Details of Chinese translation of php.ini configuration file

web front end six thousand nine hundred and seventy-two 13 years ago (2011-04-27)

;; About php. ini;;
; This file must be named 'php. ini' and placed in the directory specified by the PHP INIDir directive in httpd.conf.
; The latest version of php. ini can be viewed in the following two locations:

;; Grammar;;
; The syntax of this file is very simple. Blank characters and lines beginning with semicolons are simply ignored.
; Chapter titles (for example: [php]) are also simply ignored, even though they may have some meaning in the future.
; The format of the setting command is as follows:
; directive = value
; The directive is case sensitive! So "foo=bar" is different from "FOO=bar".
; The value can be:
; 1. String defined with quotation marks (such as "foo")
; 2. A number (integer or floating point number, such as 0, 1, 34, - 1, 33.55)
; 3. A PHP constant (such as E_ALL, M_PI)
; 4. An INI constant (On, Off, none)
; 5. An expression (such as E_ALL&~E_NOTICE)
; The expressions in the INI file only use: bit operators, logical non, parentheses:
; | Bit or
; & Bit and
; ~ Bitwise negation
; ! Logical negation
; The Boolean flag uses On to indicate on and Off to indicate off.
; An empty string can be represented by not writing anything after the equal sign, or by using the none keyword:
; foo =         ; Set foo as an empty string
; foo = none    ; Set foo as an empty string
; foo = "none"  ; Set foo to the string 'none'
; If you use constants in dynamic extensions (PHP extensions or Zend extensions) in instruction values,
; Then you can only use these constants after loading these dynamically extended command lines.

;;   httpd.conf  ;;
; You can override the value of php.ini for a specific virtual host or directory in httpd.conf for more flexible configuration:
; php_ admin_ value name value  ; Set non bool instructions. Set value to none to clear previous settings
; php_ admin_ flag  name on|off ; Only used to set bool type instructions
; [Tip] Because many commands do not allow you to use php_ value/php_ Flag, so it is not recommended to use these two.
; PHP constants (such as E_ALL) can only be used in php.ini, and corresponding mask values must be used in httpd.conf.

; [Updated on March 2, 2008]
;;===================================== Configuration Instruction Details========================================
; The set values of each of the following commands are the same as the default values built in PHP-5.2.5.
; That is, if 'php. ini' does not exist, or you delete some lines, the default value is the same.

;;   Apache  ;;
; Only valid when PHP is used as an Apache module.

child_ terminate = Off
; PHP script Whether to allow the use of Apache after the request ends_ child_ The terminate () function terminates the child process.
; This directive is only available when PHP is installed as a module of Apache 1.3 on UNIX platforms. It does not exist under other circumstances.

engine = On
; Whether to enable the PHP parsing engine.
; Tip: You can turn on or off the PHP parsing engine in httpd.conf based on the directory or virtual host.

last_ modified = Off
; Whether to place the last modification time of the PHP script in the Last Modified response header.

xbithack = Off
; Whether it is parsed as PHP executable bits regardless of the end of the file.

;; PHP core;;

; The first four configuration options are currently only used for date_ Sunrise() and date_ The sunset() function.

date.default_ latitude = 31.7667
; Default Latitude

date.default_ longitude = 35.2333
; Default Longitude

date.sunrise_ zenith = 90.583333
; Default Sunrise Zenith

date.sunset_ zenith = 90.583333
; Default sunset zenith

date.timezone =
; The default time zone used for all date and time functions when the TZ environment variable is not set.
; Mainland China should use "PRC"
; The priority of application time zone is:
; 1. Use date_ default_ timezone_ The time zone set by the set() function (if set)
; 2. TZ environment variable (if not empty)
; 3. Value of the command (if set)
; 4. PHP speculates by itself (if supported by the operating system)
; 5. If none of the above is successful, use "UTC"

[PHP-Core-Assert] = On
; Whether to enable assert() assertion evaluation

assert.bail = Off
; Whether to abort script execution when failure assertion occurs

assert.callback =
; Callback function executed when failure assertion occurs

assert.quiet_ eval = Off
; Whether to use quiet evaluation (no error message is displayed, equivalent to error_reporting=0).
; If it is closed, the current error will be used when evaluating the assertion expression_ Reporting command value.

assert.warning = On
; Whether to issue a warning for each failed assertion

; Security mode is used to solve sharing The server Is set up on the basis of safety problems.
; However, it is not reasonable in structure to try to solve this problem in the PHP layer,
; The correct approach should be to modify the web server layer and the operating system layer.
; Therefore, the security mode is abolished in PHP 6, and the open based_ Basedir security protection.
; This part of instructions has been deleted in PHP6.

safe_ mode = Off
; Whether to enable safe mode.
; When opened, PHP will check whether the owner of the current script is the same as the owner of the file being operated,
; The same operation is allowed, and the different operation is rejected.

safe_ mode_ gid = Off
; In security mode, UID comparison check is performed by default when accessing files.
; However, in some cases, strict UID check is not suitable, and loose GID check is enough.
; If you want to expand it to only GID comparison, you can open this parameter.

safe_ mode_ allowed_ env_ vars = "PHP_"
; In safe mode, users can only change the prefix list of environment variables (comma separated).
; Allowing users to set certain environment variables may lead to potential security vulnerabilities.
; Note: If this parameter value is empty, PHP will allow the user to change any environment variable!

safe_ mode_ protected_ env_ vars = "LD_LIBRARY_PATH"
; A comma separated list of environment variables that users cannot change in safe mode.
; These variables even in safe_ mode_ allowed_ env_ If the vars directive is set to allow, it will also be protected.

safe_ mode_ exec_ dir = "/usr/local/php/bin"
; In the security mode, only the executable programs in this directory are allowed to be executed by the functions of the executed system programs.
; These functions are: system, escapeshelllarge, escapeshellcmd, exec, passthru,
; proc_ close, proc_ get_ status, proc_ nice, proc_ open, proc_ terminate, shell_ exec

safe_ mode_ include_ dir =
; In security mode, when the files in this group directory and its subdirectories are included, the UID/GID check will be skipped.
; In other words, if the value here is empty, any UID/GID inconsistent files are not allowed to be included.
; The directory set here must already exist in include_ The path directive can be included with the full path.
; Multiple directories are separated by colons (semicolons under Win).
; The specified limit is actually a prefix, not a directory name,
; That is, "/dir/include" will allow access to "/dir/include" and "/dir/includes"
; If you want to control access in a specified directory, please add a slash at the end.


allow_ url_ fopen = On
; Allow opening remote files

allow_ url_ include = Off
; Whether to allow include/require remote files.

disable_ classes =
; This directive accepts a comma separated list of class names to disable a specific class.

disable_ functions =
; This directive accepts a comma separated list of function names to disable specific functions.

enable_ dl = On
; Whether the dl() function is allowed. The dl() function is only valid when PHP is installed as an Apache module.
; The dl() function is disabled mainly for security reasons, because it can bypass open_ Limitations of the basedir directive.
; The dl() function is always disabled in safe mode, regardless of how it is set here.
; The instruction is deleted in PHP6, which is equivalent to setting it as Off.

expose_ php = On
; Whether to expose the fact that PHP is installed on the server (add it in the http header autograph )。
; It does not pose a direct threat to security, but it makes the client know that PHP is installed on the server.

open_ basedir =
; All files (including the file itself) that PHP allows to operate are restricted to this list of directories.
; When a script attempts to open a file outside the specified directory tree, it will be rejected.
; All symbolic links will be resolved, so it is impossible to avoid this restriction through symbolic links.
; Special value '.' The directory specified for storing this script will be used as the base directory,
; But this is a bit dangerous, because the working directory of the script can be easily changed by chdir().
; For shared servers, it is very useful to flexibly set this directive in httpd.conf for different virtual hosts or directories.
; Separate directories with semicolons in Windows and colons in UNIX systems.
; As an Apache module, open in the parent directory_ The basedir path will be automatically inherited.
; The specified limit is actually a prefix, not a directory name,
; That is, "/dir/include" will allow access to "/dir/include" and "/dir/includes",
; If you want to control access in a specified directory, please add a slash at the end.
; The default is to allow all files to be opened.

sql.safe_ mode = Off
; Whether to use SQL security mode.
; If on, specify the default value of data base The linking function will use these default values in place of the supported parameters.
; For the connection function of each different database, please refer to the corresponding manual page for its default value.


error_ reporting = E_ ALL & ~E_ NOTICE
; The error reporting level is the superposition of bit fields, and E is recommended_ ALL | E_ STRICT
;     1  E_ ERROR Fatal runtime error
;     2  E_ WARNING runtime warning (non fatal error)
;     4  E_ Parse error at compile time
;     8  E_ NOTICE runtime reminder (often a bug, or it may be intentional)
;    16  E_ CORE_ ERROR Fatal error during initialization of PHP startup
;    32  E_ CORE_ Warning during initialization of WARNING PHP startup (non fatal error)
;    64  E_ COMPILE_ ERROR compile time fatal error
;   128  E_ COMPILE_ WARNING compile time warning (non fatal error)
;   256  E_ USER_ ERROR User defined fatal error
;   512  E_ USER_ WARNING User defined warnings (non fatal errors)
; 1024  E_ USER_ NOTICE User defined reminders (often bugs, or intentional)
; 2048  E_ STRICT coding standardization warning (how to modify it for forward compatibility is recommended)
; 4096  E_ RECOVERABLE_ ERROR is a near fatal runtime error. If it is not captured, it will be regarded as E_ ERROR
; 6143  E_ ALL divide by E_ All errors except STRICT (8191 in PHP6, that is, all errors are included)
; You can also use 2147483647 (all binary bits are 1) to open various errors that may occur now or in the future

track_ errors = Off
; Whether it is in the variable $php_ The latest error or warning message is saved in errormsg.

display_ errors = On
; Whether to display error messages as part of the output.
; On the final published web site, it is strongly recommended that you turn off this feature and use error logs instead (see below).
; Opening this feature on the final published web site may expose some security information,
; For example, the file path, database planning or other information on your web service.

display_ startup_ errors = Off
; Whether to display errors when PHP starts.
; Even if display_ The errors command is turned on, and when this parameter is turned off, the PHP startup error will not be displayed.
; It is recommended that you turn off this feature, unless you must use it for debugging.

report_ memleaks = On
; Whether memory leaks are reported. This parameter only works in PHP compiled in debug mode,
; And must be in error_ The reporting directive contains E_ WARNING

report_ zend_ debug = On
; No documentation yet

html_ errors = On
; Whether to use HTML tags in error messages.
; Note: Do not use this feature on published sites!

docref_ root =  ; "//localhost/phpmanual/"
docref_ ext =   ; ".html"
; If html is opened_ Errors command, PHP will display hyperlinks on the error message,
; Directly link to a page that describes the error or the function that caused the error.
; You can go from Download the php manual,
; And put docref_ The root command points to the URL directory where your local manual is located.
; You must also set docref_ Ext directive to specify the file extension (must contain '.').
; Note: Do not use this feature on published sites.

error_ prepend_ string =  ; "<font color=#f00>"
; String for output before error message
error_ append_ string =   ; "</font>"
; String used for output after error message

xmlrpc_ errors = Off
xmlrpc_ error_ number = 0
; No documents yet


define_ syslog_ variables = Off
; Whether to define various system log variables, such as $LOG_ PID, $LOG_ CRON, etc.
; A good idea to turn it off to improve efficiency.
; You can call define at runtime_ syslog_ The variables () function defines these variables.

error_ log =
; The file to log the error to. The file must be writable to Web server users.
; Syslog indicates that it is recorded in the system log (event log under NT, syslog under Unix (3))
; If no value is set here, the error will be recorded in the error log of the Web server.

log_ errors = Off
; Whether to record errors in the log file depends on the error_ Log command.
; It is strongly recommended that you log errors rather than output them directly when you finally publish a web site,
; This allows you to know that there is a problem without exposing sensitive information.

log_ errors_ max_ len = 1024
; Sets the maximum length of the error source associated with the error message attached to the error log.
; The values set here compare the displayed and recorded errors and $php_ Errormsg is valid.
; Set to 0 to allow unlimited length.

ignore_ repeated_ errors = Off
; Whether to ignore repeated error messages when logging error logs.
; Error messages must appear on the same line of the same file to be considered duplicate.

ignore_ repeated_ source = Off
; Whether to ignore duplicate error sources when ignoring duplicate error messages.

; To make mail functions available, PHP must be able to access the sendmail program at compile time.
; If you use other mail programs, such as qmail or postfix, make sure you use the corresponding sendmail wrapper.
; PHP will first search sendmail in the PATH environment variable of the system, and then search in the following order:
; / usr/bin:/usr/sbin:/usr/etc:/etc:/usr/ucblib:/usr/lib
; It is strongly recommended to find sendmail in PATH.
; In addition, the user compiling PHP must be able to access the sendmail program.

SMTP = "localhost"
; The host name or IP address of the SMTP server used to send mail in the mail() function. For win32 only.

smtp_ port = 25
; The port number of the SMTP server. For win32 only.

sendmail_ from =
; The mail address in the "From:" header used when sending mail. Only for win32
; This option also sets the "Return Path:" header.

sendmail_ path = "-t -i"
; It is only used for unix, and can also support parameters (the default is' sendmail - t - i ')
; The path of the sendmail program, usually "/usr/sbin/sendmail or/usr/lib/sendmail".
; The configure script will try to find the program and set it as the default value, but if it fails, it can be set here.
; Systems that do not use sendmail should set this command as a sendmail alternative, if any.
; For example, Qmail users can usually be set to "/var/qmail/bin/sendmail" or "/var/qmail/bin/qmail injection".
; Qmail injection does not need any options to process mail correctly.

mail.force_ extra_ parameters =
; The mandatory additional parameter value passed to the sendmail library as an additional parameter.
; These parameters always replace the fifth parameter of mail (), even in safe mode.


default_ socket_ timeout = 60
; Default socket timeout (seconds)

max_ execution_ time = 30
; The maximum allowed execution time of each script (seconds). 0 means no limit.
; This parameter helps prevent poor quality scripts from consuming server resources endlessly.
; This instruction only affects the running time of the script itself,
; For example, the use of system()/sleep() function, database query, file upload, etc. are not included.
; In safe mode, you cannot use ini_ Set () changes this setting at runtime.

memory_ limit = 128M
; The maximum number of memory bytes that a script can request (K and M can be used as units).
; This helps prevent poor quality scripts from consuming all memory on the server.
; To be able to use this directive, you must use the "-- enable memory limit" configuration option at compile time.
; If you want to remove the memory limit, you must set it to - 1.
; After the command is set, memory_ get_ The usage () function becomes available.

max_ input_ time = -1
; The maximum allowed time (seconds) for each script to parse input data (POST, GET, upload).
; - 1 means no restriction.

max_ input_ nesting_ level = 64
; Maximum nesting depth of input variables (no more explanation documents available)

post_ max_ size = 8M
; The maximum allowed length of POST data bytes. This setting also affects file upload.
; If POST data exceeds the limit, then$_ POST and$_ FILES will be empty.
; To upload large files, the value must be greater than upload_ max_ The value of the filesize directive.
; If memory limit is enabled, this value should be less than memory_ The value of the limit instruction.

realpath_ cache_ size = 16K
; Specifies the size of the realpath (normalized absolute pathname) buffer used by PHP.
; On systems where PHP opens a large number of files, you should increase this value to improve performance.

realpath_ cache_ ttl = 120
; The validity period (in seconds) of the information in the realpath buffer.
; For systems with few file changes, you can increase this value to improve performance.


file_ uploads = On
; Whether to allow HTTP file upload.
; See upload_ max_ filesize, upload_ tmp_ dir, post_ max_ Size instruction

upload_ max_ filesize = 2M
; The maximum size of the file allowed to upload.

upload_ tmp_ dir =
; The temporary directory where files are stored when uploading files (must be a directory writable by PHP process users).
; If not specified, PHP uses the system default temporary directory.

; PHP6 deletes the following commands, which is equivalent to Off

magic_ quotes_ gpc = Off
; Whether to use automatic string escape ('" NULL) for the input GET/POST/cookie data.
; The settings here will automatically affect$_ GEST $_ POST $_ The value of the COOKIE array.
; If this command is combined with magic_ quotes_ If the sybase directive is opened at the same time, only the single quotation mark ('') will be escaped as (''),
; Other special characters will not be escaped, that is, (" NULL) will remain the same!!
; It is recommended to turn this feature off and use a custom filter function.

magic_ quotes_ runtime = Off
; Whether to use automatic string escape ('" NULL) for data generated from external resources at runtime.
; If this instruction is opened, most functions will escape data returned from external resources (databases, text files, etc.).
; For example: data obtained by SQL query, data obtained by exec() function, etc
; If this command is combined with magic_ quotes_ If the sybase directive is opened at the same time, only the single quotation mark ('') will be escaped as (''),
; Other special characters will not be escaped, that is, (" NULL) will remain the same!!
; It is recommended to turn off this feature and use a custom filter function as appropriate.

magic_ quotes_ sybase = Off
; Whether to use automatic string escape in Sybase form (represented by '')

[PHP-Core-HighLight] = "#FFFFFF"
highlight.comment = "#FF8000"
highlight.default = "#0000BB"
highlight.html = "#000000"
highlight.keyword = "#007700"
highlight.string = "#DD0000"
; The color of the syntax highlighting mode (usually used to display. phps files).
; Anything that can be accepted by<font color=xxx>will work normally.


short_ open_ tag = On
; Whether "<??>" short identification is allowed. Otherwise, "<? Php?>" long identification must be used.
; Unless your php program only runs in a controlled environment and is only for your own use, please do not use short tags.
; If you want to use PHP with XML, you can choose to turn off this option to facilitate direct embedding of "<? Xml...?>",
; Otherwise, you must use PHP to output:<? echo '<? xml version="1.0"'; ?>
; This instruction also affects the abbreviation "<?=", which is equivalent to "<? Echo". To use it, you must also open the short tag.

ASP _ tags = Off
; Whether the ASP style tag "<%%>" is allowed will also affect the abbreviation "<%=".
; This command will be deleted in PHP 6

arg_ separator.output = "&"
; The separator used to separate parameters in the URL generated by PHP.
; You can also use "&amp;" or "," and so on.

arg_ separator.input = "&"
; List of separators used by PHP when parsing variables in URLs.
; Each character in the string is treated as a separator.
; You can also use ",&" and so on.

allow_ call_ time_ pass_ reference = On
; Whether to force parameters to be passed by reference when calling a function (you will receive a warning every time you use this attribute).
; PHP opposes this practice, and deletes this instruction in PHP 6 (equivalent to setting it as Off), because it affects code cleanliness.
; It is encouraged to explicitly specify which parameters are passed by reference in the function declaration.
; We encourage you to turn off this option to ensure that your script will still work in future versions of the language.

auto_ globals_ jit = On
; Is it only used to$_ SERVER and$_ ENV variables are created only when the script is started (rather than automatically created when the script is started).
; If these two arrays are not used in the script, opening this instruction will improve the performance.
; To make this directive take effect, register must be closed_ Globals and register_ long_ Arrays instruction.

auto_ prepend_ file =
auto_ append_ file  =
; Specifies the file name that is automatically resolved before/after the main file. A blank disables the property.
; The file is included as if the include() function was called, so include will be used_ The value of the path directive.
; Note: If the script is terminated by exit(), the automatic suffix will not occur.

variables_ order = "EGPCS"
; PHP registers the order of environment, GET, POST, cookie, and server variables.
; Represented by E, G, P, C, S respectively, register from left to right, and the new value will overwrite the old value.
; For example, setting it to "GP" will cause POST variables to overwrite GET variables with the same name,
; The environment, cookie, and server variables are completely ignored.
; It is recommended to use "GPC" or "GPCS" and use the getenv() function to access environment variables.

register_ globals = Off
; Whether to register E, G, P, C, S variables as global variables.
; Opening this command may cause serious security problems unless your script has been carefully checked.
; Predefined super global variables are recommended:$_ ENV, $_ GET, $_ POST, $_ COOKIE, $_ SERVER
; The instruction is subject to variables_ The impact of the order instruction.
; This instruction has been deleted in PHP 6.

register_ argc_ argv = On
; Whether to declare $argv and $argc global variables (including the information of GET method).
; It is recommended not to use these two variables and turn off the command to improve performance.

register_ long_ arrays = On
; Whether to enable the legacy long array (HTTP_ * _VARS).
; Encourage the use of short, predefined super global arrays and turn this feature off for better performance.
; This instruction has been deleted in PHP 6.

always_ populate_ raw_ post_ data = Off
; Whether to always generate $HTTP_ RAW_ POST_ DATA variable (raw POST data).
; Otherwise, this variable is generated only when data of unrecognized MIME type is encountered.
; However, a better way to access the raw POST data is php://input
; $ HTTP_ RAW_ POST_ DATA is not available for form data with enctype="multipart/form data".

unserialize_ callback_ func =
; If the deserialization processor needs to instantiate an undefined class,
; The callback function specified here will be called by unserialize() with the name of the undefined class as a parameter,
; To avoid getting incomplete "__PHP_Incomplete_Class" objects.
; If no function is specified here, or the specified function does not contain (or implement) the undefined class, a warning message will be displayed.
; Therefore, this instruction is set only when it is really necessary to implement such a callback function.
; To disable this feature, just leave it blank.

y2k_ compliance = On
; Whether it is forced to open the year 2000 adaptation (which may not be adapted to Y2K browser Caused the problem).

zend.ze1_ compatibility_ mode = Off
; Whether to use the mode compatible with Zend Engine I (PHP 4. x). The instruction will be deleted in PHP 6 (equivalent to Off).
; This will affect object replication, construction (objects without attributes will generate FALSE or 0), and comparison.
; In compatibility mode, objects are passed by value instead of by reference by default.

precision = 14
; The number of significant digits of floating point data display.

serialize_ precision = 100
; Precision (significant digits) when serializing and storing floating point and double precision data.
; The default value ensures that floating point data will not be lost when decoded by the deserializer.

; The output control function is very useful, especially when the HTTP header is sent after the information has been output.
; The output control function will not act on HTTP headers sent by functions such as header () or setcookie (),
; It will only affect information similar to the output of the echo () function and information embedded in PHP code.

implicit_ flush = Off
; Whether the PHP output layer is required to automatically refresh data after each output block.
; This is equivalent to automatically calling the flush() function after each print (), echo (), and HTML block.
; Turning this option on has a serious impact on the performance of program execution, and is generally recommended only for debugging.
; In the CLI SAPI execution mode, the instruction defaults to On.

output_ buffering = 0
; Output buffer size in bytes. The recommended value is 4096~8192.
; Output buffering allows you to send HTTP headers (including cookies) even after outputting body content.
; The cost is that the output layer slows down a bit.
; Setting the output buffer can reduce the number of writes and sometimes the number of network packets sent.
; The actual benefits of this parameter largely depend on what Web server you use and what script you use.

output_ handler =
; Redirects the output of all scripts to an output handler.
; For example, redirect to mb_ output_ The character encoding will be transparent To the specified encoding.
; Once you specify an output handler here, the output buffer will be automatically opened (output_buffering=4096).
; Note 0: Only PHP built-in functions can be used here. User defined functions should use ob in the script_ Start().
; Note 1: Portable scripts cannot rely on this instruction, but should use ob_ The start() function explicitly specifies the output handler.
; Using this command may cause errors in some scripts that you are not familiar with.
; Note 2: You cannot use two output processing functions "mb_output_handler" and "ob_iconv_handler" at the same time.
; You cannot use the "ob_gzhandler" output processing function and zlib.output at the same time_ The compression instruction.
; Note 3: If zlib.output is used_ The handler instruction enables zlib output compression, which must be empty.


include_ path = ".:/path/to/php/pear"
; Specify a set of directories for require(), include(), fopen_ with_ The path () function looks for a file.
; The format is similar to the PATH environment variable of the system (separated by colon under UNIX and semicolon under Windows):
; UNIX: "/path1:/path2"
; Windows: "\path1;\path2"
; Use '.' in the included path You can allow a relative path, which represents the current directory.

user_ dir =
; Tell php which directory to look for when using/~username to open the script. It is only valid when it is not empty.
; That is, use the basic directory name of the PHP file under the user directory, for example: "public_html"

extension_ dir = "/path/to/php"
; The directory where extension libraries (modules) are stored, that is, the directory PHP uses to find dynamic extension modules.
; The default value for Windows is "C:/php5"


default_ mimetype = "text/html"
default_ charset =  ; "gb2312"
; PHP will automatically output the "Content Type: text/html" HTTP header by default.
; If the default_ The charset instruction is set to "gb2312",
; "Content Type: text/html; charset=gb2312" will be automatically output.
; PHP 6 opposes using default_ Charset instruction, and unicode. output is recommended_ Encoding instruction.

; PHP6 provides comprehensive Unicode support based on the ICU (International Components for Unicode) library.
; When compiling, you need to use -- with icu dir=<dir>to specify the installation location of ICU header files and libraries.
; Remove detection_ Except for unicode, other instructions are newly added in PHP 6.
; PHP6 information is still lacking, so this part may be incomplete or even wrong.

detect_ unicode = On
; Indicates whether the Zend engine detects whether the script contains multi byte characters by checking the BOM (byte order mark) of the script.
; It is recommended to close. PHP6 has canceled this command and used unicode.script_ Encoding instruction instead of its function.

unicode.semantics = Off
; Whether to enable Unicode support.
; If you open this command, PHP will become a complete Unicode environment, such as:
; All strings and variables accepted from HTTP will become Unicode, and all PHP identifiers can also use Unicode characters.
; Moreover, PHP will use Unicode strings internally and be responsible for the automatic conversion of surrounding non Unicode characters,
; For example, HTTP input/output, stream, file system operation, etc. Even php. ini itself will be parsed according to UTF-8 encoding.
; After enabling this command, you must explicitly specify the binary string. PHP will not make any assumptions about the contents of binary strings,
; Therefore, your program must ensure that it can properly handle binary strings.
; If you close this command, PHP will behave exactly the same as before:
; Strings will not become Unicode, files and binary strings will be backward compatible, and php.ini will also be parsed in the "as is" style.
; All functions and operators transparently support Unicode strings, regardless of whether this instruction is opened or not.

unicode.fallback_ encoding = UTF-8
; For all other unicodes*_ The encoding directive sets the default value.
; That is to say, if a unicode*_ If the encoding instruction is not explicitly set, the value set here will be used.

unicode.runtime_ encoding =
; Runtime encoding specifies the encoding used by the PHP engine to convert binary strings internally.
; The settings here have no effect on I/O related operations (such as writing standard output/reading file system/decoding HTTP input variables).
; PHP also allows you to explicitly convert strings:
; (binary) $str -- convert to binary string
; (unicode) $str -- convert to Unicode string
; (string) $str -- convert to Unicode string if unicode.semantics is On, otherwise convert to binary string
; For example, if the value of the instruction is iso-8859-1 and $uni is a Unicode string, then
; $ str = (binary)$uni
; It will wait for a binary string encoded with iso-8859-1.
; PHP will implicitly convert relevant strings to Unicode before connecting, comparing, passing parameters and other operations, and then perform operations.
; For example, when connecting binary strings with Unicode,
; PHP will use the settings here to convert binary strings to Unicode strings, and then operate.

unicode.output_ encoding =
; Encoding used by PHP to output non binary strings.
; Automatically convert output content such as' print 'and' echo 'to the encoding set here (not binary strings).
; When writing data to external resources such as files,
; You must rely on stream encoding features or manually encode data using Unicode extended functions.
; Oppose using the previous default in PHP 6_ Charset instruction, which is recommended.
; Previous default_ The charset directive only specifies the character set in the Content Type header, and does not convert the actual output.
; In PHP 6, the default_ The charset instruction is only valid when unicode. semantics is off.
; After the instruction is set, the value of the instruction will be filled in the 'charset' section of the Content Type output header,
; Regardless of default_ How the charset instruction is set.

unicode.http_ input_ encoding =
; Encoding of variables (such as $_GET and _ $POST) obtained through HTTP.
; This feature is still under development until April 2007

unicode.filesystem_ encoding =
; The directory name and file name encoding of the file system.
; File system related functions (such as opendir()) will use this code to accept and return file names and directory names.
; The settings here must be exactly the same as the actual encoding used by the file system.

unicode.script_ encoding =
; The default encoding of the PHP script itself.
; You can use any ICU supported code to write PHP scripts.
; If you want to set the code for a separate script file, you can use it at the beginning of the script
;    <? php declare(encoding = 'Shift-JIS'); ?>
; To specify. Note: It must start from the first line, without any characters (including blank).
; This method can only affect the script where it is located, and will not affect any other included scripts.

unicode.stream_ encoding = UTF-8
unicode.from_ error_ mode = 2
unicode.from_ error_ subst_ char = 3f
; No documents yet


auto_ detect_ line_ endings = Off
; Whether to let PHP automatically detect the end of line (EOL).
; If your script must process Macintosh files,
; Or you can run on a Macintosh and process unix or win32 files at the same time,
; Opening this command allows PHP to automatically detect EOL so that fgets() and file() functions can work properly.
; However, it will also lead to incompatible behaviors for those who use the carriage return character (CR) as the item separator in the Unix system.
; In addition, there will be a small performance loss when detecting EOL habits in the first line.

browscap =  ; "c:/windows/system32/inetsrv/browscap.ini"
; Only PWS and IIS need this setting

ignore_ user_ abort = Off
; Whether to persist in completing the entire request even after the user aborts the request.
; When executing a long request, you should consider opening it,
; Because a long request may cause the user to abort halfway or the browser to timeout.

user_ agent =  ; "PHP"
; Define the "User Agent" string

; url_ rewriter.tags = "a=href,area=href,frame=src,form=,fieldset="
; Although this instruction belongs to the core part of PHP, it is used for the configuration of the Session module

; extension =
; Load dynamic extensions at PHP startup. For example:
; After "=", only the name of the module file can be used, but not the path information.
; The path information should only be determined by the extension_ The dir instruction is provided.
; The following extensions have been built in on Windows:
; bcmath ; calendar ; com_ dotnet ; ctype ; session ; filter ; ftp ; hash
; iconv ; json ; odbc ; pcre ; Reflection ; date ; libxml ; standard
; tokenizer ; zlib ; SimpleXML ; dom ; SPL ; wddx ; xml ; xmlreader ; xmlwriter

; These instructions are only valid when PHP is running in CGI mode

doc_ root =
; "CGI root directory" of PHP. Valid only when not empty.
; It is considered unsafe to place executable programs/scripts in the main document directory of the web server (such as "htdocs"),
; For example, scripts are displayed as normal html due to configuration errors.
; Therefore, many system administrators will set a directory outside the main document directory that can only be accessed through CGI,
; The contents in this directory will only be parsed and will not be displayed as is.
; If this option is set, PHP will only interpret doc_ Files in the root directory,
; And ensure that scripts outside the directory will not be executed by the PHP interpreter (except user_dir).
; If FORCE is not specified when compiling PHP_ REDIRECT, and run in CGI mode on non IIS servers,
; This command must be set (see the safety section in the manual).
; The alternative is to use cgi.force_ The redirect command.

cgi.discard_ path = Off
; There is no document (new instruction in PHP6)

cgi.fix_ pathinfo = On
; Whether the real PATH is provided for CGI_ INFO/PATH_ TRANSLATED support (cgi compliant).
; The previous action was to put PATH_ TRANSLATED is set to SCRIPT_ FILENAME, regardless of PATH_ What is INFO.
; Turning this option on will cause PHP to correct its path to comply with CGI specifications, otherwise it will still use the old style irregular behavior.
; You are encouraged to open this command and fix the script to use SCRIPT_ FILENAME instead of PATH_ TRANSLATED 。
; About PATH_ For more information on INFO, see the cgi specification.

cgi.force_ redirect = On
; Whether to open cgi forced redirection. It is strongly recommended to open it to provide security protection for PHP running in CGI mode.
; If you close it yourself, please be responsible for the consequences.
; Note: It must be closed on IIS/OmniHTTPD/Xitami!

cgi.redirect_ status_ env =
; If cgi.force_ Redirect=On, and run PHP on servers other than Apache and Netscape,
; You may need to set a cgi redirection environment variable name, and PHP will look for it to know whether it can continue to execute.
; Setting this variable will lead to security vulnerabilities. Be sure to know what you are doing before setting it.

cgi.rfc2616_ headers = 0
; Specifies which header PHP uses when sending HTTP response code.
; 0 means to send a "Status:" header, which is supported by Apache and other web servers.
; If set to 1, PHP uses the RFC2616 standard header.
; Keep its default value of 0 unless you know what you are doing

cgi.nph = Off
; Whether to force all requests to send "Status: 200" status codes in CGI mode.

cgi.check_ shebang_ line =On
; CGI PHP checks whether the top of the script is marked with #! The starting line.
; If the script wants to run both independently and in PHP CGI mode, this starting line is required.
; If you open this command, PHP in CGI mode will skip this line.

fastcgi.impersonate = Off
; FastCGI in IIS supports the ability to imitate client security tokens.
; This enables IIS to define the security context of the request on which the runtime is based.
; Mod in Apache_ Fastcgi does not support this feature (03/17/2002)
; If running in IIS, it is set to On, and the default is Off.

fastcgi.logging = On
; Whether to record the connection through FastCGI.

; These options exist only in the document, but not in the output of the phpinfo () function

async_ send = Off
; Whether to send asynchronously.

from =  ; " "
; Define the password of anonymous ftp (an email address)

;; Near core module;;

; Perl compatible regular expression module

pcre.backtrack_ limit = 100000
; The maximum backtracking steps of PCRE.

pcre.recursion_ limit = 100000
; The maximum recursion depth of the PCRE.
; If you set this value very high, the stack space of the process may be exhausted, leading to PHP crash.

; Unless session is used_ Register() or$_ SESSION registered a variable.
; Otherwise, no matter whether session is used_ Start() will not automatically add any session records.
; Objects including resource variables or with circular references contain objects that point to their own references and cannot be saved in the session.
; register_ The globals directive affects the storage and recovery of session variables.

session.save_ handler = "files"
; The name of the processor that stores and retrieves the data associated with the session. The default is files.
; If you want to use a custom processor (such as a database based processor), you can use "user".
; If it is set to "memcache", you can use memcache as the session processor (you need to specify the "-- enable memcache session" compilation option).

session.save_ path = "/tmp"
; Parameters passed to the storage processor. For the files processor, this value is the path to create the session data file.
; Under Windows, the default is the temporary folder path.
; You can use the "N; [MODE;]/path" mode to define the path (N is an integer).
; N means that the subdirectory with N-level depth is used instead of saving all data files in one directory.
; [MODE;] Optional. It must use octal numbers. The default value is "600", which indicates the access permission of the file.
; This is a good idea to improve the performance of a large number of sessions.
; Note 0: The double quotation marks around "N; [MODE;]/path" cannot be omitted.
; Note 1: [MODE;] does not overwrite the umask of the process.
; Note 2: php will not automatically create these folder structures. Please use mod in the ext/session directory_ The script is created.
; Note 3: If the folder can be accessed by insecure users (such as the default "/tmp"), a security vulnerability will be created.
; Note 4: When N>0, automatic garbage collection will become invalid. See the following section on garbage collection for details.
; [Security Tip] It is recommended to set different directories for each different virtual host.
; For the "memcache" processor, you need to define a comma separated server URL to store session data.
; For example:“ tcp://host1:11211 , tcp://host2:11211 "
; Each URL can contain the parameters passed to that server. The available parameters are the same as the Memcache:: addServer() method.
; For example:“ tcp://host1:11211?persistent=1&weight=1&timeout=1&retry_interval=15 " = "PHPSESSID"
; The session ID identifier used in cookies can only contain letters and numbers.

session.auto_ start = Off
; The session is automatically initialized when the customer visits any page, which is disabled by default.
; Because class definitions must be loaded before the session starts, if you turn this option on, you cannot store objects in the session.

session.serialize_ handler = "php"
; The processor used to serialize/deserialize data. PHP is the standard serialization/deserialization processor.
; You can also use "php_binary". When WDDX support is enabled, only "wddx" can be used.

session.gc_ probability = 1
session.gc_ divisor = 100
; Defines the probability of starting the garbage collector each time a session is initialized.
; The collection probability formula is as follows: session.gc_ probability/session.gc_ divisor
; The more frequently you visit the session page, the smaller the probability should be. The recommended value is 1/1000~5000.

session.gc_ maxlifetime = 1440
; After the number of seconds specified by this parameter is exceeded, the saved data will be treated as' garbage 'and cleaned up by the garbage collector.
; The judgment standard is the time when the data was last accessed (for FAT file system, the time when the data was last refreshed).
; If multiple scripts share the same session.save_ Path directory but session.gc_ The maxlifetime is different,
; Then all session.gc_ The minimum value in the maxlifetime directive prevails.
; If you use multiple subdirectories to store data files, the garbage collector will not start automatically.
; You must use a shell script, cron items, or other methods that you write yourself to perform garbage collection.
; For example, the following script is equivalent to setting "session. gc_maxlifetime=1440" (24 minutes):
; cd /path/to/sessions; find -cmin +24 | xargs rm

session.referer_ check =
; If the "Referer" field in the request header does not contain the string specified here, the session ID will be considered invalid.
; Note: If there is no "Referer" field in the request header, the session ID will still be considered valid.
; It is blank by default, that is, no check is performed (all are considered valid).

session.entropy_ file =  ; "/dev/urandom"
; Additional external high entropy resources (files) used to create session IDs,
; For example, "/dev/random" or "/dev/urandom" on UNIX systems

session.entropy_ length = 0
; Number of bytes read from high entropy resources (recommended value: 16).

session.use_ cookies = On
; Whether to use cookies to save the session ID on the client

session.use_ only_ cookies = Off
; Whether to use cookies only to save session IDs on the client. The default value for PHP6 is On.
; Turn on this option to avoid the security problem caused by using URL to deliver the session.
; However, clients that disable cookies will make the session inoperable.

session.cookie_ lifetime = 0
; The cookie validity period of the session ID is passed in seconds. 0 means it is valid only when the browser is open.
; [Note] If you cannot guarantee that the server time is strictly consistent with the client time, please do not change this default value!

session.cookie_ path = "/"
; The cookie action path that passes the session ID.

session.cookie_ domain =
; The cookie scope that passes the session ID.
; Null by default indicates the hostname generated according to the cookie specification.

session.cookie_ secure = Off
; Whether to send cookies only over a secure connection (https).

session.cookie_ httponly = Off
; Whether to add the httpOnly flag in the cookie (only HTTP protocol access is allowed),
; This will cause the client script (JavaScript, etc.) to fail to access the cookie.
; Opening this command can effectively prevent session ID hijacking through XSS attacks.

session.cache_ limiter = "nocache"
; Set to {nocache | private | public} to specify the cache control mode of the session page,
; Or set it to null to prevent sending the command to disable caching in the http response header.

session.cache_ expire = 180
; Specify the validity period of the session page in the client cache (minutes)
; session.cache_ When limiter=nocache, the setting here is invalid.

session.use_ trans_ sid = Off
; Whether to use clear code to display the SID (session ID) in the URL.
; It is disabled by default, because it will bring security risks to your users:
; 1 - The user may send the URL containing a valid sid through email/irc/QQ/MSN Tell others the way.
; 2 - URLs containing valid sids may be saved on public computers.
; 3 - Users may save URLs with fixed sids in their favorites or browsing history.
; URL based session management is always more risky than cookie based session management, so it should be disabled.

session.bug_ compat_ 42 = On
session.bug_ compat_ warn = On
; There is an unspecified "BUG" in versions before PHP 4.2:
; Even in register_ Global session variables can also be initialized when globals=Off,
; If you use this feature in versions after PHP 4.3, a warning will be displayed.
; It is recommended to turn off the "BUG" and display a warning. PHP6 deletes these two commands, which is equivalent to setting them all to Off.

session.hash_ function = 0
; Hash algorithm for generating SID. SHA-1 is more secure
; 0: MD5   (128 bits)
; 1: SHA-1 (160 bits)
; SHA-1 is recommended.

session.hash_ bits_ per_ character = 4
; Specifies how many bits are saved in each character in the SID string,
; These binary numbers are the results of the hash function.
; 4: 0-9, a-f
; 5: 0-9, a-v
; 6: 0-9, a-z, A-Z, "-", ","
; The recommended value is 5

url_ rewriter.tags = "a=href,area=href,frame=src,form=,fieldset="
; This instruction belongs to the PHP core, not the Session module.
; Specify which HTML tags to rewrite to include SID (only valid when session. use_trans_sid=On)
; Form and fieldset are special:
; If you include them, the URL Rewriter will add a hidden "<input>", which contains information that should be added to the URL.
; If you want to conform to the XHTML standard, remove the form item and add<fieldset>tags before and after the form fields.
; Note: All legal items need an equal sign (even if there is no value after it).
; The recommended values are "a=href, area=href, frame=src, input=src, form=fakeentry".

session.encode_ sources = "globals"
; The controversial instruction in PHP6 has not yet been decided whether to adopt it. There are no relevant documents.

;; Other modules;;

; Alternative PHP Cache is used to cache and optimize PHP intermediate code
; Compilation/installation/configuration information is in the INSTALL file under the source tree

apc.enabled = On
; Whether to enable APC? If APC is statically compiled into PHP and you want to disable it, this is the only way.

apc.enable_ cli = Off
; Whether to enable the APC function for the CLI version. This command is only opened for testing and debugging purposes.

apc.cache_ by_ default = On
; Whether buffering is enabled for all files by default.
; If it is set to Off and used with the apc.filters instruction starting with the plus sign, the file will be cached only when matching the filter.

apc.file_ update_ protection = 2
; When you modify files on a running server, you should perform atomic operations.
; That is, first write in a temporary file, and then rename the file (mv) to the final name.
; Text editor, cp, tar and other programs do not operate in this way, which may result in caching of incomplete files.
; The default value of 2 means that when accessing a file, if it is found that the modification time is less than 2 seconds from the access time, no buffering is performed.
; That unfortunate visitor may get incomplete content, but this bad effect will not be expanded through cache.
; If you can ensure that all update operations are atomic operations, you can use 0 to turn off this feature.
; If your system updates slowly due to a large number of IO operations, you need to increase this value.

apc.filters =
; A comma separated list of POSIX extended regular expressions.
; If the source file name matches any pattern, the file will not be cached.
; Note that the file name used for matching is the file name passed to include/require, not the absolute path.
; If the first character of the regular expression is "+", it means that any file matching the expression will be cached,
; If the first character is "-", no match will be cached. "-" is the default value and can be omitted.

apc.ttl = 0
; The number of seconds the cache entry is allowed to stay in the buffer. 0 means never time out. The recommended value is 7200~86400.
; Setting it to 0 means that the buffer may be filled with old cache entries, which will result in the inability to cache new entries.

apc.user_ ttl = 0
; Similar to apc.ttl, only for each user, the recommended value is 7200~86400.
; Setting it to 0 means that the buffer may be filled with old cache entries, which will result in the inability to cache new entries.

apc.gc_ ttl = 3600
; The number of seconds that cache entries can exist in the garbage collection table.
; This value provides a security measure, even if a server process crashes when executing the cached source file,
; The source file has been modified, and the memory allocated for the old version will not be recycled until the TTL value is reached.
; Set to zero to disable this feature.

apc.include_ once_ override = Off
; Optimize include_ Once() and require_ The once() function to avoid executing additional system calls.

apc.max_ file_ size = 1M
; Prevent files larger than this size from being cached.

apc.mmap_ file_ mask =
; If MMAP support is compiled for APC using -- enable map (enabled by default),
; The value here is the mktemp style file mask passed to the mmap module (the recommended value is "/tmp/apc. XXXXXX").
; This mask is used to determine whether the memory mapping area is to be file backed or shared memory backed.
; For direct file backed memory mapping, set it to "/tmp/apc. XXXXXX" (exactly 6 X's).
; To use POSIX style shm_ Open/mmap needs to be set to "/apc. shm. XXXXXX".
; You can also set it to "/dev/zero" to use the kernel's "/dev/zero" interface for anonymous mapped memory.
; If this directive is not defined, anonymous mapping is enforced.

apc.num_ files_ hint = 1000
; The approximate number of different script source code files that may be included or requested on the Web server (the recommended value is 1024~4096).
; If you are not sure, set it to 0; This setting is mainly used for sites with thousands of source files.

apc.optimization = 0
; Optimization level (recommended value is 0). The use of this directive is opposed. It may be deleted in the future.
; A positive integer value indicates that the optimizer is enabled, and the higher the value, the more aggressive the optimization will be used.
; A higher value may have a very limited speed increase, but it is still under test.

apc.report_ autofilter = Off
; Whether to record all scripts that are not automatically cached due to early/late binding.

apc.shm_ segments = 1
; Number of shared memory blocks allocated for compiler buffers (1 is recommended).
; If APC runs out of shared memory and apc.shm_ The size instruction is set to the maximum value allowed by the system, and you can try to increase this value.
; Values other than 1 in mmap mode are invalid, because the size of shared memory segments passing through mmap is unlimited.

apc.shm_ size = 30
; The size of each shared memory block (in MB, the recommended value is 128~256).
; Some systems (including most BSD variants) default to a small shared memory block size.

apc.slam_ defense = 0
; On a very busy server, whether you start a service or modify a file,
; A race condition may be caused by multiple processes attempting to cache a file at the same time.
; This directive is used to set the percentage of cache steps skipped by the process when processing files that are not cached.
; For example, setting it to 75 means that there is a 75% probability of not caching when encountering files that are not cached, thus reducing the collision probability.
; It is against using this command and is encouraged to set it to 0 to disable this feature. It is recommended to use apc.write_ The lock command.

apc.stat = On
; Whether to enable script update checking.
; Be very careful when changing this command value.
; The default value On means that APC checks whether the script is updated every time it requests a script,
; If updated, recompile and cache the compiled content automatically. However, this has a negative impact on performance.
; If it is set to Off, it means that no inspection will be carried out, thus greatly improving the performance.
; But in order for the updated content to take effect, you must restart the Web server.
; This command is also valid for include/require files. But it should be noted that,
; If you use a relative path, APC must check every time you include/require to locate the file.
; The absolute path can skip the check, so we encourage you to use the absolute path for the include/require operation.

apc.user_ entries_ hint = 4096
; Similar to num_ files_ The hint instruction is only for each different user.
; If you are not sure, set it to 0.

apc.write_ lock = On
; Whether the write lock is enabled.
; On a very busy server, whether you start a service or modify a file,
; A race condition may be caused by multiple processes attempting to cache a file at the same time.
; Enable this command to avoid race conditions.

apc.rfc1867 = Off
; After the command is opened, for each command that contains APC just before the file field_ UPLOAD_ Upload file of PROGRESS field,
; APC will automatically create an upload_< The user cache entry of key>(<key>is the APC_UPLOAD_PROGRESS field value).
; It should be noted that file upload tracking is not thread safe here,
; Therefore, if the old file has not been uploaded completely and the new file has started to upload, the tracking of the old file will be lost.

apc.rfc1867_ prefix = "upload_"
; Buffer item entry name prefix for rfc1867 upload file

apc.rfc1867_ name = "APC_UPLOAD_PROGRESS"
; The rfc1867 implied form item name of the uploaded file to be processed by APC

apc.rfc1867_ freq = 0
; User rfc1867 uploads the update frequency of file cache entries.
; The value can be a percentage of the total file size, or an absolute size ending in 'K', 'M', 'G'.
; 0 means to update as fast as possible, but this may cause the running speed to decrease.

apc.localcache = Off
; Whether to use the non locked local process shadow cache can reduce the competition between locks when writing to the buffer.

apc.localcache.size = 512
; The shadow cache of the local process should be set to a large enough value, which is approximately equal to num_ files_ Half of hint.

apc.stat_ ctime = Off
; No documents yet

; Binary Calculator is provided for any precision mathematical calculation,
; It supports numbers of any size and precision and is described in string form.

bcmath.scale = 0
; Number of 10 decimal numbers for all bcmath functions


gd.jpeg_ ignore_ warning = Off
; Whether to ignore the warning message of the jpeg decoder (for example, the image format cannot be recognized).
; There are two MIME types: image/jpeg and image/pjpeg. The GD library can only recognize the former traditional format.

; This extension module is experimental to confirm and filter data from unreliable sources.

filter.default = "unsafe_raw"
; Filter using the specified filter$_ GET,$_ POST,$_ COOKIE,$_ REQUEST data,
; The original data can be input_ Get () function access.
; "Unsafe_raw" means no filtering.

filter.default_ flags =
; filter_ The default flag for the data() function.

; Multi byte string module support

mbstring.language = "neutral"
; The default NLS (local language setting) can be set as follows:
; The default value "neutral" means neutral, equivalent to unknown.
; "Zh cn" or "Simplified Chinese" means Simplified Chinese
; "Zh tw" or "Traditional Chinese" means Traditional Chinese
; "Universal" or "universal" means Unicode
; This instruction automatically defines the following mbstring.internal_ Default value of encoding instruction,
; And mbstring.international_ The encoding directive must be placed after the directive.

mbstring.internal_ encoding =
; This directive must be placed after the mbstring.language directive.
; The default internal code depends on the value of the mbstring.language directive when it is not set:
; "Neutral" corresponds to "ISO-8859-1"
; "Zh cn" corresponds to "EUC-CN" (equivalent to "GB2312")
; "Zh tw" corresponds to "EUC-TW" (equivalent to "BIG5")
; "Uni" corresponds to "UTF-8"
; Reminder: For simplified Chinese, it can also be set to "CP936" (equivalent to "GBK")
; Note: SJIS, BIG5 and GBK may not be suitable as internal codes, but "GB2312" is certainly OK.
; Manual mandatory specification is recommended

mbstring.encoding_ translation = Off
; Whether to follow for incoming HTTP requests_ The encoding instruction performs transparent encoding conversion,
; That is to automatically detect the encoding of input characters and transparently convert them into internal encoding.
; Portable libraries or programs should never rely on automatic code conversion.

mbstring.http_ input = "pass"
; The default HTTP input code. "pass" means skip (no conversion)
; The meaning of "aotu" and mbstring.detect_ The explanation in the order instruction is the same.
; It can be set as a separate value or a comma separated list.

mbstring.http_ output = "pass"
; The default HTTP output code. "pass" means skip (no conversion)
; The meaning of "aotu" and mbstring.detect_ The explanation in the order instruction is the same.
; It can be set as a separate value or a comma separated list.
; The output must be_ The handler instruction can only be set to "mb_output_handler".

mbstring.detect_ order =
; The default code detection sequence. "pass" means skip (no conversion).
; The default value ("auto") varies with the mbstring.language directive:
; "Neutral" and "universal" correspond to "ASCII, UTF-8"
; "Simplified Chinese" corresponds to "ASCII, UTF-8, EUC-CN, CP936"
; "Traditional Chinese" corresponds to "ASCII, UTF-8, EUC-TW, BIG-5"
; It is recommended to manually force a single value in a controlled environment

mbstring.func_ overload = 0
; Automatically use mb_* The function overloads the corresponding single byte string function.
; For example, mail () and ereg () will be automatically replaced with mb_ send_ mail(), mb_ ereg()
; Bit combination can be performed with 0,1,2,4. For example, 7 means to replace all. The specific replacement description is as follows:
; 0: No replacement
; 1: mail() &rarr; mb_ send_ mail()
; 2: strlen() &rarr; mb_ strlen() ; substr() &rarr; mb_ substr()
;     strpos() &rarr; mb_ strpos() ; strrpos() &rarr; mb_ strrpos()
;     strtolower() &rarr; mb_ strtolower() ; strtoupper() &rarr; mb_ strtoupper()
;     substr_ count() &rarr; mb_ substr_ count()
; 4: ereg() &rarr; mb_ ereg() ; eregi() &rarr; mb_ eregi()
;     ereg_ replace() &rarr; mb_ ereg_ replace() ; eregi_ replace() &rarr; mb_ eregi_ replace()
;     split() &rarr; mb_ split()

mbstring.script_ encoding =
; Encoding used by the script

mbstring.strict_ detection = Off
; Whether rigorous code detection is used

mbstring.substitute_ character =
; When a character cannot be decoded, it is replaced by this character.
; If it is set as an integer, it indicates the corresponding Unicode value. If no value is set, it indicates that the error character is not displayed.
; It is recommended to set it as "□"

; An interface to the mcrypt library, which supports many block encryption algorithms.
; It is not recommended to use this module because there are too many problems. It is recommended to encrypt at the database layer.

mcrypt.algorithms_ dir =
; The directory where the default encryption algorithm module is located. Usually "/usr/local/lib/libmcrypt".
; There is no detailed description document at present, and the explanation here may be wrong.

mcrypt.modes_ dir =
; The directory where the default encryption mode module is located. Usually "/usr/local/lib/libmcrypt".
; There is no instruction document at present, and the explanation here may be wrong.

; A high-performance distributed memory object caching system maintains a unified huge hash table in memory,
; It can be used to store data in various formats, including images video , files and database retrieval results.

memcache.allow_ failover = On
; Whether to fail over transparently to other servers when encountering errors.

memcache.chunk_ size = 8192
; The data will be transferred according to the block size set by this value. Smaller values require more additional network traffic.
; If you find an unexplained decrease in speed, try increasing this value to 32768.

memcache.default_ port = 11211
; The default TCP port used when connecting to the Memcached server.

memcache.max_ failover_ attempts = 20
; How many servers can be tried at most when receiving and sending data? Open memcache.allow_ It is valid in case of failover.

memcache.hash_ strategy = "standard"
; Controls the policy of mapping keys to servers. The default value of "standard" means to use the old hash policy of the previous version.
; Setting it to "consistent" allows you to add/delete servers in the connection pool without recalculating the mapping relationship between the key and the server.

memcache.hash_ function = "crc32"
; Controls the hash function that maps the key to the server. The default value "crc32" uses the CRC32 algorithm, while "fnv" uses the FNV-1a algorithm.
; FNV-1a is slightly slower than CRC32, but the hashing effect is better.

; This module allows PHP to transparently read and write gzip (. gz) compressed files.

zlib.output_ compression = Off
; Whether to use zlib library to transparently compress script output results.
; The value of this instruction can be set to Off, On, and the number of bytes (the size of the compressed buffer is 4096 by default).
; If you open this command, when the browser sends the "Accept Encoding: gzip (deflate)" header,
; The "Content Encoding: gzip (deflate)" and "Vary: Accept Encoding" headers will be added to the response header.
; You can use ini before the response header outputs_ The set() function enables or disables this feature in the script.
; If an answer header such as "Content Type: image/??" is output, compression will not be enabled (to prevent Netscape bugs).
; You can use "ini_set ('zlib. output_compression ',' On ')" to reopen this feature after outputting "Content Type: image/??".
; Note 1: The compression rate will be affected by the size of the compression buffer. If you want better compression quality, please specify a larger compression buffer.
; Note 2: If zlib output compression is enabled, output_ The handler directive must be empty and zlib.output must be set_ The value of the handler directive.

zlib.output_ compression_ level = -1
; The compression level can be 0~9. 0 means no compression. The higher the value, the better the effect. However, the more CPU is used. The recommended value is 1~5.
; The default value of - 1 means to use the default value (6) inside zlib.

zlib.output_ handler =
; Open zlib.output_ In the case of the compression instruction, you can only specify the output processor here.
; The processors available are "zlib. inflate" (decompression) or "zlib. deflate" (compression).
; If this command is enabled, output must be_ The handler directive is set to null.

; A database abstraction layer provides a unified interface for different databases. Currently supported:
; FrontBase,SQL Server,MySQL,ODBC,PostgreSQL,Sybase-CT,Oracle 8,SQLite

dbx.colnames_ case = "unchanged"
; The field name can be returned as "unchanged" or "uppercase" or "lowercase".

; The MySQL i module can only work with MySQL above 4.1.3.

mysqli.max_ links = -1
; The maximum number of connections allowed per process (persistent and non persistent)- 1 means unlimited

mysqli.default_ port = 3306
; mysqli_ The default TCP port used when connect() connects to the MySQL database.
; If the default value is not specified here, it will be searched in the following order:
; (1)$MYSQL_ TCP_ PORT environment variable
; (2) The mysql tcp item in the/etc/services file (unix)
; (3) MYSQL specified at compile time_ PORT constant
; Note: Under Win32, only MYSQL is used_ PORT constant.

mysqli.default_ socket =
; mysqli_ Connect () is the default socket name used when connecting to the local MySQL server.
; If not specified, the built-in MqSQL default value is used.

mysqli.default_ host =
; mysqli_ The default host used when connect() connects to the MySQL database. Invalid in safe mode.

mysqli.default_ user =
; mysqli_ The default user name used when connect() connects to the MySQL database. Invalid in safe mode.

mysqli.default_ pw =
; mysqli_ The default password used when connect() connects to the MySQL database. Invalid in safe mode.
; Saving the password in the configuration file is a bad idea. Any user with PHP permissions can run
; ' echo cfg_ get_ Var ("mysql. default_password") 'to display the password!
; And any user who has read permission to the configuration file can also see the password.

mysqli.reconnect = Off
; Allow reconnection

; PostgresSQL module is recommended to work with version 8.0 or above.

pgsql.allow_ persistent = On
; Allow persistent connection

pgsql.max_ persistent = -1
; The maximum number of persistent connections allowed per process- 1 means unlimited.

pgsql.max_ links = -1
; The maximum number of connections allowed per process (persistent and non persistent)- 1 means unlimited.

pgsql.auto_ reset_ persistent = Off
; Automatic reset at pg_ The detection of the broken persistent connection on pconnect() requires some additional overhead.

pgsql.ignore_ notice = Off
; Whether to ignore the reminder message on the back end of PostgreSQL.
; Recording back end reminder messages requires a small amount of extra overhead.

pgsql.log_ notice = Off
; Whether to record the reminder message of the PostgreSQL backend in the log.
; Only in pgsql.ignore_ Note=Office.

---------------------------------------------Translator: Jin Buguo