PHP函数库（core）

数组函数：

array_change_key_case — 返回字符串键名全为小写或大写的数组

array_change_key_case() 将 input 数组中的所有键名改为全小写或大写。改变是根据后一个选项 case 参数来进行的。本函数不改变数字索引。参数：

input 需要操作的数组。case 可以在这里用两个常量，CASE_UPPER 或 CASE_LOWER（默认值）。返回值：返回一个键全是小写或者全是大写的数组；如果输入值（input）不是一个数组，那么返回FALSE

例子：

<?php
$input_array = array("FirSt" => 1, "SecOnd" => 4);
print_r(array_change_key_case($input_array, CASE_UPPER));
?>

以上例程会输出：

Array ( [FIRST] => 1 [SECOND] => 4 )

array_chunk — 将一个数组分割成多个

将一个数组分割成多个数组，其中每个数组的单元数目由 size 决定。最后一个数组的单元数目可能会少于 size个。参数：

input 需要操作的数组size 每个数组的单元数目preserve_keys 设为 TRUE，可以使 PHP 保留输入数组中原来的键名。如果你指定了 FALSE，那每个结果数组将用从零开始的新数字索引。默认值是 FALSE。返回值：得到的数组是一个多维数组中的单元，其索引从零开始，每一维包含了 size 个元素。

例子：

<?php
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, true));
?>

以上例程会输出：

Array ( [0] => Array ( [0] => a [1] => b ) [1] => Array ( [0] => c [1] => d ) [2] => Array ( [0] => e ) )
Array ( [0] => Array ( [0] => a [1] => b ) [1] => Array ( [2] => c [3] => d ) [2] => Array ( [4] => e ) )

array_column — 返回数组中指定的一列

array_column() 返回input数组中键值为column_key的列，如果指定了可选参数index_key，那么input数组中的这一列的值将作为返回数组中对应值的键。参数：

input 需要取出数组列的多维数组（或结果集）column_key 需要返回值的列，它可以是索引数组的列索引，或者是关联数组的列的键。也可以是NULL，此时将返回整个数组（配合index_key参数来重置数组键的时候，非常管用）index_key 作为返回数组的索引/键的列，它可以是该列的整数索引，或者字符串键值。返回值：从多维数组中返回单列数组

例子：

<?php
$records = array(
 array(
 'id' => 2135,
 'first_name' => 'John',
 'last_name' => 'Doe',
 ),
 array(
 'id' => 3245,
 'first_name' => 'Sally',
 'last_name' => 'Smith',
 )
);
$first_names = array_column($records, 'first_name');
print_r($first_names);
?>

以上例程会输出：

Array([0] => John [1] => Sally)

$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);

结果：Array([2135] => Doe [3245] => Smith)

array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值

返回一个 array，用来自 keys 数组的值作为键名，来自 values 数组的值作为相应的值。参数：

keys 将被作为新数组的键。非法的值将会被转换为字符串类型（string）。values 将被作为数组的值。返回值：返回合并的 array，如果两个数组的单元数不同则返回 FALSE。

例子：

<?php
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
?>

以上例程会输出：

Array ( [green] => avocado [red] => apple [yellow] => banana )

array_count_values — 统计数组中所有的值出现的次数

array_count_values() 返回一个数组，该数组用 input 数组中的值作为键名，该值在 input 数组中出现的次数作为值。参数：

input 统计这个数组的值返回值：返回一个关联数组，用 input 数组中的值作为键名，该值在数组中出现的次数作为值。

例子：

<?php
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
?>

以上例程会输出：

Array ( [1] => 2 [hello] => 2 [world] => 1 )

array_diff_assoc — 带索引检查计算数组的差集

array_diff_assoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意和array_diff() 不同的是键名也用于比较。参数：

array1 The array to compare fromarray2 An array to compare against...返回值：Returns an array containing all the values from array1 that are not present in any of the other arrays.

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);//键值对 0 => "red" 出现在输出中是因为第二个参数中的 "red" 的键名是 1。
print_r($result);
?>

以上例程会输出：

Array ( [b] => brown [c] => blue [0] => red )

array_diff_key — 使用键名比较计算数组的差集

根据 array1 中的键名和 array2 进行比较，返回不同键名的项。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的。参数：

array1 从这个数组进行比较array2 针对此数组进行比较...返回值：array_diff_key() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。

例子：

<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_key($array1, $array2));
?>

以上例程会输出：

array(2) { ["red"]=> int(2) ["purple"]=> int(4) }

array_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集

对比了 array1 和 array2 并返回不同之处。注意和 array_diff() 不同的是键名也用于比较。和 array_diff_assoc() 不同的是使用了用户自定义的回调函数，而不是内置的函数。参数：

array1 待比较的数组array2 和这个数组进行比较...key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：返回一个 array，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。

例子：

<?php
function key_compare_func($a, $b){
 if ($a === $b) {
 return 0;
 }
 return ($a > $b)? 1:-1;
}
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result);
?>

以上例程会输出：

Array ( [b] => brown [c] => blue [0] => red )

array_diff_ukey — 用回调函数对键名比较计算数组的差集

array_diff_ukey() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的。参数：

array1 The array to compare fromarray2 An array to compare against...key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：Returns an array containing all the entries from array1 that are not present in any of the other arrays.

例子：

<?php
function key_compare_func($key1, $key2){
 if ($key1 == $key2)
 return 0;
 else if ($key1 > $key2)
 return 1;
 else
 return -1;
}
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_ukey($array1, $array2, 'key_compare_func'));
?>

以上例程会输出：

array(2) { ["red"]=> int(2) ["purple"]=> int(4) }

array_diff — 计算数组的差集

对比返回在 array1 中但是不在 array2 及任何其它参数数组中的值。参数：

array1 要被对比的数组array2 和这个数组进行比较...返回值：返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保留不变。例子：<?php
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);
print_r($result);
?>
以上例程会输出：
Array ( [1] => blue )

array_fill_keys — 使用指定的键和值填充数组

使用 value 参数的值作为值，使用 keys 数组的值作为键来填充一个数组。参数：

keys 使用该数组的值作为键。非法值将被转换为字符串。value

填充使用的值。

返回值：返回填充后的数组。

例子：

<?php
$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
?>

以上例程会输出：Array ( [foo] => banana [5] => banana [10] => banana [bar] => banana )

array_fill — 用给定的值填充数组

array_fill() 用 value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始。参数：

start_index 返回的数组的第一个索引值。

如果 start_index 是负数，那么返回的数组的第一个索引将会是 start_index ，而后面索引则从0开始。 (参见例子)。

num 插入元素的数量。必须大于 0。value 用来填充的值。返回值：返回填充后的数组。

例子：

<?php
$a = array_fill(5, 6, 'banana');
$b = array_fill(-2, 4, 'pear');
print_r($a);
print_r($b);
?>

以上例程会输出：Array ( [5] => banana [6] => banana [7] => banana [8] => banana [9] => banana [10] => banana ) Array ( [-2] => pear [0] => pear [1] => pear [2] => pear )

array_filter — 用回调函数过滤数组中的单元

依次将 input 数组中的每个值传递到 callback 函数。如果 callback 函数返回 TRUE，则 input 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。参数：

input 要循环的数组callback 使用的回调函数

如果没有提供 callback 函数，将删除 input 中所有等值为 FALSE 的条目。

返回值：返回过滤后的数组。

例子：

<?php
function odd($var){
 // returns whether the input integer is odd
 return($var & 1);
}
function even($var){
 // returns whether the input integer is even
 return(!($var & 1));
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);
echo "Odd :\n";
print_r(array_filter($array1, "odd"));
echo "Even:\n";
print_r(array_filter($array2, "even"));
?>

以上例程会输出：Odd : Array ( [a] => 1 [c] => 3 [e] => 5 ) Even: Array ( [0] => 6 [2] => 8 [4] => 10 [6] => 12 )

无 callback：

<?php
$entry = array(
 0 => 'foo',
 1 => false,
 2 => -1,
 3 => null,
 4 => ''
 );
print_r(array_filter($entry));
?>

结果：Array ( [0] => foo [2] => -1 )

array_flip — 交换数组中的键和值

array_flip() 返回一个反转后的 array，例如 trans 中的键名变成了值，而 trans 中的值成了键名。

注意 trans 中的值需要能够作为合法的键名，例如需要是 integer 或者 string。如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转。

如果同一个值出现了多次，则最后一个键名将作为它的值，所有其它的都丢失了。参数：

trans 要交换键/值对的数组。

返回值：成功时返回交换后的数组，如果失败返回 NULL。

例子：

<?php
$trans = array("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);
?>

以上例程会输出：Array ( [1] => b [2] => c )

array_intersect_assoc — 带索引检查计算数组的交集

array_intersect_assoc() 返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。参数：

array1 The array with master values to check.array2 An array to compare values against.array

要对比的数组变量的列表。

返回值：返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "b" => "yellow", "blue", "red");
$result_array = array_intersect_assoc($array1, $array2);
print_r($result_array);
?>

以上例程会输出：Array ( [a] => green )

array_intersect_key — 使用键名比较计算数组的交集

array_intersect_key() 返回一个数组，该数组包含了所有出现在 array1 中并同时出现在所有其它参数数组中的键名的值。参数：

array1

The array with master keys to check.

array2

An array to compare keys against.

array

A variable list of arrays to compare.

返回值：Returns an associative array containing all the entries of array1 which have keys that are present in all arguments.

例子：

<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_intersect_key($array1, $array2));
?>

以上例程会输出：array(2) { ["blue"]=> int(1) ["green"]=> int(3) }

array_intersect_uassoc — 带索引检查计算数组的交集，用回调函数比较索引

array_intersect_uassoc() 返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。参数：

array1

Initial array for comparison of the arrays.

array2

First array to compare keys against.

array Variable list of array arguments to compare values against.key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：Returns the values of array1 whose values exist in all of the arguments.

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_intersect_uassoc($array1, $array2, "strcasecmp"));
?>

以上例程会输出：Array ( [b] => brown )

array_intersect_ukey — 用回调函数比较键名来计算数组的交集

array_intersect_ukey() 返回一个数组，该数组包含了所有出现在 array1 中并同时出现在所有其它参数数组中的键名的值。参数：

array1

Initial array for comparison of the arrays.

array2

First array to compare keys against.

array Variable list of array arguments to compare keys against.key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：Returns the values of array1 whose keys exist in all the arguments.

例子：

<?php
function key_compare_func($key1, $key2){
 if ($key1 == $key2)
 return 0;
 else if ($key1 > $key2)
 return 1;
 else return -1;
}
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_intersect_ukey($array1, $array2, 'key_compare_func'));
?>

以上例程会输出：array(2) { ["blue"]=> int(1) ["green"]=> int(3) }

array_intersect — 计算数组的交集

array_intersect() 返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。注意键名保留不变。参数：

array1

The array with master values to check.

array2

An array to compare values against.

array

A variable list of arrays to compare.

返回值：返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。

例子：

<?php
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);
?>

以上例程会输出：Array ( [a] => green [0] => red )

array_key_exists — 检查给定的键名或索引是否存在于数组中

array_key_exists() 在给定的 key 存在于数组中时返回 TRUE。key 可以是任何能作为数组索引的值。array_key_exists() 也可用于对象。参数：

key

要检查的键。

search

一个数组，包含待检查的键。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

array_key_exists() 与 isset() 的对比

isset() 对于数组中为 NULL 的值不会返回 TRUE，而 array_key_exists() 会。

<?php
$search_array = array('first' => null, 'second' => 4);

// returns false

isset($search_array['first']);    
// returns true
array_key_exists('first', $search_array);

?>

array_keys — 返回数组中部分的或所有的键名

array_keys() 返回 input 数组中的数字或者字符串的键名。

如果指定可选参数 search_value，则只返回该值的键名。否则 input 数组中所有键名都会被返回。参数：

input 一个数组，包含了要返回的键。search_value 如果指定了这个参数，只有包含这些值的键才会返回。strict 判断在搜索的时候是否该使用严格的比较（===）。返回值：返回 input 里的所有键。例子：<?php
$array = array(0 => 100, "color" => "red");
print_r(array_keys($array));
$array = array("blue", "red", "green", "blue", "blue");
print_r(array_keys($array, "blue"));
$array = array("color" => array("blue", "red", "green"),
"size" => array("small", "medium", "large"));
print_r(array_keys($array));
?>
以上例程会输出：Array ( [0] => 0 [1] => color ) Array ( [0] => 0 [1] => 3 [2] => 4 ) Array ( [0] => color [1] => size )

array_map — 将回调函数作用到给定数组的单元上

array_map() 返回一个数组，该数组包含了 arr1 中的所有单元经过 callback 作用过之后的单元。callback 接受的参数数目应该和传递给 array_map() 函数的数组数目一致。参数：

callback

对每个数组的每个元素作用的回调函数。

arr1

将被回调函数（callback）执行的数组。

array

将被回调函数（callback）执行的数组列表。

返回值：返回一个数组，该数组的每个元素都数组（arr1）里面的每个元素经过回调函数（callback）处理了的。

例子：

<?php
function cube($n){
return($n * $n * $n);
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>

以上例程会输出：

Array ( [0] => 1 [1] => 8 [2] => 27 [3] => 64 [4] => 125 )

array_merge_recursive — 递归地合并一个或多个数组

array_merge_recursive() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

如果输入的数组中有相同的字符串键名，则这些值会被合并到一个数组中去，这将递归下去，因此如果一个值本身是一个数组，本函数将按照相应的条目把它合并为另一个数组。然而，如果数组具有相同的数组键名，后一个值将不会覆盖原来的值，而是附加到后面。参数：

array1 要合并的初始数组。

...

返回值:一个结果数组，其中的值合并自附加的参数。

例子：

<?php
$ar1 = array("color" => array("favorite" => "red"), 5);
$ar2 = array(10, "color" => array("favorite" => "green", "blue"));
$result = array_merge_recursive($ar1, $ar2);
print_r($result);
?>

以上例程会输出：

Array ( [color] => Array ( [favorite] => Array ( [0] => red [1] => green ) [0] => blue ) [0] => 5 [1] => 10 )

array_merge — 合并一个或多个数组

array_merge() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。

如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。

如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。参数：

array1 Initial array to merge.

...

返回值:返回结果数组。

例子：

<?php
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);
?>

以上例程会输出：

Array ( [color] => green [0] => 2 [1] => 4 [2] => a [3] => b [shape] => trapezoid [4] => 4 )

array_multisort — 对多个数组或多维数组进行排序

array_multisort() 可以用来一次对多个数组进行排序，或者根据某一维或多维对多维数组进行排序。

关联（string）键名保持不变，但数字键名会被重新索引。

排序顺序标志：

SORT_ASC - 按照上升顺序排序
SORT_DESC - 按照下降顺序排序

排序类型标志：

SORT_REGULAR - 将项目按照通常方法比较
SORT_NUMERIC - 将项目按照数值比较
SORT_STRING - 将项目按照字符串比较

每个数组之后不能指定两个同类的排序标志。每个数组后指定的排序标志仅对该数组有效 - 在此之前为默认值SORT_ASC 和 SORT_REGULAR。参数：

arr 要排序的一个 array。arg 接下来的每个参数可以是另一个 array 或者是为之前 array 排序标志选项参数： SORT_ASC, SORT_DESC,SORT_REGULAR, SORT_NUMERIC, SORT_STRING....返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$ar1 = array(10, 100, 100, 0);
$ar2 = array(1, 3, 2, 4);
array_multisort($ar1, $ar2);
var_dump($ar1);
var_dump($ar2);
?>

以上例程会输出：

array(4) { [0]=> int(0) [1]=> int(10) [2]=> int(100) [3]=> int(100) } array(4) { [0]=> int(4) [1]=> int(1) [2]=> int(2) [3]=> int(3) }

排序多维数组：

<?php
$ar = array(
 array("10", 11, 100, 100, "a"),
 array( 1, 2, "2", 3, 1)
 );
array_multisort($ar[0], SORT_ASC, SORT_STRING,
 $ar[1], SORT_NUMERIC, SORT_DESC);
var_dump($ar);
?>

结果：

array(2) { [0]=> array(5) { [0]=> string(2) "10" [1]=> int(100) [2]=> int(100) [3]=> int(11) [4]=> string(1) "a" } [1]=> array(5) { [0]=> int(1) [1]=> int(3) [2]=> string(1) "2" [3]=> int(2) [4]=> int(1) } }

array_pad — 用值将数组填补到指定长度

array_pad() 返回 input 的一个拷贝，并用 pad_value 将其填补到 pad_size 指定的长度。如果 pad_size 为正，则填补到数组的右侧，如果为负则从左侧开始填补。如果 pad_size 的绝对值小于或等于 input 数组的长度则没有任何填补。有可能一次最多填补 1048576 个单元。参数：

input

需要被填充的原始数组。

pad_size

新数组的长度。

pad_value

将被填充的值，只有在 input 的现有长度小于 pad_size 的长度时才有效。

返回值：返回 input 用 pad_value 填充到 pad_size 指定的长度之后的一个副本。如果 pad_size 为正，则填补到数组的右侧，如果为负则从左侧开始填补。如果 pad_size 的绝对值小于或等于 input 数组的长度则没有任何填补。

例子：

<?php
$input = array(12, 10, 9);
$result = array_pad($input, 5, 0);
// result is array(12, 10, 9, 0, 0)
$result = array_pad($input, -7, -1);
// result is array(-1, -1, -1, -1, 12, 10, 9)
$result = array_pad($input, 2, "noop");
// not padded
?>

array_pop — 将数组最后一个单元弹出（出栈）

array_pop() 弹出并返回 array 数组的最后一个单元，并将数组 array 的长度减一。如果 array 为空（或者不是数组）将返回 NULL。此外如果被调用不是一个数则会产生一个 Warning。参数：

array

需要做出栈的数组。

返回值：返回 array 的最后一个值。如果 array 是空（如果不是一个数组），将会返回 NULL 。

例子：

<?php
$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);
print_r($stack);
?>

以上例程会输出：

Array ( [0] => orange [1] => banana [2] => apple )

array_product — 计算数组中所有值的乘积

array_product() 以整数或浮点数返回一个数组中所有值的乘积。参数：

array

这个数组。

返回值：以整数或浮点数返回一个数组中所有值的乘积。

例子：

<?php
$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\n";
echo "product(array()) = " . array_product(array()) . "\n";
?>

以上例程会输出：

product(a) = 384 product(array()) = 0

array_push — 将一个或多个单元压入数组的末尾（入栈）

array_push() 将 array 当成一个栈，并将传入的变量压入 array 的末尾。array 的长度将根据入栈变量的数目增加。和如下效果相同：

<?php
$array[] = $var;
?>

并对每个 var 重复以上动作。

Note: 如果用 array_push() 来给数组增加一个单元，还不如用 $array[] = ，因为这样没有调用函数的额外负担。

Note: 如果第一个参数不是数组，array_push() 将发出一条警告。这和 $var[] 的行为不同，后者会新建一个数组。参数：

array 输入的数组。

var 要压入的值。

返回值：返回处理之后数组的元素个数。

例子：

<?php
$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");
print_r($stack);
?>

以上例程会输出：

Array ( [0] => orange [1] => banana [2] => apple [3] => raspberry )

array_rand — 从数组中随机取出一个或多个单元

从数组中取出一个或多个随机的单元，并返回随机条目的一个或多个键。参数：

input 输入的数组。

num_req 指明了你想取出多少个单元。如果指定的数目超过了数组里的数量将会产生一个E_WARNING 级别的错误。

返回值：如果你只取出一个，array_rand() 返回一个随机单元的键名，否则就返回一个包含随机键名的数组。这样你就可以随机从数组中取出键名和值。

例子：

<?php
$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($input, 2);
echo $input[$rand_keys[0]] . "\n";
echo $input[$rand_keys[1]] . "\n";
?>

以上例程会输出：

随机的

array_reduce — 用回调函数迭代地将数组简化为单一的值

array_reduce() 将回调函数 function 迭代地作用到 input 数组中的每一个单元中，从而将数组简化为单一的值。参数：

input The input array.

function The callback function.

mixedcallback ( mixed&$result , mixed$item )

initial

如果指定了可选参数 initial，该参数将被当成是数组中的第一个值来处理，或者如果数组为空的话就作为最终返回值。

返回值：返回结果值。initial 参数，array_reduce() 返回 NULL。

例子：

<?php
function rsum($v, $w){
    $v += $w;
    return $v;
}
function rmul($v, $w){
    $v *= $w;
    return $v;
}
$a = array(1, 2, 3, 4, 5);
$x = array();
$b = array_reduce($a, "rsum");
$c = array_reduce($a, "rmul", 10);
$d = array_reduce($x, "rsum", "No data to reduce");
?>

这将使 $b 的值为 15，$c 的值为 1200（= 10*1*2*3*4*5），以及 $d 的值为 1。

array_replace_recursive — 使用传递的数组递归替换第一个数组的元素

array_replace_recursive() 使用后面数组元素的值替换数组 array1 的值。如果一个键存在于第一个数组同时也存在于第二个数组，它的值将被第二个数组中的值替换。如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。如果一个键仅存在于第一个数组，它将保持不变。如果传递了多个替换数组，它们将被按顺序依次处理，后面的数组将覆盖之前的值。

array_replace_recursive() 是递归的：它将遍历数组并将相同的处理应用到数组的内部值。

如果数组 array1 中的值是标量，它的值将被第二个数组 array2 中的值替换，它可能是一个标量或者数组。如果 array1 和 array2 中的值都是数组，array_replace_recursive() 函数将递归地替换它们各自的值。参数：

array1 替换该数组的值。

array2 从此数组中提取替换值。

...

返回值：返回一个数组。如果发生错误，将返回 NULL。

例子：

<?php
$base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"), );
$replacements = array('citrus' => array('pineapple'), 'berries' => array('blueberry'));
$basket = array_replace_recursive($base, $replacements);
print_r($basket);
$basket = array_replace($base, $replacements);
print_r($basket);
?>

以上例程会输出：

Array([citrus] => Array([0] => pineapple) [berries] => Array([0] => blueberry [1] => raspberry)) Array([citrus] => Array([0] => pineapple)[berries] => Array

([0] => blueberry))

array_replace — 使用传递的数组替换第一个数组的元素

array_replace() 函数使用后面数组元素相同 key 的值替换 array1 数组的值。如果一个键存在于第一个数组同时也存在于第二个数组，它的值将被第二个数组中的值替换。如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。如果一个键仅存在于第一个数组，它将保持不变。如果传递了多个替换数组，它们将被按顺序依次处理，后面的数组将覆盖之前的值。

array_replace() 是非递归的：它将第一个数组的值进行替换而不管第二个数组中是什么类型。参数：

array1 替换该数组的值。

array2 从此数组中提取替换值。

...

返回值：返回一个数组。如果发生错误，将返回 NULL。

例子：

<?php
$base = array("orange", "banana", "apple", "raspberry");
$replacements = array(0 => "pineapple", 4 => "cherry");
$replacements2 = array(0 => "grape");
$basket = array_replace($base, $replacements, $replacements2);
print_r($basket);
?>

以上例程会输出：

Array([0] => grape [1] => banana [2] => apple [3] => raspberry [4] => cherry)

array_reverse — 返回一个单元顺序相反的数组

array_reverse() 接受数组 array 作为输入并返回一个单元为相反顺序的新数组。参数：

array 输入的数组。

preserve_keys 如果设置为 TRUE 会保留数字的键。非数字的键则不受这个设置的影响，总是会被保留。

返回值：

返回反转后的数组。

<?php
$input  = array("php", 4.0, array("green", "red"));
$result = array_reverse($input);
$result_keyed = array_reverse($input, true);
?>

以上例程会输出：

Array ( [2] => Array ( [0] => green [1] => red ) [1] => 4 [0] => php )

array_search — 在数组中搜索给定的值，如果成功则返回相应的键名

在 haystack 中搜索 needle 参数。参数：

needle 搜索的值。

Note: 如果 needle 是字符串，则比较以区分大小写的方式进行。

haystack 这个数组。

strict 如果可选的第三个参数 strict 为 TRUE，则 array_search() 将在 haystack 中检查完全相同的元素。这意味着同样检查 haystack 里 needle 的类型，并且对象需是同一个实例。

返回值：

如果找到了 needle 则返回它的键，否则返回 FALSE。

如果 needle 在 haystack 中出现不止一次，则返回第一个匹配的键。要返回所有匹配值的键，应该用 array_keys() 加上可选参数 search_value 来代替。

例子：

<?php
$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;
?>

array_shift — 将数组开头的单元移出数组

array_shift() 将 array 的第一个单元移出并作为结果返回，将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数，文字键名将不变。

Note: 使用此函数后会重置（reset()）array 指针。参数：

array 输入的数组。

返回值：

返回移出的值，如果 array 为空或不是一个数组则返回 NULL。

例子：

<?php
$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);
print_r($stack);
?>

以上例程会输出：

Array ( [0] => banana [1] => apple [2] => raspberry )

array_slice — 从数组中取出一段

array_slice() 返回根据 offset 和 length 参数所指定的 array 数组中的一段序列。参数：

array 输入的数组。

offset 如果 offset 非负，则序列将从 array 中的此偏移量开始。如果 offset 为负，则序列将从 array 中距离末端这么远的地方开始。

length 如果给出了 length 并且为正，则序列中将具有这么多的单元。如果给出了 length 并且为负，则序列将终止在距离数组末端这么远的地方。如果省略，则序列将从 offset 开始一直到 array 的末端。

preserve_keys 注意 array_slice() 默认会重新排序并重置数组的数字索引。你可以通过将preserve_keys 设为 TRUE 来改变此行为。

返回值：

返回其中一段。

例子：

<?php
$input = array("a", "b", "c", "d", "e");
$output = array_slice($input, 2);      // returns "c", "d", and "e"
$output = array_slice($input, -2, 1);  // returns "d"
$output = array_slice($input, 0, 3);   // returns "a", "b", and "c"
// note the differences in the array keys
print_r(array_slice($input, 2, -1));
print_r(array_slice($input, 2, -1, true));
?>

以上例程会输出：

Array ( [0] => c [1] => d ) Array ( [2] => c [3] => d )

array_splice — 把数组中的一部分去掉并用其它值取代

把 input 数组中由 offset 和 length 指定的单元去掉，如果提供了 replacement 参数，则用其中的单元取代。

注意 input 中的数字键名不被保留。参数：

input 输入的数组。

offset 如果 offset 为正，则从 input 数组中该值指定的偏移量开始移除。如果 offset为负，则从 input 末尾倒数该值指定的偏移量开始移除。

length 如果省略 length，则移除数组中从 offset 到结尾的所有部分。如果指定了 length 并且为正值，则移除这么多单元。如果指定了 length 并且为负值，则移除从 offset 到数组末尾倒数 length 为止中间所有的单元。小窍门：当给出了 replacement 时要移除从 offset 到数组末尾所有单元时，用 count($input) 作为 length。

replacement 如果给出了 replacement 数组，则被移除的单元被此数组中的单元替代。

如果 offset 和 length 的组合结果是不会移除任何值，则 replacement 数组中的单元将被插入到 offset 指定的位置。注意替换数组中的键名不保留。

如果用来替换 replacement 只有一个单元，那么不需要给它加上 array()，除非该单元本身就是一个数组、一个对象或者 NULL。

返回值：

返回一个包含有被移除单元的数组。

例子：

<?php
$input = array("red", "green", "blue", "yellow");
array_splice($input, 2);
// $input is now array("red", "green")


$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, -1);
// $input is now array("red", "yellow")
$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, count($input), "orange");
// $input is now array("red", "orange")
$input = array("red", "green", "blue", "yellow");
array_splice($input, -1, 1, array("black", "maroon"));
// $input is now array("red", "green",
//          "blue", "black", "maroon")

$input = array("red", "green", "blue", "yellow"); array_splice($input, 3, 0, "purple"); // $input is now array("red", "green", // "blue", "purple", "yellow"); ?>

array_sum — 计算数组中所有值的和

array_sum() 将数组中的所有值的和以整数或浮点数的结果返回。参数：

array

输入的数组。

返回值：

所有值的和以整数或浮点数的结果返回。

例子：

<?php
$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "\n";
$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo "sum(b) = " . array_sum($b) . "\n";
?>

以上例程会输出：

sum(a) = 20 sum(b) = 6.9

array_udiff_assoc — 带索引检查计算数组的差集，用回调函数比较数据

此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。参数：

此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。

array1 第一个数组。
array2 第二个数组。
data_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )

返回值：array_udiff_assoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意和 array_diff() 与 array_udiff() 不同的是键名也用于比较。数组数据的比较是用用户提供的回调函数进行的。在此方面和 array_diff_assoc() 的行为正好相反，后者是用内部函数进行比较的。
例子：

<?php
class cr {
    private $priv_member;
    function cr($val){
        $this->priv_member = $val;
    }
    static function comp_func_cr($a, $b){
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr"));
print_r($result);
?>

以上例程会输出：

Array ( [0.1] => cr Object ( [priv_member:private] => 9 ) [0.5] => cr Object ( [priv_member:private] => 12 ) [0] => cr Object ( [priv_member:private] => 23 ) )

array_udiff_uassoc — 带索引检查计算数组的差集，用回调函数比较数据和索引

array_udiff_uassoc() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。

注意和 array_diff() 与 array_udiff() 不同的是键名也用于比较。参数：

array1 第一个数组。


array2 第二个数组。
data_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )
key_compare_func 对键名（索引）的检查也是由回调函数 key_compare_func 进行的。这和 array_udiff_assoc() 的行为不同，后者是用内部函数比较索引的。

返回值：

Returns an array containing all the values from array1 that are not present in any of the other arguments.

例子：

<?php
class cr {
    private $priv_member;
    function cr($val){
        $this->priv_member = $val;
    }
    static function comp_func_cr($a, $b){
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }
    static function comp_func_key($a, $b){
        if ($a === $b) return 0;
        return ($a > $b)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key"));
print_r($result);
?>

以上例程会输出：

Array ( [0.1] => cr Object ( [priv_member:private] => 9 ) [0.5] => cr Object ( [priv_member:private] => 12 ) [0] => cr Object ( [priv_member:private] => 23 ) )

array_udiff — 用回调函数比较数据来计算数组的差集

array_udiff() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保持不变。数据的比较是用 data_compare_func 进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。这和 array_diff() 不同，后者使用了内部函数来比较数据。参数：

array1 第一个数组。
array2 第二个数组。
data_compare_func 回调对照函数。在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )

返回值：

Returns an array containing all the values of array1 that are not present in any of the other arguments.

例子：

<?php
class cr {
    private $priv_member;
    function cr($val){
        $this->priv_member = $val;
    }
    static function comp_func_cr($a, $b){
        if ($a->priv_member === $b->priv_member) return 0;
        return ($a->priv_member > $b->priv_member)? 1:-1;
    }
}
$a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1=> new cr(4), 2 => new cr(-15),);
$b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1=> new cr(4), 2 => new cr(-15),);
$result = array_udiff($a, $b, array("cr", "comp_func_cr"));
print_r($result);
?>

以上例程会输出：

Array ( [0.5] => cr Object ( [priv_member:private] => 12 ) [0] => cr Object ( [priv_member:private] => 23 ) )

array_uintersect_assoc — 带索引检查计算数组的交集，用回调函数比较数据

此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。

注意和 array_uintersect() 不同的是键名也要比较。数据是用回调函数比较的。参数：

array1 第一个数组。

array2 第二个数组。


data_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )

返回值：

返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_uintersect_assoc($array1, $array2, "strcasecmp"));
?>

以上例程会输出：

Array ( [a] => green )

array_uintersect_uassoc — 带索引检查计算数组的交集，用回调函数比较数据和索引

通过额外的索引检查、回调函数比较数据和索引来返回多个数组的交集。注意和 array_uintersect() 不同的是键名也要比较。数据和索引都是用回调函数比较的。参数：

array1 第一个数组。
array2 第二个数组。
data_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )
key_compare_func 键名比较的回调函数。

返回值：

返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_uintersect_uassoc($array1, $array2, "strcasecmp", "strcasecmp"));
?>

以上例程会输出：

Array ( [a] => green [b] => brown )

array_uintersect — 计算数组的交集，用回调函数比较数据

array_uintersect() 返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。数据比较是用回调函数进行的。此比较是通过用户提供的回调函数来进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。参数：

array1 第一个数组。
array2 第二个数组。
data_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。: intcallback ( mixed$a, mixed$b )

返回值：

Returns an array containing all the values of array1 that are present in all the arguments.

例子：

<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "GREEN", "B" => "brown", "yellow", "red");
print_r(array_uintersect($array1, $array2, "strcasecmp"));
?>

以上例程会输出：

Array ( [a] => green [b] => brown [0] => red )

array_unique — 移除数组中重复的值

array_unique() 接受 array 作为输入并返回没有重复值的新数组。

注意键名保留不变。array_unique() 先将值作为字符串排序，然后对每个值只保留第一个遇到的键名，接着忽略所有后面的键名。这并不意味着在未排序的 array 中同一个值的第一个出现的键名会被保留。

Note: 当且仅当 (string) $elem1 === (string) $elem2 时两个单元被认为相同。就是说，当字符串的表达一样时。第一个单元将被保留。参数：

array 输入的数组。

sort_flags The optional second parameter sort_flags may be used to modify the sorting behavior using these values:

Sorting type flags:

SORT_REGULAR - compare items normally (don't change types)
SORT_NUMERIC - compare items numerically
SORT_STRING - compare items as strings
SORT_LOCALE_STRING - compare items as strings, based on the current locale.


返回值：Returns the filtered array.
例子：

<?php
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>

以上例程会输出：

Array ( [a] => green [0] => red [1] => blue )

<?php
$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);
?>

结果：


array(2) { [0]=> int(4) [2]=> string(1) "3" }

array_unshift — 在数组开头插入一个或多个单元

array_unshift() 将传入的单元插入到 array 数组的开头。注意单元是作为整体被插入的，因此传入单元将保持同样的顺序。所有的数值键名将修改为从零开始重新计数，所有的文字键名保持不变。参数：

array 输入的数组。
var 开头插入的变量。

返回值：

返回 array 数组新的单元数目。

例子：

<?php
$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");
print_r($queue);
?>

以上例程会输出：

Array ( [0] => apple [1] => raspberry [2] => orange [3] => banana )

array_values — 返回数组中所有的值

array_values() 返回 input 数组中所有的值并给其建立数字索引。参数：

input 数组。

返回值：

返回含所有值的索引数组。

<?php
$array = array("size" => "XL", "color" => "gold");
print_r(array_values($array));
?>

以上例程会输出：

Array ( [0] => XL [1] => gold )

array_walk_recursive — 对数组中的每个成员递归地应用用户函数

将用户自定义函数 funcname 应用到 array 数组中的每个单元。本函数会递归到更深层的数组中去。参数：

input 输入的数组。
funcname 典型情况下 funcname 接受两个参数。input 参数的值作为第一个，键名作为第二个。: Note:如果 funcname 需要直接作用于数组中的值，则给 funcname 的第一个参数指定为引用。这样任何对这些单元的改变也将会改变原始数组本身。
userdata 如果提供了可选参数 userdata，将被作为第三个参数传递给 callback funcname。

返回值：

成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$sweet = array('a' => 'apple', 'b' => 'banana');
$fruits = array('sweet' => $sweet, 'sour' => 'lemon');
function test_print($item, $key){
    echo "$key holds $item\n";
}
array_walk_recursive($fruits, 'test_print');
?>

以上例程会输出：

a holds apple b holds banana sour holds lemon

array_walk — 使用用户自定义函数对数组中的每个元素做回调处理

将用户自定义函数 funcname 应用到 array 数组中的每个单元。

array_walk() 不会受到 array 内部数组指针的影响。array_walk() 会遍历整个数组而不管指针的位置。参数：

array 输入的数组。
funcname 典型情况下 funcname 接受两个参数。array 参数的值作为第一个，键名作为第二个。Note:如果 funcname 需要直接作用于数组中的值，则给 funcname 的第一个参数指定为引用。这样任何对这些单元的改变也将会改变原始数组本身。只有 array 的值才可以被改变，用户不应在回调函数中改变该数组本身的结构。例如增加/删除单元，unset 单元等等。如果 array_walk() 作用的数组改变了，则此函数的的行为未经定义，且不可预期。

userdata 如果提供了可选参数 userdata，将被作为第三个参数传递给 callback funcname。

返回值：

成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
function test_alter(&$item1, $key, $prefix){
    $item1 = "$prefix: $item1";
}
function test_print($item2, $key){
    echo "$key. $item2<br />\n";
}
echo "Before ...:\n";
array_walk($fruits, 'test_print');
array_walk($fruits, 'test_alter', 'fruit');
echo "... and after:\n";
array_walk($fruits, 'test_print');
?>

以上例程会输出：

Before ...: d. lemon
a. orange
b. banana
c. apple
... and after: d. fruit: lemon
a. fruit: orange
b. fruit: banana
c. fruit: apple

array — 新建一个数组

参数

...

语法“index => values”，用逗号分开，定义了索引和值。索引可以是字符串或数字。如果省略了索引，会自动产生从 0 开始的整数索引。如果索引是整数，则下一个产生的索引将是目前最大的整数索引 + 1。注意如果定义了两个完全一样的索引，则后面一个会覆盖前一个。

在最后一个定义的数组项目之后加一个逗号虽然不常见，却是合法的语法。

返回值：

返回根据参数建立的数组。

例子：

<?php
$array = array(1, 1, 1, 1,  1, 8 => 1,  4 => 1, 19, 3 => 13);
print_r($array);
?>

以上例程会输出：

Array ( [0] => 1 [1] => 1 [2] => 1 [3] => 13 [4] => 1 [8] => 1 [9] => 19 )

arsort — 对数组进行逆向排序并保持索引关系

本函数对数组进行排序，数组的索引保持和单元的关联。

主要用于对那些单元顺序很重要的结合数组进行排序。参数：

array 输入的数组。
sort_flags 可以用可选的参数 sort_flags 改变排序的行为

返回值：

成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
arsort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}
?>

以上例程会输出：

a = orange d = lemon b = banana c = apple

asort — 对数组进行排序并保持索引关系

本函数对数组进行排序，数组的索引保持和单元的关联。主要用于对那些单元顺序很重要的结合数组进行排序。参数：

array 输入的数组。
sort_flags 可以用可选的参数 sort_flags 改变排序的行为

返回值：

成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
asort($fruits);
foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}
?>

以上例程会输出：

c = apple b = banana d = lemon a = orange

compact — 建立一个数组，包括变量名和它们的值

创建一个包含变量与其值的数组。

对每个参数，compact() 在当前的符号表中查找该变量名并将它添加到输出的数组中，变量名成为键名而变量的内容成为该键的值。简单说，它做的事和 extract() 正好相反。返回将所有变量添加进去后的数组。

任何没有变量名与之对应的字符串都被略过。参数：

varname compact() 接受可变的参数数目。每个参数可以是一个包括变量名的字符串或者是一个包含变量名的数组，该数组中还可以包含其它单元内容为变量名的数组， compact() 可以递归处理。

返回值：

返回输出的数组，包含了添加的所有变量。

例子：

<?php
$city  = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";
$location_vars = array("city", "state");
$result = compact("event", "nothing_here", $location_vars);
print_r($result);
?>

以上例程会输出：

Array ( [event] => SIGGRAPH [city] => San Francisco [state] => CA )

count — 计算数组中的单元数目或对象中的属性个数

统计一个数组里的所有元素，或者一个对象里的东西。

对于对象，如果安装了 SPL，可以通过实现 Countable 接口来调用 count()。该接口只有一个方法Countable::count()，此方法返回 count() 函数的返回值。参数：

var 数组或者对象。
mode 如果可选的 mode 参数设为 COUNT_RECURSIVE（或 1），count() 将递归地对数组计数。对计算多维数组的所有单元尤其有用。mode 的默认值是 0。count() 识别不了无限递归。

返回值：返回 var 中的单元数目。如果 var 不是数组类型或者实现了 Countable 接口的对象，将返回 1，有一个例外，如果 var 是 NULL 则结果是 0。

Caution

count() 对没有初始化的变量返回 0，但对于空的数组也会返回 0。用 isset() 来测试变量是否已经初始化。

例子：

<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count($a);
// $result == 3
$b[0]  = 7;
$b[5]  = 9;
$b[10] = 11;
$result = count($b);
// $result == 3
$result = count(null);
// $result == 0
$result = count(false);
// $result == 1
?>

<?php
$food = array('fruits' => array('orange', 'banana', 'apple'),
              'veggie' => array('carrot', 'collard', 'pea'));
// recursive count
echo count($food, COUNT_RECURSIVE); // output 8
// normal count
echo count($food); // output 2
?>

current — 返回数组中的当前单元

每个数组中都有一个内部的指针指向它“当前的”单元，初始指向插入到数组中的第一个单元。参数：

array 这个数组。

返回值：

current() 函数返回当前被内部指针指向的数组单元的值，并不移动指针。如果内部指针指向超出了单元列表的末端，current() 返回 FALSE。

Warning：

此函数可能返回布尔值 FALSE，但也可能返回等同于 FALSE 的非布尔值。请阅读布尔类型章节以获取更多信息。应使用 === 运算符来测试此函数的返回值。

例子：

<?php
$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport);    // $mode = 'bike';
$mode = current($transport); // $mode = 'bike';
$mode = prev($transport);    // $mode = 'foot';
$mode = end($transport);     // $mode = 'plane';
$mode = current($transport); // $mode = 'plane';
$arr = array();
var_dump(current($arr)); // bool(false)
$arr = array(array());
var_dump(current($arr)); // array(0) { }
?>

each — 返回数组中当前的键／值对并将数组指针向前移动一步

返回数组中当前的键／值对并将数组指针向前移动一步

在执行 each() 之后，数组指针将停留在数组中的下一个单元或者当碰到数组结尾时停留在最后一个单元。如果要再用 each 遍历数组，必须使用 reset()。参数：

array 输入的数组。

返回值：

返回 array 数组中当前指针位置的键／值对并向前移动数组指针。键值对被返回为四个单元的数组，键名为0，1，key和 value。单元 0 和 key 包含有数组单元的键名，1 和 value 包含有数据。

如果内部指针越过了数组的末端，则 each() 返回 FALSE。

例子：

<?php
$foo = array("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each($foo);
print_r($bar);
?>

$bar 现在包含有如下的键／值对：

Array([1] => bob [value] => bob [0] => 0 [key] => 0

)

<?php
$foo = array("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each($foo);
print_r($bar);
?>

$bar 现在包含有如下的键／值对：

Array([1] => Bob [value] => Bob [0] => Robert [key] => Robert

)

each() 经常和 list() 结合使用来遍历数组，例如：

<?php
$fruit = array('a' => 'apple', 'b' => 'banana', 'c' => 'cranberry');
reset($fruit);
while (list($key, $val) = each($fruit)) {
    echo "$key => $val\n";
}
?>

以上例程会输出：

a => apple b => banana c => cranberry

end — 将数组的内部指针指向最后一个单元

end() 将 array 的内部指针移动到最后一个单元并返回其值。参数：

array

这个数组。该数组是通过引用传递的，因为它会被这个函数修改。这意味着你必须传入一个真正的变量，而不是函数返回的数组，因为只有真正的变量才能以引用传递。

返回值：

返回最后一个元素的值，或者如果是空数组则返回 FALSE。

例子：

<?php
$fruits = array('apple', 'banana', 'cranberry');
echo end($fruits); // cranberry
?>

extract — 从数组中将变量导入到当前的符号表

本函数用来将变量从数组中导入到当前的符号表中。

检查每个键名看是否可以作为一个合法的变量名，同时也检查和符号表中已有的变量名的冲突。参数：

var_array 一个关联数组。此函数会将键名当作变量名，值作为变量的值。对每个键／值对都会在当前的符号表中建立变量，并受到 extract_type 和 prefix 参数的影响。

必须使用关联数组，数字索引的数组将不会产生结果，除非用了 EXTR_PREFIX_ALL 或者 EXTR_PREFIX_INVALID。

extract_type 对待非法／数字和冲突的键名的方法将根据 extract_type 参数决定。可以是以下值之一：

EXTR_OVERWRITE 如果有冲突，覆盖已有的变量。
EXTR_SKIP 如果有冲突，不覆盖已有的变量。
EXTR_PREFIX_SAME 如果有冲突，在变量名前加上前缀 prefix。
EXTR_PREFIX_ALL 给所有变量名加上前缀 prefix。
EXTR_PREFIX_INVALID 仅在非法／数字的变量名前加上前缀 prefix。
EXTR_IF_EXISTS 仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。举个例子，以下情况非常有用：定义一些有效变量，然后从 $_REQUEST 中仅导入这些已定义的变量。
EXTR_PREFIX_IF_EXISTS 仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。
EXTR_REFS 将变量作为引用提取。这有力地表明了导入的变量仍然引用了 var_array 参数的值。可以单独使用这个标志或者在 extract_type 中用 OR 与其它任何标志结合使用。如果没有指定 extract_type，则被假定为 EXTR_OVERWRITE。

prefix 注意 prefix 仅在 extract_type 的值是EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS 时需要。如果附加了前缀后的结果不是合法的变量名，将不会导入到符号表中。前缀和数组键名之间会自动加上一个下划线。

返回值：

返回成功导入到符号表中的变量数目。

例子：

<?php
/* 假定 $var_array 是 wddx_deserialize 返回的数组*/
$size = "large";
$var_array = array("color" => "blue",
                   "size"  => "medium",
                   "shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");
echo "$color, $size, $shape, $wddx_size\n";
?>

以上例程会输出：

blue, large, sphere, medium

in_array — 检查数组中是否存在某个值

在 haystack 中搜索 needle，如果没有设置 strict 则使用宽松的比较。参数：

needle

待搜索的值

如果 needle 是字符串，则比较是区分大小写的。

haystack

这个数组。

strict

如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。

返回值：如果找到 needle 则返回 TRUE，否则返回 FALSE。

in_array() 严格类型检查例子

<?php
$a = array('1.10', 12.4, 1.13);
if (in_array('12.4', $a, true)) {
echo "'12.4' found with strict check\n";
}
if (in_array(1.13, $a, true)) {
echo "1.13 found with strict check\n";
}
?>

以上例程会输出：

1.13 found with strict check

in_array() 中用数组作为 needle

<?php
$a = array(array('p', 'h'), array('p', 'r'), 'o');
if (in_array(array('p', 'h'), $a)) {
 echo "'ph' was found\n";
}
if (in_array(array('f', 'i'), $a)) {
 echo "'fi' was found\n";
}
if (in_array('o', $a)) {
 echo "'o' was found\n";
}
?>

以上例程会输出：

'ph' was found 'o' was found

key_exists — 别名 array_key_exists

此函数是该函数的别名： array_key_exists().

key — 从关联数组中取得键名

key() 返回数组中当前单元的键名。参数：

array

该数组。

返回值：key() 函数返回数组中内部指针指向的当前单元的键名。但它不会移动指针。如果内部指针超过了元素列表尾部，或者数组是空的，key() 会返回 NULL。

例子：

<?php
$array = array(
 'fruit1' => 'apple',
 'fruit2' => 'orange',
 'fruit3' => 'grape',
 'fruit4' => 'apple',
 'fruit5' => 'apple');
// this cycle echoes all associative array
// key where value equals "apple"
while ($fruit_name = current($array)) {
 if ($fruit_name == 'apple') {
 echo key($array).' ';
 }
 next($array);
}
?>

以上例程会输出：

fruit1
fruit4
fruit5

krsort — 对数组按照键名逆向排序

对数组按照键名逆向排序，保留键名到数据的关联。主要用于结合数组。参数：

array

输入的数组。

sort_flags

可以用可选参数 sort_flags 改变排序的行为

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>

以上例程会输出：

d = lemon c = apple b = banana a = orange

ksort — 对数组按照键名排序

对数组按照键名排序，保留键名到数据的关联。本函数主要用于关联数组。参数：

array

输入的数组。

sort_flags

可以用可选参数 sort_flags 改变排序的行为

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>

以上例程会输出：

a = orange b = banana c = apple d = lemon

list — 把数组中的值赋给一些变量

像 array() 一样，这不是真正的函数，而是语言结构。list() 用一步操作给一组变量进行赋值。参数：

varname

一个变量。

返回值：返回指定的数组。例子：<?php
$info = array('coffee', 'brown', 'caffeine');
// 列出所有变量
list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.\n";
// 列出他们的其中一个
list($drink, , $power) = $info;
echo "$drink has $power.\n";
// 或者让我们跳到仅第三个
list( , , $power) = $info;
echo "I need $power!\n";
// list() 不能对字符串起作用
list($bar) = "abcde";
var_dump($bar); // NULL
?>

natcasesort — 用“自然排序”算法对数组进行不区分大小写字母的排序

本函数实现了一个和人们通常对字母数字字符串进行排序的方法一样的排序算法并保持原有键／值的关联，这被称为“自然排序”。参数：

array

输入的数组。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$array1 = $array2 = array('IMG0.png', 'img12.png', 'img10.png', 'img2.png', 'img1.png', 'IMG3.png');
sort($array1);
echo "Standard sorting\n";
print_r($array1);
natcasesort($array2);
echo "\nNatural order sorting (case-insensitive)\n";
print_r($array2);
?>

以上例程会输出：

Standard sorting Array ( [0] => IMG0.png [1] => IMG3.png [2] => img1.png [3] => img10.png [4] => img12.png [5] => img2.png ) Natural order sorting (case-insensitive) Array ( [0] => IMG0.png [4] => img1.png [3] => img2.png [5] => IMG3.png [2] => img10.png [1] => img12.png )

natsort — 用“自然排序”算法对数组排序

本函数实现了一个和人们通常对字母数字字符串进行排序的方法一样的排序算法并保持原有键／值的关联，这被称为“自然排序”。参数：

array

输入的 array。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png");
asort($array1);
echo "Standard sorting\n";
print_r($array1);
natsort($array2);
echo "\nNatural order sorting\n";
print_r($array2);
?>

以上例程会输出：

Standard sorting Array ( [3] => img1.png [1] => img10.png [0] => img12.png [2] => img2.png ) Natural order sorting Array ( [3] => img1.png [2] => img2.png [1] => img10.png [0] => img12.png )

next — 将数组中的内部指针向前移动一位

next() 和 current() 的行为类似，只有一点区别，在返回值之前将内部指针向前移动一位。这意味着它返回的是下一个数组单元的值并将数组指针向前移动了一位。参数：

array

受影响的 array 。

返回值：返回数组内部指针指向的下一个单元的值，或当没有更多单元时返回 FALSE。

例子：

<?php
$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport); // $mode = 'bike';
$mode = next($transport); // $mode = 'car';
$mode = prev($transport); // $mode = 'bike';
$mode = end($transport); // $mode = 'plane';
?>

pos — current 的别名

此函数是该函数的别名：current()。

prev — 将数组的内部指针倒回一位

prev() 和 next() 的行为类似，只除了它将内部指针倒回一位而不是前移一位。参数：

array

The input array.

返回值：返回数组内部指针指向的前一个单元的值，或当没有更多单元时返回 FALSE。

例子：

range — 建立一个包含指定范围单元的数组

建立一个包含指定范围单元的数组。参数：

start

序列的第一个值。

limit

序列结束于 limit 的值。

step

如果给出了 step 的值，它将被作为单元之间的步进值。step 应该为正值。如果未指定，step 则默认为 1。

返回值：返回的数组中从 start 到 limit 的单元，包括它们本身。

例子：

<?php
// array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
foreach (range(0, 12) as $number) {
 echo $number;
}
// The step parameter was introduced in 5.0.0
// array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
foreach (range(0, 100, 10) as $number) {
 echo $number;
}
// Use of character sequences introduced in 4.1.0
// array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i');
foreach (range('a', 'i') as $letter) {
 echo $letter;
}
// array('c', 'b', 'a');
foreach (range('c', 'a') as $letter) {
 echo $letter;
}
?>

reset — 将数组的内部指针指向第一个单元

reset() 将 array 的内部指针倒回到第一个单元并返回第一个数组单元的值。参数：

array

输入的数组。

返回值：返回数组第一个单元的值，如果数组为空则返回 FALSE。

例子：

<?php
$array = array('step one', 'step two', 'step three', 'step four');
// by default, the pointer is on the first element
echo current($array) . " \n"; // "step one"
// skip two steps
next($array);
next($array);
echo current($array) . " \n"; // "step three"
// reset pointer, start again on step one
reset($array);
echo current($array) . " \n"; // "step one"
?>

rsort — 对数组逆向排序

本函数对数组进行逆向排序（最高到最低）。参数：

array

输入的数组。

sort_flags

可以用可选参数 sort_flags 改变排序的行为

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>

以上例程会输出：

0 = orange 1 = lemon 2 = banana 3 = apple

shuffle — 将数组打乱

本函数打乱（随机排列单元的顺序）一个数组。参数：

array

待操作的数组。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$numbers = range(1, 20);
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
?>

以上例程会输出：

15 9 19 5 17 18 4 10 3 20 7 8 16 6 12 11 14 13 2 1

sizeof — count 的别名

此函数是该函数的别名：count()。

sort — 对数组排序

本函数对数组进行排序。当本函数结束时数组单元将被从最低到最高重新安排。参数：

array 要排序的数组。sort_flags 可选的第二个参数 sort_flags 可以用以下值改变排序的行为：

排序类型标记：

SORT_REGULAR - 正常比较单元（不改变类型）
SORT_NUMERIC - 单元被作为数字来比较
SORT_STRING - 单元被作为字符串来比较
SORT_LOCALE_STRING - 根据当前的区域（locale）设置来把单元当作字符串比较，可以用 setlocale() 来改变。
SORT_NATURAL - 和 natsort() 类似对每个单元以“自然的顺序”对字符串进行排序。 PHP 5.4.0 中新增的。
SORT_FLAG_CASE - 能够与 SORT_STRING 或 SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符串。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
$fruits = array("lemon", "orange", "banana", "apple");
sort($fruits);
foreach ($fruits as $key => $val) {
echo "fruits[" . $key . "] = " . $val . "\n";
}
?>

以上例程会输出：

fruits[0] = apple fruits[1] = banana fruits[2] = lemon fruits[3] = orange

uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联

主要用于对那些单元顺序很重要的结合数组进行排序。比较函数是用户自定义的。参数：

array

输入的数组。

cmp_function

用户自定义比较函数的例子请参考 usort() 和 uksort()。

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
function cmp($a, $b) {
 if ($a == $b) {
 return 0;
 }
 return ($a < $b) ? -1 : 1;
}
$array = array('a' => 4, 'b' => 8, 'c' => -1, 'd' => -9, 'e' => 2, 'f' => 5, 'g' => 3, 'h' => -4);
print_r($array);
uasort($array, 'cmp');
print_r($array);
?>

以上例程会输出：

Array ( [a] => 4 [b] => 8 [c] => -1 [d] => -9 [e] => 2 [f] => 5 [g] => 3 [h] => -4 ) Array ( [d] => -9 [h] => -4 [c] => -1 [e] => 2 [g] => 3 [a] => 4 [f] => 5 [b] => 8 )

uksort — 使用用户自定义的比较函数对数组中的键名进行排序

uksort() 函数将使用用户提供的比较函数对数组中的键名进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。参数：

array

输入的数组。

cmp_function

在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
function cmp($a, $b){
 $a = preg_replace('@^(a|an|the) @', '', $a);
 $b = preg_replace('@^(a|an|the) @', '', $b);
 return strcasecmp($a, $b);
}
$a = array("John" => 1, "the Earth" => 2, "an apple" => 3, "a banana" => 4);
uksort($a, "cmp");
foreach ($a as $key => $value) {
 echo "$key: $value\n";
}
?>

以上例程会输出：

an apple: 3 a banana: 4 the Earth: 2 John: 1

usort — 使用用户自定义的比较函数对数组中的值进行排序

本函数将用用户自定义的比较函数对一个数组中的值进行排序。如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。参数：

array

输入的数组

cmp_function

在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。

int callback ( mixed $a, mixed $b )

返回值：成功时返回 TRUE，或者在失败时返回 FALSE。

例子：

<?php
function cmp($a, $b){
 if ($a == $b) {
 return 0;
 }
 return ($a < $b) ? -1 : 1;
}
$a = array(3, 2, 5, 6, 1);
usort($a, "cmp");
foreach ($a as $key => $value) {
 echo "$key: $value\n";
}
?>

以上例程会输出：

0: 1 1: 2 2: 3 3: 5 4: 6

----------------------------------------------------------------------------------------------------------------------------------

字符串函数：

addcslashes — 以 C 语言风格使用反斜线转义字符串中的字符

返回字符串，该字符串在属于参数 charlist 列表中的字符前都加上了反斜线。参数：

str

要转义的字符。

charlist

如果 charlist 中包含有 \n，\r 等字符，将以 C 语言风格转换，而其它非字母数字且 ASCII 码低于 32 以及高于 126 的字符均转换成使用八进制表示。

当定义 charlist 参数中的字符序列时，需要确实知道介于自己设置的开始及结束范围之内的都是些什么字符。

<?php
echo addcslashes('foo[ ]', 'A..z');
// 输出：\f\o\o\[ \]
// 所有大小写字母均被转义
// ... 但 [\]^_` 以及分隔符、换行符、回车符等也一并被转义了。
?>

另外，如果设置范围中的结束字符 ASCII 码高于开始字符，则不会创建范围，只是将开始字符、结束字符以及其间的字符逐个转义。可使用 ord() 函数获取字符的 ASCII 码值。

<?php
echo addcslashes("zoo['.']", 'z..A');
// 输出：\zoo['\.']
?>

当选择对字符 0，a，b，f，n，r，t 和 v 进行转义时需要小心，它们将被转换成 \0，\a，\b，\f，\n，\r，\t 和 \v。在 PHP 中，只有 \0（NULL），\r（回车符），\n（换行符）和 \t（制表符）是预定义的转义序列，而在 C 语言中，上述的所有转换后的字符都是预定义的转义序列。

返回值：返回转义后的字符。

例子：

<?php
$escaped = addcslashes($not_escaped, "\0..\37!@\177..\377");
?>

addslashes — 使用反斜线引用字符串

返回字符串，该字符串为了数据库查询语句等的需要在某些字符前加上了反斜线。这些字符是单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。

一个使用 addslashes() 的例子是当你要往数据库中输入数据时。例如，将名字 O'reilly 插入到数据库中，这就需要对其进行转义。强烈建议使用 DBMS 指定的转义函数（比如 MySQL 是 mysqli_real_escape_string()，PostgreSQL 是pg_escape_string()），但是如果你使用的 DBMS 没有一个转义函数，并且使用 \ 来转义特殊字符，你可以使用这个函数。仅仅是为了获取插入数据库的数据，额外的 \ 并不会插入。当 PHP 指令 magic_quotes_sybase 被设置成 on时，意味着插入 ' 时将使用 ' 进行转义。参数：

str 要转义的字符。

返回值：返回转义后的字符。

例子：

<?php
$str = "Is your name O'reilly?";
// 输出： Is your name O\'reilly?
echo addslashes($str);
?>

bin2hex — 函数把ASCII字符的字符串转换为十六进制值

返回 ASCII 字符串，为参数 str 的十六进制表示。转换使用字节方式，高四位字节优先。参数：

str

一个字符串。

返回值：返回指定字符串十六进制的表示。

chop — rtrim 的别名

此函数是该函数的别名：rtrim()。

chr — 返回指定的字符

返回相对应于 ascii 所指定的单个字符。此函数与 ord() 是互补的。参数：

ascii Ascii 码。返回值：返回规定的字符。

例子：

<?php
$str = "The string ends in escape: ";
$str .= chr(27); /* 在 $str 后边增加换码符 */
/* 通常这样更有用 */
$str = sprintf("The string ends in escape: %c", 27);
?>

chunk_split — 将字符串分割成小块

使用此函数将字符串分割成小块非常有用。例如将 base64_encode() 的输出转换成符合 RFC 2045 语义的字符串。它会在每 chunklen 个字符后边插入 end。参数：

body

要分割的字符。

chunklen

分割的尺寸。

end

行尾序列符号。

返回值：返回分割后的字符。

例子：

<?php
// 使用 RFC 2045 语义格式化 $data
$new_string = chunk_split(base64_encode($data));
?>

convert_cyr_string — 将字符由一种 Cyrillic 字符转换成另一种

此函数将给定的字符串从一种 Cyrillic 字符转换成另一种，返回转换之后的字符串。参数：

str 要转换的字符。
from 单个字符，代表源 Cyrillic 字符集。
to 单个字符，代表了目标 Cyrillic 字符集。

支持的类型有：

k - koi8-r
w - windows-1251
i - iso8859-5
a - x-cp866
d - x-cp866
m - x-mac-cyrillic

返回值：返回转换后的字符串。

Note: 此函数可安全用于二进制对象。

convert_uudecode — 解码一个 uuencode 编码的字符串

convert_uudecode() 解码一个 uuencode 编码的字符串。参数：

data

uuencode 编码后的数据

返回值：返回解码后的字符串数据，或者在失败时返回 FALSE.。

例子：

<?php
/* 你猜会输出啥？:) */
echo convert_uudecode("+22!L;W9E(%!(4\"$`\n`");
?>

convert_uuencode — 使用 uuencode 编码一个字符串

convert_uuencode() 使用 uuencode 算法对一个字符串进行编码。

uuencode 算法会将所有（含二进制）字符串转化为可输出的字符，并且可以被安全的应用于网络传输。使用 uuencode 编码后的数据将会比源数据大35%左右。参数：

data

需要被编码的数据。

返回值：返回 uuencode 编码后的数据或者在失败时返回 FALSE。例子：<?php
$some_string = "test\ntext text\r\n";
echo convert_uuencode($some_string);
?>

count_chars — 返回字符串所用字符的信息

统计 string 中每个字节值（0..255）出现的次数，使用多种模式返回结果。参数：

string

需要统计的字符串。

mode

参见返回的值。

返回值：根据不同的 mode，count_chars() 返回下列不同的结果：

0 - 以所有的每个字节值作为键名，出现次数作为值的数组。
1 - 与 0 相同，但只列出出现次数大于零的字节值。
2 - 与 0 相同，但只列出出现次数等于零的字节值。
3 - 返回由所有使用了的字节值组成的字符串。
4 - 返回由所有未使用的字节值组成的字符串。

例子：

<?php
$data = "Two Ts and one F.";
foreach (count_chars($data, 1) as $i => $val) {
echo "There were $val instance(s) of \"" , chr($i) , "\" in the string.\n";
}
?>

以上例程会输出：

There were 4 instance(s) of " " in the string. There were 1 instance(s) of "." in the string. There were 1 instance(s) of "F" in the string. There were 2 instance(s) of "T" in the string. There were 1 instance(s) of "a" in the string. There were 1 instance(s) of "d" in the string. There were 1 instance(s) of "e" in the string. There were 2 instance(s) of "n" in the string. There were 2 instance(s) of "o" in the string. There were 1 instance(s) of "s" in the string. There were 1 instance(s) of "w" in the string.

crc32 — 计算一个字符串的 crc32 多项式

生成 str 的 32 位循环冗余校验码多项式。这通常用于检查传输的数据是否完整。参数：

str

要校验的数据。

返回值：返回 str crc32 校验的整数。

例子：

<?php
$checksum = crc32("The quick brown fox jumped over the lazy dog.");
printf("%u\n", $checksum);
?>

crypt — 单向字符串散列

crypt() 返回一个基于标准 UNIX DES 算法或系统上其他可用的替代算法的散列字符串。

有些系统支持不止一种散列类型。实际上，有时候，基于 MD5 的算法被用来替代基于标准 DES 的算法。这种散列类型由盐值参数触发。在 5.3 之前，PHP 在安装时根据系统的 crypt() 决定可用的算法。如果没有提供盐值，PHP 将自动生成一个 2 个字符（DES）或者 12 个字符（MD5）的盐值，这取决于 MD5 crypt() 的可用性。PHP 设置了一个名为CRYPT_SALT_LENGTH 的常量，用来表示可用散列允许的最长可用盐值。

基于标准 DES 算法的 crypt() 在输出内容的开始位置返回两个字符的盐值。它也只使用 str 的开始 8 个字符，所以更长的以相同 8 个字符开始的字符串也将生成相同的结果（当使用了相同的盐值时）。

在 crypt() 函数支持多重散列的系统上，下面的常量根据相应的类型是否可用被设置为 0 或 1：

CRYPT_STD_DES - 基于标准 DES 算法的散列使用 "./0-9A-Za-z" 字符中的两个字符作为盐值。在盐值中使用非法的字符将导致 crypt() 失败。
CRYPT_EXT_DES - 扩展的基于 DES 算法的散列。其盐值为 9 个字符的字符串，由 1 个下划线后面跟着 4 字节循环次数和 4 字节盐值组成。它们被编码成可打印字符，每个字符 6 位，有效位最少的优先。0 到 63 被编码为 "./0-9A-Za-z"。在盐值中使用非法的字符将导致 crypt() 失败。
CRYPT_MD5 - MD5 散列使用一个以 $1$ 开始的 12 字符的字符串盐值。
CRYPT_BLOWFISH - Blowfish 算法使用如下盐值：“$2a$”，一个两位 cost 参数，“$” 以及 64 位由 “./0-9A-Za-z” 中的字符组合而成的字符串。在盐值中使用此范围之外的字符将导致 crypt() 返回一个空字符串。两位 cost 参数是循环次数以 2 为底的对数，它的范围是 04-31，超出这个范围将导致 crypt() 失败。
CRYPT_SHA256 - SHA-256 算法使用一个以 $5$ 开头的 16 字符字符串盐值进行散列。如果盐值字符串以 “rounds=<N>$” 开头，N 的数字值将被用来指定散列循环的执行次数，这点很像 Blowfish 算法的 cost 参数。默认的循环次数是 5000，最小是 1000，最大是 999,999,999。超出这个范围的 N 将会被转换为最接近的值。
CRYPT_SHA512 - SHA-512 算法使用一个以 $6$ 开头的 16 字符字符串盐值进行散列。如果盐值字符串以 “rounds=<N>$” 开头，N 的数字值将被用来指定散列循环的执行次数，这点很像 Blowfish 算法的 cost 参数。默认的循环次数是 5000，最小是 1000，最大是 999,999,999。超出这个范围的 N 将会被转换为最接近的值。参数：

str 待散列的字符串。salt 可选的盐值字符串。如果没有提供，算法行为将由不同的算法实现决定，并可能导致不可预料的结束。返回值：返回散列后的字符串或一个少于 13 字符的字符串，从而保证在失败时与盐值区分开来。

例子：

<?php
$password = crypt('mypassword'); // 自动生成盐值
/* 你应当使用 crypt() 得到的完整结果作为盐值进行密码校验，以此来避免使用不同散列算法导致的问题。（如上所述，基于标准 DES 算法的密码散列使用 2 字符盐值，但是基于 MD5 算法的散列使用 12 个字符盐值。）*/
if (crypt($user_input, $password) == $password) {
echo "Password verified!";
}
?>

利用 htpasswd 进行 crypt() 加密

<?php
// 设置密码
$password = 'mypassword';
// 获取散列值，使用自动盐值
$hash = crypt($password);
?>

以不同散列类型使用 crypt()

<?php
if (CRYPT_STD_DES == 1) {
 echo 'Standard DES: ' . crypt('rasmuslerdorf', 'rl') . "\n";
}
if (CRYPT_EXT_DES == 1) {
 echo 'Extended DES: ' . crypt('rasmuslerdorf', '_J9..rasm') . "\n";
}
if (CRYPT_MD5 == 1) {
 echo 'MD5: ' . crypt('rasmuslerdorf', '$1$rasmusle$') . "\n";
}
if (CRYPT_BLOWFISH == 1) {
 echo 'Blowfish: ' . crypt('rasmuslerdorf', '$2a$07$usesomesillystringforsalt$') . "\n";
}
if (CRYPT_SHA256 == 1) {
 echo 'SHA-256: ' . crypt('rasmuslerdorf', '$5$rounds=5000$usesomesillystringforsalt$') . "\n";
}
if (CRYPT_SHA512 == 1) {
 echo 'SHA-512: ' . crypt('rasmuslerdorf', '$6$rounds=5000$usesomesillystringforsalt$') . "\n";
}
?>

以上例程会输出：

Standard DES: rl.3StKT.4T8M

Extended DES: _J9..rasmBYk8r9AiWNc

MD5:          $1$rasmusle$rISCgZzpwk3UhDidwXvin0

Blowfish:     $2a$07$usesomesillystringfore2uDLvp1Ii2e./U9C8sBjqp8I90dH6hi

SHA-256:      $5$rounds=5000$usesomesillystri$KqJWpanXZHKq2BOB43TSaYhEWsQ1Lr5QNyPCDH/Tp.6

SHA-512:      $6$rounds=5000$usesomesillystri$D4IrlXatmP7rx3P3InaxBeoomnAihCKRVQP22JZ6EY47Wc6BkroIuUUBOov1i.S5KPgErtP/EN5mcO.ChWQW21

echo — 输出一个或多个字符串

echo 不是一个函数（它是一个语言结构），因此你不一定要使用小括号来指明参数，单引号，双引号都可以。 echo（不像其他语言构造）不表现得像一个函数，所以不能总是使用一个函数的上下文。另外，如果你想给echo 传递多个参数，那么就不能使用小括号。

echo 也有一个快捷用法，你可以在打开标记前直接用一个等号。在 PHP 5.4.0 之前，必须在php.ini 里面启用short_open_tag 才有效。

I have <?=$foo?> foo.

explode — 使用一个字符串分割另一个字符串

此函数返回由字符串组成的数组，每个元素都是 string 的一个子串，它们被字符串 delimiter 作为边界点分割出来。参数：

delimiter

边界上的分隔字符。


string

输入的字符串。


limit

如果设置了 limit 参数并且是正数，则返回的数组包含最多 limit 个元素，而最后那个元素将包含 string的剩余部分。

如果 limit 参数是负数，则返回除了最后的 -limit 个元素外的所有元素。

如果 limit 是 0，则会被当做 1。

由于历史原因，虽然 implode() 可以接收两种参数顺序，但是 explode() 不行。你必须保证 separator 参数在string 参数之前才行。

返回值：

此函数返回由字符串组成的 array，每个元素都是 string 的一个子串，它们被字符串 delimiter 作为边界点分割出来。

如果 delimiter 为空字符串（""），explode() 将返回 FALSE。如果 delimiter 所包含的值在 string 中找不到，并且使用了负数的 limit ，那么会返回空的 array，否则返回包含 string 单个元素的数组。

例子：

<?php
// 示例 1
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2
// 示例 2
$data = "foo:*:1023:1000::/home/foo:/bin/sh";
list($user, $pass, $uid, $gid, $gecos, $home, $shell) = explode(":", $data);
echo $user; // foo
echo $pass; // *
?>

<?php
/* A string that doesn't contain the delimiter will simply return a one-length array of the original string. */
$input1 = "hello";
$input2 = "hello,there";
var_dump( explode( ',', $input1 ) );
var_dump( explode( ',', $input2 ) );
?>

以上例程会输出：

array(1) { [0]=> string(5) "hello" } array(2) { [0]=> string(5) "hello" [1]=> string(5) "there" }

以上例程会输出：

Array ( [0] => one [1] => two|three|four ) Array ( [0] => one [1] => two [2] => three )

fprintf — 将格式化后的字符串写入到流

写入一个根据 format 格式化后的字符串到由 handle 句柄打开的流中。参数：

handle

文件系统指针，是典型地由 fopen() 创建的 resource(资源)。

format

参见 sprintf() 中对 format 的描述。

args...返回值：返回写入的字符串长度。

例子：

<?php
if (!($fp = fopen('date.txt', 'w'))) {
return;
}
fprintf($fp, "%04d-%02d-%02d", $year, $month, $day);
// will write the formatted ISO date to date.txt
?>

<?php
if (!($fp = fopen('currency.txt', 'w'))) {
return;
}
$money1 = 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money will output "123.1";
$len = fprintf($fp, '%01.2f', $money);
// will write "123.10" to currency.txt
echo "wrote $len bytes to currency.txt";
// use the return value of fprintf to determine how many bytes we wrote
?>

get_html_translation_table — 返回使用 htmlspecialchars 和 htmlentities 后的转换表

get_html_translation_table() 将返回 htmlspecialchars() 和 htmlentities() 处理后的转换表。

Note：

特殊字符可以使用多种转换方式。例如： " 可以被转换成 ", " 或者 &#x22.get_html_translation_table() 返回其中最常用的。参数：

table 有两个新的常量 (HTML_ENTITIES, HTML_SPECIALCHARS) 允许你指定你想要的表。flags A bitmask of one or more of the following flags, which specify which quotes the table will contain as well as which document type the table is for. The default is ENT_COMPAT | ENT_HTML401.

Available `flags` constants
Constant Name	Description
`ENT_COMPAT`	Table will contain entities for double-quotes, but not for single-quotes.
`ENT_QUOTES`	Table will contain entities for both double and single quotes.
`ENT_NOQUOTES`	Table will neither contain entities for single quotes nor for double quotes.
`ENT_HTML401`	Table for HTML 4.01.
`ENT_XML1`	Table for XML 1.
`ENT_XHTML`	Table for XHTML.
`ENT_HTML5`	Table for HTML 5.

encoding Encoding to use. If omitted, the default value for this argument is ISO-8859-1 in versions of PHP prior to 5.4.0, and UTF-8 from PHP 5.4.0 onwards.

支持以下字符集：

支持的字符集列表
字符集	别名	描述
ISO-8859-1	ISO8859-1	西欧，Latin-1
ISO-8859-5	ISO8859-5	Little used cyrillic charset (Latin/Cyrillic).
ISO-8859-15	ISO8859-15	西欧，Latin-9。增加欧元符号，法语和芬兰语字母在 Latin-1(ISO-8859-1) 中缺失。
UTF-8		ASCII 兼容的多字节 8 位 Unicode。
cp866	ibm866, 866	DOS 特有的西里尔编码。本字符集在 4.3.2 版本中得到支持。
cp1251	Windows-1251, win-1251, 1251	Windows 特有的西里尔编码。本字符集在 4.3.2 版本中得到支持。
cp1252	Windows-1252, 1252	Windows 特有的西欧编码。
KOI8-R	koi8-ru, koi8r	俄语。本字符集在 4.3.2 版本中得到支持。
BIG5	950	繁体中文，主要用于中国台湾省。
GB2312	936	简体中文，中国国家标准字符集。
BIG5-HKSCS		繁体中文，附带香港扩展的 Big5 字符集。
Shift_JIS	SJIS, 932	日语
EUC-JP	EUCJP	日语
MacRoman		Mac OS 使用的字符串。
''		An empty string activates detection from script encoding (Zend multibyte),default_charset and current locale (see nl_langinfo() and setlocale()), in this order. Not recommended.

Note: 其他字符集没有认可。将会使用默认编码并抛出异常。

返回值：将转换表作为一个数组返回。

例子：

<?php
var_dump(get_html_translation_table(HTML_ENTITIES, ENT_QUOTES | ENT_HTML5));
?>

hebrev — 将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew）

将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew）

函数将会尝试避免破坏单词。参数：

hebrew_text 逻辑顺序希伯来文字符串。

max_chars_per_line 可选参数，表示每行可返回的最多字符数。

返回值：返回视觉顺序字符串。

hebrevc — 将逻辑顺序希伯来文（logical-Hebrew）转换为视觉顺序希伯来文（visual-Hebrew），并且转换换行符

本函数与hebrev() 一样，唯一的区别是本函数会额外将换行符(\n)转换为" \n"。

函数将会尝试避免破坏单词。参数：

hebrew_text

逻辑顺序希伯来文字符串。

max_chars_per_line

可选参数，表示每行可返回的最多字符数。

返回值：返回视觉顺序字符串。

hex2bin — 转换十六进制字符串为二进制字符串

转换十六进制字符串为二进制字符串。

Caution

这个函数不是转换十六进制数字为二进制数字。这种转换可以使用base_convert() 函数。

参数：data 十六进制表示的数据返回值：返回给定数据的二进制表示或者在失败时返回 FALSE。例子：<?php
$hex = hex2bin("6578616d706c65206865782064617461");
var_dump($hex);
?>

以上例程会输出：

string(16) "example hex data"

html_entity_decode — Convert all HTML entities to their applicable characters

<?php
$orig = "I'll \"walk\" the dog now";
$a = htmlentities($orig);
$b = html_entity_decode($a);
echo $a; // I'll "walk" the dog now
echo $b; // I'll "walk" the dog now
?>

htmlentities — Convert all applicable characters to HTML entities

<?php
$str = "A 'quote' is bold";
// Outputs: A 'quote' is bold
echo htmlentities($str);
// Outputs: A 'quote' is bold
echo htmlentities($str, ENT_QUOTES);
?>

<?php
$str = "\x8F!!!";
// Outputs an empty string
echo htmlentities($str, ENT_QUOTES, "UTF-8");
// Outputs "!!!"
echo htmlentities($str, ENT_QUOTES | ENT_IGNORE, "UTF-8");
?>

htmlspecialchars_decode — 将特殊的 HTML 实体转换回普通字符

此函数的作用和 htmlspecialchars() 刚好相反。它将特殊的HTML实体转换回普通字符。

被转换的实体有： &， " （没有设置ENT_NOQUOTES 时）, ' （设置了 ENT_QUOTES 时）， < 以及>。参数：

string 要解码的字符串flags 用下列标记中的一个或多个作为一个位掩码，来指定如何处理引号和使用哪种文档类型。默认为 ENT_COMPAT | ENT_HTML401。

有效的 `flags` 常量
常量名	说明
`ENT_COMPAT`	转换双引号，不转换单引号。
`ENT_QUOTES`	单引号和双引号都转换。
`ENT_NOQUOTES`	单引号和双引号都不转换。
`ENT_HTML401`	作为HTML 4.01编码处理。
`ENT_XML1`	作为XML 1编码处理。
`ENT_XHTML`	作为XHTML编码处理。
`ENT_HTML5`	作为HTML 5编码处理。

返回值：返回解码后的字符串。

例子：

<?php
$str = "this -> "\n";
echo htmlspecialchars_decode($str);
// 注意，这里的引号不会被转换
echo htmlspecialchars_decode($str, ENT_NOQUOTES);
?>

以上例程会输出：

this -> "

htmlspecialchars — Convert special characters to HTML entities

<?php
$new = htmlspecialchars("<a href='test'>Test</a>", ENT_QUOTES);
echo $new; // <a href='test'>Test</a>
?>

implode — 将一个一维数组的值转化为字符串

用 glue 将一维数组的值连接为一个字符串。参数：

glue

默认为空的字符串。

pieces

你想要转换的数组。

返回值：返回一个字符串，其内容为由 glue 分割开的数组的值。

例子：

<?php
$array = array('lastname', 'email', 'phone');
$comma_separated = implode(",", $array);
echo $comma_separated; // lastname,email,phone
// Empty string when using an empty array:
var_dump(implode('hello', array())); // string(0) ""
?>

join — 别名 implode

此函数是该函数的别名： implode().

lcfirst — 使一个字符串的第一个字符小写

返回str的第一个字符小写了的字符串。如果str的第一个字符是字母，则将其转换为小写。

需要注意的是“字母”是由当前语言区域决定的。比如，在默认的“C”区域像日耳曼语系中的元音变音a (ä) 将不会被转换。参数：

str 输入的字符串。返回值：返回转换后的字符串。例子：<?php
$foo = 'HelloWorld';
$foo = lcfirst($foo); // helloWorld
$bar = 'HELLO WORLD!';
$bar = lcfirst($bar); // hELLO WORLD!
$bar = lcfirst(strtoupper($bar)); // hELLO WORLD!
?>

levenshtein — 计算两个字符串之间的编辑距离

编辑距离，是指两个字串之间，通过替换、插入、删除等操作将字符串str1转换成str2所需要操作的最少字符数量。该算法的复杂度是 O(m*n)，其中 n 和 m 分别是str1 和str2的长度（当和算法复杂度为O(max(n,m)**3)的similar_text()相比时，此函数还是相当不错的，尽管仍然很耗时。）。

在最简单的形式中，该函数只以两个字符串作为参数，并计算通过插入、替换和删除等操作将str1转换成str2所需要的操作次数。

第二种变体将采用三个额外的参数来定义插入、替换和删除操作的次数。此变体比第一种更加通用和适应，但效率不高。参数：

str1

求编辑距离中的其中一个字符串

str2

求编辑距离中的另一个字符串

cost_ins

定义插入次数

cost_rep

定义替换次数

cost_del

定义删除次数

此函数返回两个字符串参数之间的编辑距离，如果其中一个字符串参数长度大于限制的255个字符时，返回-1。

例子：

<?php
// 输入拼写错误的单词
$input = 'carrrot';
// 要检查的单词数组
$words = array('apple','pineapple','banana','orange',
 'radish','carrot','pea','bean','potato');
// 目前没有找到最短距离
$shortest = -1;
// 遍历单词来找到最接近的
foreach ($words as $word) {
 // 计算输入单词与当前单词的距离
 $lev = levenshtein($input, $word);
 // 检查完全的匹配
 if ($lev == 0) {
 // 最接近的单词是这个（完全匹配）
 $closest = $word;
 $shortest = 0;
 // 退出循环；我们已经找到一个完全的匹配
 break;
 }
 // 如果此次距离比上次找到的要短
 // 或者还没找到接近的单词
 if ($lev <= $shortest || $shortest < 0) {
 // 设置最接近的匹配以及它的最短距离
 $closest = $word;
 $shortest = $lev;
 }
}
echo "Input word: $input\n";
if ($shortest == 0) {
 echo "Exact match found: $closest\n";
} else {
 echo "Did you mean: $closest?\n";
}
?>

以上例程会输出：

Input word: carrrot Did you mean: carrot?

localeconv — Get numeric formatting information

<?php
if (false !== setlocale(LC_ALL, 'nl_NL.UTF-8@euro')) {
$locale_info = localeconv();
print_r($locale_info);
}
?>

ltrim — 删除字符串开头的空白字符（或其他字符）

删除字符串开头的空白字符（或其他字符）参数：

str

输入的字符串。

character_mask

通过参数 character_mask，你也可以指定想要删除的字符，简单地列出你想要删除的所有字符即可。使用..，可以指定字符的范围。

返回值：该函数返回一个删除了 str 最左边的空白字符的字符串。如果不使用第二个参数， ltrim() 仅删除以下字符：

" " (ASCII 32 (0x20))，普通空白字符。
"\t" (ASCII 9 (0x09))，制表符.
"\n" (ASCII 10 (0x0A))，换行符。
"\r" (ASCII 13 (0x0D))，回车符。
"\0" (ASCII 0 (0x00))， NUL空字节符。
"\x0B" (ASCII 11 (0x0B))，垂直制表符。

例子：

<?php
$text = "\t\tThese are a few words :) ... ";
$binary = "\x09Example string\x0A";
$hello = "Hello World";
var_dump($text, $binary, $hello);
print "\n";
$trimmed = ltrim($text);
var_dump($trimmed);
$trimmed = ltrim($text, " \t.");
var_dump($trimmed);
$trimmed = ltrim($hello, "Hdle");
var_dump($trimmed);
// 删除 $binary 开头的 ASCII 控制字符
// (从 0 到 31，包括 0 和 31)
$clean = ltrim($binary, "\x00..\x1F");
var_dump($clean);
?>

以上例程会输出：

string(32) " These are a few words :) ... " string(16) " Example string " string(11) "Hello World" string(30) "These are a few words :) ... " string(30) "These are a few words :) ... " string(7) "o World" string(15) "Example string "

md5_file — 计算指定文件的 MD5 散列值

使用 » RSA 数据安全公司的 MD5 报文算法计算 filename 文件的 MD5 散列值并返回。该散列值为 32 字符的十六进制数字。参数：

filename

文件名

raw_output

如果被设置为 TRUE，那么报文摘要将以原始的 16 位二进制格式返回。

返回值：成功返回字符串，否则返回 FALSE。

例子：

<?php
$file = 'php-5.3.0alpha2-Win32-VC9-x64.zip';
echo 'MD5 file hash of ' . $file . ': ' . md5_file($file);
?>

md5 — 计算字符串的 MD5 散列值

使用 » RSA 数据安全公司的 MD5 报文算法计算 str 的 MD5 散列值。参数：

str

原始字符串。

raw_output

如果可选的 raw_output 被设置为 TRUE，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。

返回值：以 32 字符十六进制数字形式返回散列值。

例子：

<?php
$str = 'apple';
if (md5($str) === '1f3870be274f6c49b3e31a0c6728957f') {
echo "Would you like a green or red apple?";
}
?>

metaphone — Calculate the metaphone key of a string

返回值：Returns the metaphone key as a string, 或者在失败时返回 FALSE.

<?php
var_dump(metaphone('programming'));
var_dump(metaphone('programmer'));
?>

以上例程会输出：

string(7) "PRKRMNK" string(6) "PRKRMR"

<?php
var_dump(metaphone('programming', 5));
var_dump(metaphone('programmer', 5));
?>

以上例程会输出：

string(5) "PRKRM" string(5) "PRKRM"

money_format — Formats a number as a currency string

<?php
$number = 1234.56;
// let's print the international format for the en_US locale
setlocale(LC_MONETARY, 'en_US');
echo money_format('%i', $number) . "\n";
// USD 1,234.56
// Italian national format with 2 decimals`
setlocale(LC_MONETARY, 'it_IT');
echo money_format('%.2n', $number) . "\n";
// Eu 1.234,56
// Using a negative number
$number = -1234.5672;
// US national format, using () for negative numbers
// and 10 digits for left precision
setlocale(LC_MONETARY, 'en_US');
echo money_format('%(#10n', $number) . "\n";
// ($ 1,234.57)
// Similar format as above, adding the use of 2 digits of right
// precision and '*' as a fill character
echo money_format('%=*(#10.2n', $number) . "\n";
// ($********1,234.57)
// Let's justify to the left, with 14 positions of width, 8 digits of
// left precision, 2 of right precision, withouth grouping character
// and using the international format for the de_DE locale.
setlocale(LC_MONETARY, 'de_DE');
echo money_format('%=*^-14#8.2i', 1234.56) . "\n";
// Eu 1234,56****
// Let's add some blurb before and after the conversion specification
setlocale(LC_MONETARY, 'en_GB');
$fmt = 'The final value is %i (after a 10%% discount)';
echo money_format($fmt, 1234.56) . "\n";
// The final value is GBP 1,234.56 (after a 10% discount)
?>

nl_langinfo — Query language and locale information

Note: 此函数未在 Windows 平台下实现。

nl2br — 在字符串所有新行之前插入 HTML 换行标记

在字符串 string 所有新行之前插入 ' ' 或 ' '，并返回。参数：

string

输入字符串。

is_xhtml

是否使用 XHTML 兼容换行符。

返回值：返回调整后的字符串。

例子：

<?php
echo nl2br("foo isn't\n bar");

echo nl2br("Welcome\r\nThis is my HTML document", false);

$string = "This\r\nis\n\ra\nstring\r";
echo nl2br($string);
?>

以上例程会输出：

foo isn't
bar
Warning: Wrong parameter count for nl2br() in D:\wamp\www\MyPHP\test2PHP.php on line 202
This
is
a
string

number_format — 以千位分隔符方式格式化一个数字

本函数可以接受1个、2个或者4个参数（注意：不能是3个）:

如果只提供第一个参数，number的小数部分会被去掉并且每个千位分隔符都是英文小写逗号","

如果提供两个参数，number将保留小数点后的位数到你设定的值，其余同楼上

如果提供了四个参数，number 将保留decimals个长度的小数部分, 小数点被替换为dec_point，千位分隔符替换为thousands_sep。参数：

number 你要格式化的数字decimals 要保留的小数位数dec_point 指定小数点显示的字符thousands_sep 指定千位分隔符显示的字符返回值：格式化以后的 number.

例子：

<?php
$number = 1234.56;
// english notation (default)
$english_format_number = number_format($number);
// 1,235
// French notation
$nombre_format_francais = number_format($number, 2, ',', ' ');
// 1 234,56
$number = 1234.5678;
// english notation without thousands separator
$english_format_number = number_format($number, 2, '.', '');
// 1234.57
?>

ord — 返回字符的 ASCII 码值

返回字符串 string 第一个字符的 ASCII 码值。

该函数是 chr() 的互补函数。参数：

string

一个字符。

返回值：返回整型的 ASCII 码值。

例子：

<?php
$str = "\n";
if (ord($str) == 10) {
echo "The first character of \$str is a line feed.\n";
}
?>

parse_str — 将字符串解析成多个变量

如果 str 是 URL 传递入的查询字符串（query string），则将它解析为变量并设置到当前作用域。参数：

str

输入的字符串。

arr

如果设置了第二个变量 arr，变量将会以数组元素的形式存入到这个数组，作为替代。

返回值：没有返回值。

例子：

<?php
$str = "first=value&arr[]=foo+bar&arr[]=baz";
parse_str($str);
echo $first; // value
echo $arr[0]; // foo bar
echo $arr[1]; // baz
parse_str($str, $output);
echo $output['first']; // value
echo $output['arr'][0]; // foo bar
echo $output['arr'][1]; // baz
?>

print — 输出字符串

输出 arg。

print 实际上不是一个函数（它是一个语言结构），因此你可以不必使用圆括号来括起它的参数列表。

返回值：总是返回 1。

printf — 输出格式化字符串

依据 format 格式参数产生输出。参数：

format

format 描述信息，请参见 sprintf()。

args...返回值：返回输出字符串的长度。

quoted_printable_decode — 将 quoted-printable 字符串转换为 8-bit 字符串

该函数返回 quoted-printable 解码之后的 8-bit 字符串 (参考 » RFC2045 的6.7章节，而不是 » RFC2821 的4.5.2章节，so additional periods are not stripped from the beginning of line)

该函数与 imap_qprint() 函数十分相似，但是该函数不需要依赖 IMAP 模块。参数：

str

输入的字符串。

返回值：返回的 8-bit 二进制字符串。

quoted_printable_encode — 将 8-bit 字符串转换成 quoted-printable 字符串

返回 quoted-printable 格式的字符，该格式由 » RFC2045 6.7.章节里制定。

该函数与 imap_8bit() 函数十分相似，不同的是该函数不需要 IMAP 模块就能运行。参数：

str

输入的字符串。

返回值：返回编码之后的字符串。

quotemeta — 转义元字符集

返回在下面这些特殊字符前加反斜线(\) 转义后的字符串。这些特殊字符包含：

. \ + * ? [ ^ ] ( $ )。参数：

str

输入字符串

返回值：返回元字符集被转义后的字符串，如果输入字符串str为空，则返回 FALSE。

Note: 此函数可安全用于二进制对象。

rtrim — 删除字符串末端的空白字符（或者其他字符）

该函数删除 str 末端的空白字符并返回。

不使用第二个参数，rtrim() 仅删除以下字符：

" " (ASCII 32 (0x20))，普通空白符。
"\t" (ASCII 9 (0x09))，制表符。
"\n" (ASCII 10 (0x0A))，换行符。
"\r" (ASCII 13 (0x0D))，回车符。
"\0" (ASCII 0 (0x00))，NUL 空字节符。
"\x0B" (ASCII 11 (0x0B))，垂直制表符。参数：

str

输入字符串。

character_mask

通过指定 character_mask，可以指定想要删除的字符列表。简单地列出你想要删除的全部字符。使用 .. 格式，可以指定一个范围。

返回值：返回改变后的字符串。

<?php
$text = "\t\tThese are a few words :) ... ";
$binary = "\x09Example string\x0A";
$hello = "Hello World";
var_dump($text, $binary, $hello);
print "\n";
$trimmed = rtrim($text);
var_dump($trimmed);
$trimmed = rtrim($text, " \t.");
var_dump($trimmed);
$trimmed = rtrim($hello, "Hdle");
var_dump($trimmed);
// 删除 $binary 末端的 ASCII 码控制字符
// (包括 0 - 31)
$clean = rtrim($binary, "\x00..\x1F");
var_dump($clean);
?>

以上例程会输出：

string(32) " These are a few words :) ... " string(16) " Example string " string(11) "Hello World" string(30) " These are a few words :) ..." string(26) " These are a few words :)" string(9) "Hello Wor" string(15) " Example string"

setlocale — 设置地区信息

设置地区信息。参数：

category category 命名常量指定的受区域设置的功能类别:

LC_ALL 所有的设置
LC_COLLATE 字符串比较, 详见 strcoll()
LC_CTYPE 字符串的分类与转换, 参见例子 strtoupper()
LC_MONETARY 等同 localeconv()
LC_NUMERIC 对于小数点的分隔 (另请参见 localeconv())
LC_TIME 时间与格式 strftime()
LC_MESSAGES 系统响应 (如果PHP使用libintl编译)

locale If locale is NULL or the empty string "", the locale names will be set from the values of environment variables with the same names as the above categories, or from "LANG".If locale is "0", the locale setting is not affected, only the current setting is returned.If locale is an array or followed by additional parameters then each array element or parameter is tried to be set as new locale until success. This is useful if a locale is known under different names on different systems or for providing a fallback for a possibly not available locale....(可使用字符串或数组参数进行尝试直到设置成功。)例子：<?php
/* Set locale to Dutch */
setlocale(LC_ALL, 'nl_NL');
/* Output: vrijdag 22 december 1978 */
echo strftime("%A %e %B %Y", mktime(0, 0, 0, 12, 22, 1978));
/* try different possible locale names for german as of PHP 4.3.0 */
$loc_de = setlocale(LC_ALL, 'de_DE@euro', 'de_DE', 'de', 'ge');
echo "Preferred locale for german on this system is '$loc_de'";
?>

<?php
/* Set locale to Dutch */
setlocale(LC_ALL, 'nld_nld');
/* Output: vrijdag 22 december 1978 */
echo strftime("%A %d %B %Y", mktime(0, 0, 0, 12, 22, 1978));
/* try different possible locale names for german as of PHP 4.3.0 */
$loc_de = setlocale(LC_ALL, 'de_DE@euro', 'de_DE', 'deu_deu');
echo "Preferred locale for german on this system is '$loc_de'";
?>

sha1_file — 计算文件的 sha1 散列值

利用» 美国安全散列算法 1，计算并返回由 filename 指定的文件的 sha1 散列值。该散列值是一个 40 字符长度的十六进制数字。参数：

filename

要散列的文件的文件名。

raw_output

如果被设置为 TRUE，sha1 摘要将以 20 字符长度的原始格式返回。

返回值：成功返回一个字符串，否则返回 FALSE。

例子：

<?php
foreach(glob('/home/Kalle/myproject/*.php') as $ent){
 if(is_dir($ent)){
 continue;
 }
 echo $ent . ' (SHA1: ' . sha1_file($ent) . ')', PHP_EOL;
}
?>

sha1 — 计算字符串的 sha1 散列值

利用» 美国安全散列算法 1 计算字符串的 sha1 散列值。参数：

str

输入字符串。

raw_output

如果可选的 raw_output 参数被设置为 TRUE，那么 sha1 摘要将以 20 字符长度的原始格式返回，否则返回值是一个 40 字符长度的十六进制数字。

返回值：返回 sha1 散列值字符串。

例子：

<?php
$str = 'apple';
if (sha1($str) === 'd0be2dc421be4fcd0172e5afceea3970e2f3d940') {
echo "Would you like a green or red apple?";
}
?>

similar_text — 计算两个字符串的相似度

两个字符串的相似程度计算依据 Programming Classics: Implementing the World's Best Algorithms by Oliver (ISBN 0-131-00413-1) 的描述进行。注意该实现没有使用 Oliver 虚拟码中的堆栈，但是却进行了递归调用，这个做法可能会导致整个过程变慢或变快。也请注意，该算法的复杂度是 O(N**3)，N 是最长字符串的长度。参数

first 第一个字符串。second 第二个字符串。percent 通过引用方式传递第三个参数，similar_text() 将计算相似程度百分数。返回值：返回在两个字符串中匹配字符的数目。

soundex — Calculate the soundex key of a string

<?php
soundex("Euler") == soundex("Ellery"); // E460
soundex("Gauss") == soundex("Ghosh"); // G200
soundex("Hilbert") == soundex("Heilbronn"); // H416
soundex("Knuth") == soundex("Kant"); // K530
soundex("Lloyd") == soundex("Ladd"); // L300
soundex("Lukasiewicz") == soundex("Lissajous"); // L222
?>

sprintf — Return a formatted string

返回值：Returns a string produced according to the formatting string format.

例子：

<?php
$n =  43951789;
$u = -43951789;
$c = 65; // ASCII 65 is 'A'
// notice the double %%, this prints a literal '%' character
printf("%%b = '%b'\n", $n); // binary representation
printf("%%c = '%c'\n", $c); // print the ascii character, same as chr() function
printf("%%d = '%d'\n", $n); // standard integer representation
printf("%%e = '%e'\n", $n); // scientific notation
printf("%%u = '%u'\n", $n); // unsigned integer representation of a positive integer
printf("%%u = '%u'\n", $u); // unsigned integer representation of a negative integer
printf("%%f = '%f'\n", $n); // floating point representation
printf("%%o = '%o'\n", $n); // octal representation
printf("%%s = '%s'\n", $n); // string representation
printf("%%x = '%x'\n", $n); // hexadecimal representation (lower-case)
printf("%%X = '%X'\n", $n); // hexadecimal representation (upper-case)
printf("%%+d = '%+d'\n", $n); // sign specifier on a positive integer
printf("%%+d = '%+d'\n", $u); // sign specifier on a negative integer
?>

以上例程会输出：

%b = '10100111101010011010101101'

%c = 'A'

%d = '43951789'

%e = '4.39518e+7'

%u = '43951789'

%u = '4251015507'

%f = '43951789.000000'

%o = '247523255'

%s = '43951789'

%x = '29ea6ad'

%X = '29EA6AD'

%+d = '+43951789'

%+d = '-43951789'

printf(): string specifiers

<?php
$s = 'monkey';
$t = 'many monkeys';
printf("[%s]\n",      $s); // standard string output
printf("[%10s]\n",    $s); // right-justification with spaces
printf("[%-10s]\n",   $s); // left-justification with spaces
printf("[%010s]\n",   $s); // zero-padding works on strings too
printf("[%'#10s]\n",  $s); // use the custom padding character '#'
printf("[%10.10s]\n", $t); // left-justification but with a cutoff of 10 characters
?>

以上例程会输出：

[monkey]

[    monkey]

[monkey    ]

[0000monkey]

[####monkey]

[many monke]

sprintf(): zero-padded integers

<?php
$isodate = sprintf("%04d-%02d-%02d", $year, $month, $day);
?>

sprintf(): formatting currency

<?php
$money1 = 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money will output "123.1";
$formatted = sprintf("%01.2f", $money);
// echo $formatted will output "123.10"
?>

sprintf(): scientific notation

<?php
$number = 362525200;
echo sprintf("%.3e", $number); // outputs 3.625e+8
?>

sscanf — 根据指定格式解析输入的字符

这个函数 sscanf() 输入类似 printf()。 sscanf() 读取字符串str 然后根据指定格式format解析, 格式的描述文档见sprintf()。

指定的格式字符串中的任意空白匹配输入字符串的任意空白.也就是说即使是格式字符串中的一个制表符 \t 也能匹配输入字符串中的一个单一空格字符。参数：

str 将要被解析的字符串.format The interpreted format for 解析str的格式, 除了以下不同外，其余的见 sprintf()的描述文档:

函数不区分语言地区
F, g, G 和 b 不被支持.
D 表示十进制数字.
i stands for integer with base detection.
n stands for number of characters processed so far.

...

可以选参数将以引用方式传入，它们的值将被设置为解析匹配的值

返回值：如果仅传入了两个参数给这个函数，解析后将返回一个数组，否则，如果可选参数被传入，这个函数将返回被设置了值的个数。如果format存在的子字符串比 str内可用的多, -1 将被返回.

例子：

<?php
// getting the serial number
list($serial) = sscanf("SN/2350001", "SN/%d");
// and the date of manufacturing
$mandate = "January 01 2000";
list($month, $day, $year) = sscanf($mandate, "%s %d %d");
echo "Item $serial was manufactured on: $year-" . substr($month, 0, 3) . "-$day\n";
?>

If optional parameters are passed, the function will return the number of assigned values.

sscanf() - using optional parameters

<?php
// get author info and generate DocBook entry
$auth = "24\tLewis Carroll";
$n = sscanf($auth, "%d\t%s %s", $id, $first, $last);
echo "<author id='$id'>
    <firstname>$first</firstname>
    <surname>$last</surname>
</author>\n";
?>

str_getcsv — 解析 CSV 字符串为一个数组

以 CSV 字段格式解析字符串输入，并返回包含读取字段的数组。参数：

input

待解析的字符串。

delimiter

设定字段界定符（仅单个字符）。

enclosure

设定字段包裹字符（仅单个字符）。

escape

设置转义字符（仅单个字符）。默认为反斜线（\）。

返回值：返回一个包含读取到的字段的索引数组。

str_ireplace — str_replace 的忽略大小写版本

该函数返回一个字符串或者数组。该字符串或数组是将 subject 中全部的 search 都被 replace 替换（忽略大小写）之后的结果。如果没有一些特殊的替换规则，你应该使用该函数替换带有 i 修正符的 preg_replace() 函数。参数：

如果 search 和 replace 为数组，那么 str_replace() 将对 subject 做二者的映射替换。如果 replace 的值的个数少于 search 的个数，多余的替换将使用空字符串来进行。如果 search 是一个数组而 replace 是一个字符串，那么 search 中每个元素的替换将始终使用这个字符串。

如果 search 或 replace 是数组，他们的元素将从头到尾一个个处理。

search

要搜索的值，就像是 needle。可以使用 array 来提供多个 needle。


replace

The replacement value that replaces found search values. An array may be used to designate multiple replacements.


subject

要被搜索和替换的字符串或数组，就像是 haystack。

如果 subject 是一个数组，替换操作将遍历整个 subject，并且也将返回一个数组。


count

如果设定了，将会设置执行替换的次数。

返回值：返回替换后的字符串或者数组。

例子：

<?php
$bodytag = str_ireplace("%body%", "black", "<body text=%BODY%>");
?>

Note: 此函数可安全用于二进制对象。

str_pad — 使用另一个字符串填充字符串为指定长度

该函数返回 input 被从左端、右端或者同时两端被填充到制定长度后的结果。如果可选的 pad_string 参数没有被指定，input 将被空格字符填充，否则它将被 pad_string 填充到指定长度。参数：

input

输入字符串。

pad_length

如果 pad_length 的值是负数，小于或者等于输入字符串的长度，不会发生任何填充。

pad_string

Note:

如果填充字符的长度不能被 pad_string 整除，那么 pad_string 可能会被缩短。

pad_type

可选的 pad_type 参数的可能值为 STR_PAD_RIGHT，STR_PAD_LEFT 或 STR_PAD_BOTH。如果没有指定pad_type，则假定它是 STR_PAD_RIGHT。

返回值：返回填充后的字符串。

例子：

<?php
$input = "Alien";
echo str_pad($input, 10); // 输出 "Alien "
echo str_pad($input, 10, "-=", STR_PAD_LEFT); // 输出 "-=-=-Alien"
echo str_pad($input, 10, "_", STR_PAD_BOTH); // 输出 "__Alien___"
echo str_pad($input, 6 , "___"); // 输出 "Alien_"
?>

str_repeat — 重复一个字符串

返回 input 重复 multiplier 次后的结果。参数：

input

待操作的字符串。

multiplier

input 被重复的次数。

multiplier 必须大于等于 0。如果 multiplier 被设置为 0，函数返回空字符串。

返回值：返回重复后的字符串。

例子：

<?php
echo str_repeat("-=", 10);
?>

以上例程会输出：

-=-=-=-=-=-=-=-=-=-=

str_replace — 子字符串替换

该函数返回一个字符串或者数组。该字符串或数组是将 subject 中全部的 search 都被 replace 替换之后的结果。

如果没有一些特殊的替换需求（比如正则表达式），你应该使用该函数替换 ereg_replace() 和 preg_replace()。

如果 search 和 replace 都是数组，它们的值将会被依次处理。

search 查找的目标值，也就是 needle。一个数组可以指定多个目标。


replace search 的替换值。一个数组可以被用来指定多重替换。

subject 执行替换的数组或者字符串。也就是 haystack。如果 subject 是一个数组，替换操作将遍历整个 subject，返回值也将是一个数组。count如果被指定，它的值将被设置为替换发生的次数。

返回值：该函数返回替换后的数组或者字符串。

例子：

<?php
// 赋值: <body text='black'>
$bodytag = str_replace("%body%", "black", "<body text='%body%'>");
// 赋值: Hll Wrld f PHP
$vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$onlyconsonants = str_replace($vowels, "", "Hello World of PHP");
// 赋值: You should eat pizza, beer, and ice cream every day
$phrase = "You should eat fruits, vegetables, and fiber every day.";
$healthy = array("fruits", "vegetables", "fiber");
$yummy = array("pizza", "beer", "ice cream");
$newphrase = str_replace($healthy, $yummy, $phrase);
// 赋值: 2
$str = str_replace("ll", "", "good golly miss molly!", $count);
echo $count;
?>

可能的 str_replace() 替换范例

<?php
// 替换顺序
$str = "Line 1\nLine 2\rLine 3\r\nLine 4\n";
$order = array("\r\n", "\n", "\r");
$replace = ' ';
// 首先替换 \r\n 字符，因此它们不会被两次转换
$newstr = str_replace($order, $replace, $str);
// 输出 F ，因为 A 被 B 替换，B 又被 C 替换，以此类推...
// 由于从左到右依次替换，最终 E 被 F 替换
$search = array('A', 'B', 'C', 'D', 'E');
$replace = array('B', 'C', 'D', 'E', 'F');
$subject = 'A';
echo str_replace($search, $replace, $subject);
// 输出: apearpearle pear
// 由于上面提到的原因
$letters = array('a', 'p');
$fruit = array('apple', 'pear');
$text = 'a p';
$output = str_replace($letters, $fruit, $text);
echo $output;
?>

Note: 此函数可安全用于二进制对象。

str_rot13 — 对字符串执行 ROT13 转换

对 str 参数执行 ROT13 编码并将结果字符串返回。

ROT13 编码简单地使用字母表中后面第 13 个字母替换当前字母，同时忽略非字母表中的字符。编码和解码都使用相同的函数，传递一个编码过的字符串作为参数，将得到原始字符串。参数：

str

输入字符串。

返回值：返回给定字符串的 ROT13 版本。

例子：

<?php
echo str_rot13('PHP 4.3.0'); // CUC 4.3.0
?>

str_shuffle — 随机打乱一个字符串

str_shuffle() 函数打乱一个字符串，使用任何一种可能的排序方案。参数：

str

输入字符串。

返回值：返回打乱后的字符串。

例子：

<?php
$str = 'abcdef';
$shuffled = str_shuffle($str);
// 输出类似于: bfdaec
echo $shuffled;
?>

str_split — 将字符串转换为数组

将一个字符串转换为数组。参数：

string

输入字符串。

split_length

每一段的长度。

返回值：

如果指定了可选的 split_length 参数，返回数组中的每个元素均为一个长度为 split_length 的字符块，否则每个字符块为单个字符。

如果 split_length 小于 1，返回 FALSE。如果 split_length 参数超过了 string 超过了字符串 string 的长度，整个字符串将作为数组仅有的一个元素返回。

例子：

<?php
$str = "Hello Friend";
$arr1 = str_split($str);
$arr2 = str_split($str, 3);
print_r($arr1);
print_r($arr2);
?>

以上例程会输出：

Array ( [0] => H [1] => e [2] => l [3] => l [4] => o [5] => [6] => F [7] => r [8] => i [9] => e [10] => n [11] => d ) Array ( [0] => Hel [1] => lo [2] => Fri [3] => end )

str_word_count — 返回字符串中单词的使用情况

统计 string 中单词的数量。如果可选的参数 format 没有被指定，那么返回值是一个代表单词数量的整型数。如果指定了 format 参数，返回值将是一个数组，数组的内容则取决于 format 参数。format 的可能值和相应的输出结果如下所列。

对于这个函数的目的来说，单词的定义是一个与区域设置相关的字符串。这个字符串可以包含字母字符，也可以包含 "'" 和 "-" 字符（但不能以这两个字符开始）。参数：

string 字符串。format 指定函数的返回值。当前支持的值如下：

0 - 返回单词数量
1 - 返回一个包含 string 中全部单词的数组
2 - 返回关联数组。数组的键是单词在 string 中出现的数值位置，数组的值是这个单词

charlist 附加的字符串列表，其中的字符将被视为单词的一部分。返回值：返回一个数组或整型数，这取决于 format 参数的选择。例子：<?php
$str = "Hello fri3nd, you're
looking good today!";
print_r(str_word_count($str, 1));
print_r(str_word_count($str, 2));
print_r(str_word_count($str, 1, 'àáãç3'));
echo str_word_count($str);
?>

以上例程会输出：

Array ( [0] => Hello [1] => fri [2] => nd [3] => you're [4] => looking [5] => good [6] => today ) Array ( [0] => Hello [6] => fri [10] => nd [14] => you're [29] => looking [46] => good [51] => today ) Array ( [0] => Hello [1] => fri3nd [2] => you're [3] => looking [4] => good [5] => today ) 7

strcasecmp — 二进制安全比较字符串（不区分大小写）

二进制安全比较字符串（不区分大小写）。参数：

str1

第一个字符串。

str2

第二个字符串。

返回值：如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

例子：

<?php
$var1 = "Hello";
$var2 = "hello";
if (strcasecmp($var1, $var2) == 0) {
echo '$var1 is equal to $var2 in a case-insensitive string comparison';
}
?>

strchr — 别名 strstr

此函数是该函数的别名： strstr().

strcmp — 二进制安全字符串比较

注意该比较区分大小写。参数：

str1

第一个字符串。

str2

第二个字符串。

返回值：如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

例子：

<?php
$var1 = "Hello";
$var2 = "hello";
if (strcmp($var1, $var2) !== 0) {
echo '$var1 is not equal to $var2 in a case sensitive string comparison';
}
?>

strcoll — 基于区域设置的字符串比较

注意该比较区分大小写。和 strcmp() 不同，该函数不是二进制安全的。

strcoll() 使用当前区域设置进行比较。如果当前区域为 C 或 POSIX，该函数等同于 strcmp()。参数：

str1

第一个字符串。

str2

第二个字符串。

返回值：如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

strcspn — 获取不匹配遮罩的起始子字符串的长度

返回 str1 中，所有字符都不存在于 str2 范围的起始子字符串的长度。参数：

str1

第一个字符串。

str2

第二个字符串。

start

查找的起始位置。

length

查找的长度。

返回值：以整型数返回子串的长度。

<?php
$a = strcspn('abcd', 'apple');
$b = strcspn('abcd', 'banana');
$c = strcspn('hello', 'l');
$d = strcspn('hello', 'world');
var_dump($a);
var_dump($b);
var_dump($c);
var_dump($d);
?>

以上例程会输出：

int(0) int(0) int(2) int(2)

strip_tags — 从字符串中去除 HTML 和 PHP 标记

该函数尝试返回给定的字符串 str 去除空字符、HTML 和 PHP 标记后的结果。它使用与函数 fgetss() 一样的机制去除标记。参数：

str

输入字符串。

allowable_tags

使用可选的第二个参数指定不被去除的字符列表。

HTML 注释和 PHP 标签也会被去除。这里是硬编码处理的，所以无法通过 allowable_tags 参数进行改变。

返回值：返回处理后的字符串。

例子：

<?php
$text = 'Test paragraph. <a href="#fragment">Other text</a>';
echo strip_tags($text);
echo "\n";
// 允许 和 <a>
echo strip_tags($text, '<a>');
?>

以上例程会输出：

Test paragraph. Other text

Test paragraph.

Other text

stripcslashes — 反引用一个使用 addcslashes 转义的字符串

返回反转义后的字符串。可识别类似 C 语言的 \n，\r，... 八进制以及十六进制的描述。参数：

str

需要反转义的字符串。

返回值：返回反转义后的字符串。

stripos — 查找字符串首次出现的位置（不区分大小写）

返回在字符串 haystack 中 needle 首次出现的数字位置。与 strpos() 不同，stripos() 不区分大小写。参数：

haystack

在该字符串中查找。

needle

注意 needle 可以是一个单字符或者多字符的字符串。

如果 needle 不是一个字符串，那么它将被转换为整型并被视为字符顺序值。

offset

可选的 offset 参数允许你指定从 haystack 中的哪个字符开始查找。返回的位置数字值仍然相对于haystack 的起始位置。

返回值：

返回 needle 存在于 haystack 字符串开始的位置(独立于偏移量)。同时注意字符串位置起始于 0，而不是 1。

如果未发现 needle 将返回 FALSE。

Warning

例子：

<?php
$findme = 'a';
$mystring1 = 'xyz';
$mystring2 = 'ABC';
$pos1 = stripos($mystring1, $findme);
$pos2 = stripos($mystring2, $findme);
// 'a' 当然不在 'xyz' 中
if ($pos1 === false) {
 echo "The string '$findme' was not found in the string '$mystring1'";
}
// 注意这里使用的是 ===。简单的 == 不能像我们期望的那样工作，
// 因为 'a' 的位置是 0（第一个字符）。
if ($pos2 !== false) {
 echo "We found '$findme' in '$mystring2' at position $pos2";
}
?>

Note: 此函数可安全用于二进制对象。

stripslashes — 反引用一个引用字符串

反引用一个引用字符串。Note:

如果 magic_quotes_sybase 项开启，反斜线将被去除，但是两个反斜线将会被替换成一个。

一个使用范例是使用 PHP 检测 magic_quotes_gpc 配置项的开启情况（在PHP 5.4之前默认是开启的）并且你不需要将数据插入到一个需要转义的位置（例如数据库）。例如，你只是简单地将表单数据直接输出。参数：

str

输入字符串。

返回值：返回一个去除转义反斜线后的字符串（\' 转换为 ' 等等）。双反斜线（\\）被转换为单个反斜线（\）。

例子：

<?php
$str = "Is your name O\'reilly?";
// 输出: Is your name O'reilly?
echo stripslashes($str);
?>

Note:stripslashes() 是非递归的。如果你想要在多维数组中使用该函数，你需要使用递归函数。

对数组使用 stripslashes()

<?php
function stripslashes_deep($value){
 $value = is_array($value) ?
 array_map('stripslashes_deep', $value) :
 stripslashes($value);
 return $value;
}
$array = array("f\\'oo", "b\\'ar", array("fo\\'o", "b\\'ar"));
$array = stripslashes_deep($array);
print_r($array);
?>

以上例程会输出：

Array ( [0] => f'oo [1] => b'ar [2] => Array ( [0] => fo'o [1] => b'ar ) )

stristr — strstr 函数的忽略大小写版本

返回 haystack 字符串从 needle 第一次出现的位置开始到结尾的字符串。参数：

haystack

在该字符串中查找。


needle

如果 needle 不是一个字符串，那么它将被转换为整型并被视为字符顺序值。


before_needle

若为 TRUE，strstr() 将返回 needle 在 haystack 中的位置之前的部分(不包括 needle)。

参数 needle 和 haystack 将以不区分大小写的方式对待。

返回值：返回匹配的子字符串。如果 needle 未找到，返回 FALSE。

例子：

<?php
 $email = 'USER@EXAMPLE.com';
 echo stristr($email, 'e'); // 输出 ER@EXAMPLE.com
 echo stristr($email, 'e', true); // 自 PHP 5.3.0 起，输出 US
?>

测试字符串的存在与否

<?php
 $string = 'Hello World!';
 if(stristr($string, 'earth') === FALSE) {
 echo '"earth" not found in string';
 }
// 输出: "earth" not found in string
?>

使用非字符串 needle

<?php
$string = 'APPLE';
echo stristr($string, 97); // 97 = 小写字母 a
// 输出: APPLE
?>

Note: 此函数可安全用于二进制对象。

strlen — 获取字符串长度

返回给定的字符串 string 的长度。参数：

string

需要计算长度的字符串。

返回值：成功则返回字符串 string 的长度；如果 string 为空，则返回 0。

<?php
$str = 'abcdef';
echo strlen($str); // 6
$str = ' ab cd ';
echo strlen($str); // 7
?>

strnatcasecmp — 使用“自然顺序”算法比较字符串（不区分大小写）

该函数实现了以人类习惯对数字型字符串进行排序的比较算法。除了不区分大小写，该函数的行为与 strnatcmp() 类似。参数：

str1

第一个字符串。

str2

第二个字符串。

返回值：与其他字符串比较函数类似，如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

strnatcmp — 使用自然排序算法比较字符串

该函数实现了以人类习惯对数字型字符串进行排序的比较算法，这就是“自然顺序”。注意该比较区分大小写。参数：str1

第一个字符串。

str2

第二个字符串。

返回值：与其他字符串比较函数类似，如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

例子：

<?php
$arr1 = $arr2 = array("img12.png", "img10.png", "img2.png", "img1.png");
echo "Standard string comparison\n";
usort($arr1, "strcmp");
print_r($arr1);
echo "\nNatural order string comparison\n";
usort($arr2, "strnatcmp");
print_r($arr2);
?>

以上例程会输出：

Standard string comparison Array ( [0] => img1.png [1] => img10.png [2] => img12.png [3] => img2.png ) Natural order string comparison Array ( [0] => img1.png [1] => img2.png [2] => img10.png [3] => img12.png )

strncasecmp — 二进制安全比较字符串开头的若干个字符（不区分大小写）

该函数与 strcasecmp() 类似，不同之处在于你可以指定两个字符串比较时使用的长度（即最大比较长度）。参数：

str1

第一个字符串。

str2

第二个字符串。

len

最大比较长度。

返回值：如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

strncmp — 二进制安全比较字符串开头的若干个字符

该函数与 strcmp() 类似，不同之处在于你可以指定两个字符串比较时使用的长度（即最大比较长度）。

注意该比较区分大小写。参数：

str1

第一个字符串。

str2

第二个字符串。

len

最大比较长度。

返回值：如果 str1 小于 str2 返回 < 0；如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

strpbrk — 在字符串中查找一组字符的任何一个字符

strpbrk() 函数在 haystack 字符串中查找 char_list 中的字符。参数：

haystack

在此字符串中查找 char_list。

char_list

该参数区分大小写。

返回值：返回一个以找到的字符开始的子字符串。如果没有找到，则返回 FALSE。

例子：

<?php
$text = 'This is a Simple text.';
// 输出 "is is a Simple text."，因为 'i' 先被匹配
echo strpbrk($text, 'mi');
// 输出 "Simple text."，因为字符区分大小写
echo strpbrk($text, 'S');
?>

strpos — 查找字符串首次出现的位置

返回 needle 在 haystack 中首次出现的数字位置。参数：

haystack

在该字符串中进行查找。

needle

如果 needle 不是一个字符串，那么它将被转换为整型并被视为字符的顺序值。

offset

如果提供了此参数，搜索会从字符串该字符数的起始位置开始统计。和 strrpos()、 strripos()不一样，这个偏移量不能是负数。

返回值：

返回 needle 存在于 haystack 字符串起始的位置(独立于 offset)。同时注意字符串位置是从0开始，而不是从1开始的。

如果没找到 needle，将返回 FALSE。

Warning

例子：

使用 ===

<?php
$mystring = 'abc';
$findme = 'a';
$pos = strpos($mystring, $findme);
// 注意这里使用的是 ===。简单的 == 不能像我们期待的那样工作，
// 因为 'a' 是第 0 位置上的（第一个）字符。
if ($pos === false) {
 echo "The string '$findme' was not found in the string '$mystring'";
} else {
 echo "The string '$findme' was found in the string '$mystring'";
 echo " and exists at position $pos";
}
?>

使用 !==

<?php
$mystring = 'abc';
$findme = 'a';
$pos = strpos($mystring, $findme);
// 使用 !== 操作符。使用 != 不能像我们期待的那样工作，
// 因为 'a' 的位置是 0。语句 (0 != false) 的结果是 false。
if ($pos !== false) {
 echo "The string '$findme' was found in the string '$mystring'";
 echo " and exists at position $pos";
} else {
 echo "The string '$findme' was not found in the string '$mystring'";
}
?>

使用位置偏移量

<?php
// 忽视位置偏移量之前的字符进行查找
$newstring = 'abcdef abcdef';
$pos = strpos($newstring, 'a', 1); // $pos = 7, 不是 0
?>

Note: 此函数可安全用于二进制对象。

strrchr — 查找指定字符在字符串中的最后一次出现

该函数返回 haystack 字符串中的一部分，这部分以 needle 的最后出现位置开始，直到 haystack 末尾。

参数：

haystack

在该字符串中查找。

needle

如果 needle 包含了不止一个字符，那么仅使用第一个字符。该行为不同于 strstr()。

如果 needle 不是一个字符串，那么将被转化为整型并被视为字符顺序值。

返回值：该函数返回字符串的一部分。如果 needle 未被找到，返回 FALSE。

例子：

<?php
// 获取 $PATH 中不含磁盘符号的目录
$dir = substr(strrchr($PATH, ":"), 1);
// 获取最后一行内容
$text = "Line 1\nLine 2\nLine 3";
$last = substr(strrchr($text, 10), 1 );
?>

Note: 此函数可安全用于二进制对象。

strrev — 反转字符串

返回 string 反转后的字符串。参数：

string

待反转的原始字符串。

返回值：返回反转后的字符串。

例子：

<?php
echo strrev("Hello world!"); // 输出 "!dlrow olleH"
?>

strripos — 计算指定字符串在目标字符串中最后一次出现的位置（不区分大小写）

以不区分大小写的方式查找指定字符串在目标字符串中最后一次出现的位置。与 strrpos() 不同，strripos() 不区分大小写。参数：

haystack

在此字符串中进行查找。

needle

注意 needle 可以是一个单字符或者多字符的字符串。

offset

参数 offset 可以被指定来查找字符串中任意长度的子字符串。

负数偏移量将使得查找从字符串的起始位置开始，到 offset 位置为止。

返回值：

返回 needle 相对于 haystack 字符串的位置(和搜索的方向和偏移量无关)。同时注意字符串的起始位置为 0 而非 1。

如果 needle 未被发现，返回 FALSE。

Warning

<?php
$haystack = 'ababcd';
$needle = 'aB';
$pos = strripos($haystack, $needle);
if ($pos === false) {
 echo "Sorry, we did not find ($needle) in ($haystack)";
} else {
 echo "Congratulations!\n";
 echo "We found the last ($needle) in ($haystack) at position ($pos)";
}
?>

以上例程会输出：

Congratulations! We found the last (aB) in (ababcd) at position (2)

strrpos — 计算指定字符串在目标字符串中最后一次出现的位置

返回字符串 haystack 中 needle 最后一次出现的数字位置。注意 PHP4 中，needle 只能为单个字符。如果 needle 被指定为一个字符串，那么将仅使用第一个字符。参数：

haystack

在此字符串中进行查找。

needle

如果 needle不是一个字符串，它将被转换为整型并被视为字符的顺序值。

offset

或许会查找字符串中任意长度的子字符串。负数值将导致查找在字符串结尾处开始的计数位置处结束。

返回值：

返回 needle 存在的位置。如果没有找到，返回 FALSE。 Also note that string positions start at 0, and not 1.

Returns FALSE if the needle was not found.

Warning

检查字串是否存在

<?php
$pos = strrpos($mystring, "b");
if ($pos === false) { // 注意: 三个等号
// 未发现...
}
?>

使用偏移位置进行查找

<?php
$foo = "0123456789a123456789b123456789c";
var_dump(strrpos($foo, '7', -5)); // 从尾部第 5 个位置开始查找
 // 结果: int(17)
var_dump(strrpos($foo, '7', 20)); // 从第 20 个位置开始查找
 // 结果: int(27)
var_dump(strrpos($foo, '7', 28)); // 结果: bool(false)
?>

strspn — 计算字符串中全部字符都存在于指定字符集合中的第一段子串的长度。

返回 subject 中全部字符仅存在于 mask 中的第一组连续字符(子字符串)的长度。

如果省略了 start 和 length 参数，则检查整个 subject 字符串；如果指定了这两个参数，则效果等同于调用strspn(substr($subject, $start, $length), $mask)（更多信息，参见 substr ）。

代码行：

<?php
$var = strspn("42 is the answer to the 128th question.", "1234567890");
?>

$var 将被指派为 2，因为 '42' 是 subject 中第一段全部字符都存在于 '1234567890' 的连续字符。参数：

subject

待检查的字符串。

mask

检查字符列表。

start

subject 的开始检查位置。

如果 start 被设置并且是非负的，strspn() 将从 subject 的第 start 个位置开始检查。例如，在字符串 'abcdef' 中，第 0 个位置的字符是 'a'，第二个位置的字符是 'c'，等等。

如果 start 被设置并且为负数，strspn() 将从 subject 的尾部倒数第 start 个位置开始检查 subject。

length

subject 中检查的长度。

如果 length 被设置并且为非负数，那么将从起始位置开始，检查 subject 的 length 个长度的字符。

如果 length 被设置并且为负数，那么将从起始位置开始，直到从 subject 尾部开始第 length 个位置，对subject 进行检查。

返回值：返回 str1 中第一段全部字符都存在于 str2 范围的字符串的长度。

<?php
echo strspn("foo", "o", 1, 2); // 打印: 2
?>

Note: 此函数可安全用于二进制对象。

strstr — 查找字符串的首次出现

返回 haystack 字符串从 needle 第一次出现的位置开始到 haystack 结尾的字符串。

Note:该函数区分大小写。如果想要不区分大小写，请使用 stristr()。

Note:如果你仅仅想确定 needle 是否存在于 haystack 中，请使用速度更快、耗费内存更少的 strpos() 函数。参数：

haystack

输入字符串。

needle

如果 needle 不是一个字符串，那么它将被转化为整型并且作为字符的序号来使用。

before_needle

若为 TRUE，strstr() 将返回 needle 在 haystack 中的位置之前的部分。

返回值：返回字符串的一部分或者 FALSE（如果未发现 needle）。

例子：

<?php
$email = 'name@example.com';
$domain = strstr($email, '@');
echo $domain; // 打印 @example.com
$user = strstr($email, '@', true); // 从 PHP 5.3.0 起
echo $user; // 打印 name
?>

strtok — 标记分割字符串

strtok() 将字符串 str 分割为若干子字符串，每个子字符串以 token 中的字符分割。这也就意味着，如果有个字符串是 "This is an example string"，你可以使用空格字符将这句话分割成独立的单词。

注意仅第一次调用 strtok 函数时使用 string 参数。后来每次调用 strtok，都将只使用 token 参数，因为它会记住它在字符串 string 中的位置。如果要重新开始分割一个新的字符串，你需再次使用 string 来调用 strtok 函数，以便完成初始化工作。注意可以在 token 参数中使用多个字符。字符串将被该参数中任何一个字符分割。参数：

str

被分成若干子字符串的原始字符串。

token

分割 str 时使用的分界字符。

返回值：标记后的字符串。

例子：

<?php
$string = "This is\tan example\nstring";
/* 使用制表符和换行符作为分界符 */
$tok = strtok($string, " \n\t");
while ($tok !== false) {
echo "Word=$tok ";
$tok = strtok(" \n\t");
}
?>

旧的 strtok() 运行机制

<?php
$first_token = strtok('/something', '/');
$second_token = strtok('/');
var_dump($first_token, $second_token);
?>

结果：string(9) "something" bool(false)

新的 strtok() 运行机制

<?php
$first_token = strtok('/something', '/');
$second_token = strtok('/');
var_dump($first_token, $second_token);
?>

结果：string(9) "something" bool(false)

strtolower — 将字符串转化为小写

将 string 中所有的字母字符转换为小写并返回。参数：

string

输入字符串。

返回值：返回转换后的小写字符串。

例子：

<?php
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtolower($str);
echo $str; // 打印 mary had a little lamb and she loved it so
?>

Note: 此函数可安全用于二进制对象。

strtoupper — 将字符串转化为大写

将 string 中所有的字母字符转换为大写并返回。参数：

string

输入字符串。

返回值：返回转换后的大写字符串。

<?php
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtoupper($str);
echo $str; // 打印 MARY HAD A LITTLE LAMB AND SHE LOVED IT SO
?>

Note: 此函数可安全用于二进制对象。

strtr — 转换指定字符

该函数返回 str 的一个副本，并将在 from 中指定的字符转换为 to 中相应的字符。比如， $from[$n]中每次的出现都会被替换为 $to[$n]，其中 $n 是两个参数都有效的位移(offset)。

如果 from 与 to 长度不相等，那么多余的字符部分将被忽略。 str 的长度将会和返回的值一样。参数：

str

待转换的字符串。

from

字符串中与将要被转换的目的字符 to 相对应的源字符。

to

字符串中与将要被转换的字符 from 相对应的目的字符。

replace_pairs

参数 replace_pairs 可以用来取代 to 和 from 参数，因为它是以 array('from' => 'to', ...) 格式出现的数组。

返回值：返回转换后的字符串。如果 replace_pairs 中包含一个空字符串（""）键，那么将返回 FALSE。 If the str is not a scalar then it is not typecasted into a string, instead a warning is raised and NULL is returned.

例子：

<?php
$addr = strtr($addr, "äåö", "aao");
?>

使用两个参数的 strtr() 范例

<?php
$trans = array("hello" => "hi", "hi" => "hello");
echo strtr("hi all, I said hello", $trans);
?>

以上例程会输出：

hello all, I said hi

<?php
echo strtr("baab", "ab", "01"),"\n";
$trans = array("ab" => "01");
echo strtr("baab", $trans);
?>

1001 ba01

substr_compare — 二进制安全比较字符串（从偏移位置比较指定长度）

substr_compare() 从偏移位置 offset 开始比较 main_str 与 str，比较长度为 length 个字符。参数：

main_str

待比较的第一个字符串。

str

待比较的第二个字符串。

offset

比较开始的位置。如果为负数，则从字符串结尾处开始算起。

length

比较的长度。默认值为 str 的长度与 main_str 的长度减去位置偏移量 offset 后二者中的较大者。

case_insensitivity

如果 case_insensitivity 为 TRUE，比较将不区分大小写。

返回值：如果 main_str 从偏移位置 offset 起的子字符串小于 str，则返回小于 0 的数；如果大于 str，则返回大于 0 的数；如果二者相等，则返回 0。如果 offset 大于等于 main_str 的长度或 length 被设置为小于 1 的值（ PHP 5.6 之前的版本），substr_compare() 将打印出一条警告信息并且返回 FALSE。

例子：

<?php
echo substr_compare("abcde", "bc", 1, 2); // 0
echo substr_compare("abcde", "de", -2, 2); // 0
echo substr_compare("abcde", "bcg", 1, 2); // 0
echo substr_compare("abcde", "BC", 1, 2, true); // 0
echo substr_compare("abcde", "bc", 1, 3); // 1
echo substr_compare("abcde", "cd", 1, 2); // -1
echo substr_compare("abcde", "abc", 5, 1); // warning
?>

substr_count — 计算字串出现的次数

substr_count() 返回子字符串needle 在字符串 haystack 中出现的次数。注意 needle 区分大小写。

Note:

该函数不会计算重叠字符串。参数：

haystack

在此字符串中进行搜索。

needle

要搜索的字符串。

offset

开始计数的偏移位置。

length

指定偏移位置之后的最大搜索长度。如果偏移量加上这个长度的和大于 haystack 的总长度，则打印警告信息。

返回值：该函数返回整型。

<?php
$text = 'This is a test';
echo strlen($text); // 14
echo substr_count($text, 'is'); // 2
// 字符串被简化为 's is a test'，因此输出 1
echo substr_count($text, 'is', 3);
// 字符串被简化为 's i'，所以输出 0
echo substr_count($text, 'is', 3, 3);
// 因为 5+10 > 14，所以生成警告
echo substr_count($text, 'is', 5, 10);
// 输出 1，因为该函数不计算重叠字符串
$text2 = 'gcdgcdgcd';
echo substr_count($text2, 'gcdgcd');
?>

substr_replace — 替换字符串的子串

substr_replace() 在字符串 string 的副本中将由 start 和可选的 length 参数限定的子字符串使用 replacement进行替换。参数：

string

输入字符串

An array of strings can be provided, in which case the replacements will occur on each string in turn. In this case, the replacement, start and length parameters may be provided either as scalar values to be applied to each input string in turn, or as arrays, in which case the corresponding array element will be used for each input string.

replacement

替换字符串。

start

如果 start 为正数，替换将从 string 的 start 位置开始。

如果 start 为负数，替换将从 string 的倒数第 start 个位置开始。

length

如果设定了这个参数并且为正数，表示 string 中被替换的子字符串的长度。如果设定为负数，它表示待替换的子字符串结尾处距离 string 末端的字符个数。如果没有提供此参数，那么它默认为 strlen( string ) （字符串的长度）。当然，如果 length 为 0，那么这个函数的功能为将 replacement 插入到 string 的 start位置处。

返回值：返回结果字符串。如果 string 是个数组，那么也将返回一个数组。

<?php
$var = 'ABCDEFGH:/MNRPQR/';
echo "Original: $var<hr />\n";
/* 这两个例子使用 “bob” 替换整个 $var。*/
echo substr_replace($var, 'bob', 0) . " \n";
echo substr_replace($var, 'bob', 0, strlen($var)) . " \n";
/* 将 “bob” 插入到 $var 的开头处。*/
echo substr_replace($var, 'bob', 0, 0) . " \n";
/* 下面两个例子使用 “bob” 替换 $var 中的 “MNRPQR”。*/
echo substr_replace($var, 'bob', 10, -1) . " \n";
echo substr_replace($var, 'bob', -7, -1) . " \n";
/* 从 $var 中删除 “MNRPQR”。*/
echo substr_replace($var, '', 10, -1) . " \n";
?>

Using substr_replace() to replace multiple strings at once

<?php
$input = array('A: XXX', 'B: XXX', 'C: XXX');
// A simple case: replace XXX in each string with YYY.
echo implode('; ', substr_replace($input, 'YYY', 3, 3))."\n";
// A more complicated case where each replacement is different.
$replace = array('AAA', 'BBB', 'CCC');
echo implode('; ', substr_replace($input, $replace, 3, 3))."\n";
// Replace a different number of characters each time.
$length = array(1, 2, 3);
echo implode('; ', substr_replace($input, $replace, 3, $length))."\n";
?>

以上例程会输出：

A: YYY; B: YYY; C: YYY A: AAA; B: BBB; C: CCC A: AAAXX; B: BBBX; C: CCC

Note: 此函数可安全用于二进制对象。

substr — 返回字符串的子串

返回字符串 string 由 start 和 length 参数指定的子字符串。参数：

string

输入字符串。

start

如果 start 是非负数，返回的字符串将从 string 的 start 位置开始，从 0 开始计算。例如，在字符串 “abcdef” 中，在位置 0 的字符是 “a”，位置 2 的字符串是 “c” 等等。

如果 start 是负数，返回的字符串将从 string 结尾处向前数第 start 个字符开始。

如果 string 的长度小于或等于 start，将返回 FALSE。

Example #1 使用负数 start

<?php
$rest = substr("abcdef", -1);    // 返回 "f"
$rest = substr("abcdef", -2);    // 返回 "ef"
$rest = substr("abcdef", -3, 1); // 返回 "d"
?>

length

如果提供了正数的 length，返回的字符串将从 start 处开始最多包括 length 个字符（取决于 string 的长度）。

如果提供了负数的 length，那么 string 末尾处的许多字符将会被漏掉（若 start 是负数则从字符串尾部算起）。如果 start 不在这段文本中，那么将返回一个空字符串。

如果提供了值为 0，FALSE 或 NULL 的 length，那么将返回一个空字符串。

如果没有提供 length，返回的子字符串将从 start 位置开始直到字符串结尾。

Example #2 使用负数 length

<?php
$rest = substr("abcdef", 0, -1);  // 返回 "abcde"
$rest = substr("abcdef", 2, -1);  // 返回 "cde"
$rest = substr("abcdef", 4, -4);  // 返回 ""
$rest = substr("abcdef", -3, -1); // 返回 "de"
?>

返回值：返回提取的子字符串，或者在失败时返回 FALSE。

substr() 基本用法

<?php
echo substr('abcdef', 1); // bcdef
echo substr('abcdef', 1, 3); // bcd
echo substr('abcdef', 0, 4); // abcd
echo substr('abcdef', 0, 8); // abcdef
echo substr('abcdef', -1, 1); // f
// 访问字符串中的单个字符
// 也可以使用中括号
$string = 'abcdef';
echo $string[0]; // a
echo $string[3]; // d
echo $string[strlen($string)-1]; // f
?>

substr() casting behaviour

<?php
class apple {
 public function __toString() {
 return "green";
 }
}
echo "1) ".var_export(substr("pear", 0, 2), true).PHP_EOL;
echo "2) ".var_export(substr(54321, 0, 2), true).PHP_EOL;
echo "3) ".var_export(substr(new apple(), 0, 2), true).PHP_EOL;
echo "4) ".var_export(substr(true, 0, 1), true).PHP_EOL;
echo "5) ".var_export(substr(false, 0, 1), true).PHP_EOL;
echo "6) ".var_export(substr("", 0, 1), true).PHP_EOL;
echo "7) ".var_export(substr(1.2e3, 0, 4), true).PHP_EOL;
?>

以上例程会输出：

1) 'pe' 2) '54' 3) 'gr' 4) '1' 5) false 6) false 7) '1200'

trim — 去除字符串首尾处的空白字符（或者其他字符）

此函数返回字符串 str 去除首尾空白字符后的结果。如果不指定第二个参数，trim() 将去除这些字符：

" " (ASCII 32 (0x20))，普通空格符。
"\t" (ASCII 9 (0x09))，制表符。
"\n" (ASCII 10 (0x0A))，换行符。
"\r" (ASCII 13 (0x0D))，回车符。
"\0" (ASCII 0 (0x00))，空字节符。
"\x0B" (ASCII 11 (0x0B))，垂直制表符。参数：

str

待处理的字符串。

charlist

可选参数，过滤字符也可由 charlist 参数指定。一般要列出所有希望过滤的字符，也可以使用 “..” 列出一个字符范围。

返回值：过滤后的字符串。

例子：

<?php
$text = "\t\tThese are a few words :) ... ";
$binary = "\x09Example string\x0A";
$hello = "Hello World";
var_dump($text, $binary, $hello);
print "\n";
$trimmed = trim($text);
var_dump($trimmed);
$trimmed = trim($text, " \t.");
var_dump($trimmed);
$trimmed = trim($hello, "Hdle");
var_dump($trimmed);
// 清除 $binary 首位的 ASCII 控制字符
// （包括 0-31）
$clean = trim($binary, "\x00..\x1F");
var_dump($clean);
?>

以上例程会输出：

string(32) " These are a few words :) ... " string(16) " Example string " string(11) "Hello World" string(28) "These are a few words :) ..." string(24) "These are a few words :)" string(5) "o Wor" string(14) "Example string"

使用 trim() 清理数组值

<?php
function trim_value(&$value) {
$value = trim($value);
}
$fruit = array('apple','banana ', ' cranberry ');
var_dump($fruit);
array_walk($fruit, 'trim_value');
var_dump($fruit);
?>

以上例程会输出：

array(3) { [0]=> string(5) "apple" [1]=> string(7) "banana " [2]=> string(11) " cranberry " } array(3) { [0]=> string(5) "apple" [1]=> string(6) "banana" [2]=> string(9) "cranberry" }

ucfirst — 将字符串的首字母转换为大写

将 str 的首字符（如果首字符是字母）转换为大写字母，并返回这个字符串。参数：

str

输入字符串。

返回值：返回结果字符串。

例子：

<?php
$foo = 'hello world!';
$foo = ucfirst($foo); // Hello world!
$bar = 'HELLO WORLD!';
$bar = ucfirst($bar); // HELLO WORLD!
$bar = ucfirst(strtolower($bar)); // Hello world!
?>

ucwords — 将字符串中每个单词的首字母转换为大写

将 str 中每个单词的首字符（如果首字符是字母）转换为大写字母，并返回这个字符串。这里单词的定义是紧跟在空白字符（空格符、制表符、换行符、回车符、水平线以及竖线）之后的子字符串。参数：

str

输入字符串。

返回值：返回转换后的字符串。

例子：

<?php
$foo = 'hello world!';
$foo = ucwords($foo); // Hello World!
$bar = 'HELLO WORLD!';
$bar = ucwords($bar); // HELLO WORLD!
$bar = ucwords(strtolower($bar)); // Hello World!
?>

Note: 此函数可安全用于二进制对象。

vfprintf — 将格式化字符串写入流

向由 handle 指定的流资源句柄中写入根据 format 格式化后的字符串。作用与 fprintf() 函数类似，但是接收一个数组参数，而不是一系列可变数量的参数。参数：

handleformat

关于 format 的描述，参见 sprintf()。

args返回值：返回输出字符串的长度。

例子：

<?php
if (!($fp = fopen('date.txt', 'w')))
return;
vfprintf($fp, "%04d-%02d-%02d", array($year, $month, $day));
// 将向 date.txt 写入格式化的 ISO 标准日期
?>

vprintf — 输出格式化字符串

根据 format （sprintf() 函数文档中有相关描述）参数指定的格式，在一个格式化字符串中显示多个值。

作用与 printf() 函数类似，但是接收一个数组参数，而不是一系列可变数量的参数。参数：

format

关于 format 的描述，参见 sprintf()。

args返回值：返回输出字符串的长度。

例子：

<?php
vprintf("%04d-%02d-%02d", explode('-', '1988-8-1')); // 1988-08-01
?>

vsprintf — 返回格式化字符串

作用与 sprintf() 函数类似，但是接收一个数组参数，而不是一系列可变数量的参数。参数：

format

关于 format 的描述，参见 sprintf()。

args返回值：根据 format （sprintf() 函数文档中有相关描述）参数指定的格式，在一个字符串中返回一系列值。

例子：

<?php
print vsprintf("%04d-%02d-%02d", explode('-', '1988-8-1')); // 1988-08-01
?>

wordwrap — 打断字符串为指定数量的字串

使用字符串断点将字符串打断为指定数量的字串。参数：

str

输入字符串。

width

列宽度。

break

使用可选的 break 参数打断字符串。

cut

如果 cut 设置为 TRUE，字符串总是在指定的宽度或者之前位置被打断。因此，如果有的单词宽度超过了给定的宽度，它将被分隔开来。

返回值：返回打断后的字符串。

例子：

<?php
$text = "The quick brown fox jumped over the lazy dog.";
$newtext = wordwrap($text, 20, " \n");
echo $newtext;
?>

以上例程会输出：

The quick brown fox
jumped over the lazy
dog.

<?php
$text = "A very long woooooooooooord.";
$newtext = wordwrap($text, 8, "\n", true);
echo "$newtext\n";
?>

以上例程会输出：

A very long wooooooo ooooord.

----------------------------------------------------------------------------------------------------------------------------------

JSON函数：

json_decode — 对 JSON 格式的字符串进行编码

接受一个 JSON 格式的字符串并且把它转换为 PHP 变量。参数：

json

待解码的 json string 格式的字符串。

This function only works with UTF-8 encoded data.

assoc

当该参数为 TRUE 时，将返回 array 而非 object 。

depth User specified recursion depth.options

Bitmask of JSON decode options. Currently only JSON_BIGINT_AS_STRING is supported (default is to cast large integers as floats)

返回值：Returns the value encoded in json in appropriate PHP type. Values true, false and null (case-insensitive) are returned as TRUE, FALSE and NULL respectively. NULL is returned if the json cannot be decoded or if the encoded data is deeper than the recursion limit.

例子：

<?php
$json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
var_dump(json_decode($json));
var_dump(json_decode($json, true));
?>

以上例程会输出：

object(stdClass)#1 (5) { ["a"]=> int(1) ["b"]=> int(2) ["c"]=> int(3) ["d"]=> int(4) ["e"]=> int(5) } array(5) { ["a"]=> int(1) ["b"]=> int(2) ["c"]=> int(3) ["d"]=> int(4) ["e"]=> int(5) }

<?php
$json = '{"foo-bar": 12345}';
$obj = json_decode($json);
print $obj->{'foo-bar'}; // 12345
?>

common mistakes using json_decode()

<?php
// the following strings are valid JavaScript but not valid JSON
// the name and value must be enclosed in double quotes
// single quotes are not valid
$bad_json = "{ 'bar': 'baz' }";
json_decode($bad_json); // null
// the name must be enclosed in double quotes
$bad_json = '{ bar: "baz" }';
json_decode($bad_json); // null
// trailing commas are not allowed
$bad_json = '{ bar: "baz", }';
json_decode($bad_json); // null
?>

json_decode() of large integers

<?php
$json = '12345678901234567890';
var_dump(json_decode($json));
var_dump(json_decode($json, false, 512, JSON_BIGINT_AS_STRING));
?>

以上例程会输出：

float(1.2345678901235E+19)

string(20) "12345678901234567890"

json_encode — 对变量进行 JSON 编码

返回 value 值的 JSON 形式。参数：

value

待编码的 value ，除了resource 类型之外，可以为任何数据类型，

该函数只能接受 UTF-8 编码的数据

options

由以下常量组成的二进制掩码： JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS,JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT,JSON_UNESCAPED_UNICODE.

返回值：编码成功则返回一个以 JSON 形式表示的 string 或者在失败时返回 FALSE 。

例子：

<?php
$arr = array ('a'=>1,'b'=>2,'c'=>3,'d'=>4,'e'=>5);
echo json_encode($arr);
?>

以上例程会输出：

{"a":1,"b":2,"c":3,"d":4,"e":5}

json_encode() 函数中 options 参数的用法

<?php
$a = array('<foo>',"'bar'",'"baz"','&blong&', "\xc3\xa9");
echo "Normal: ", json_encode($a), "\n";
echo "Tags: ", json_encode($a, JSON_HEX_TAG), "\n";
echo "Apos: ", json_encode($a, JSON_HEX_APOS), "\n";
echo "Quot: ", json_encode($a, JSON_HEX_QUOT), "\n";
echo "Amp: ", json_encode($a, JSON_HEX_AMP), "\n";
echo "Unicode: ", json_encode($a, JSON_UNESCAPED_UNICODE), "\n";
echo "All: ", json_encode($a, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP | JSON_UNESCAPED_UNICODE), "\n\n";
$b = array();
echo "Empty array output as array: ", json_encode($b), "\n";
echo "Empty array output as object: ", json_encode($b, JSON_FORCE_OBJECT), "\n\n";
$c = array(array(1,2,3));
echo "Non-associative array output as array: ", json_encode($c), "\n";
echo "Non-associative array output as object: ", json_encode($c, JSON_FORCE_OBJECT), "\n\n";
$d = array('foo' => 'bar', 'baz' => 'long');
echo "Associative array always output as object: ", json_encode($d), "\n";
echo "Associative array always output as object: ", json_encode($d, JSON_FORCE_OBJECT), "\n\n";
?>

结果：

Normal: ["<foo>","'bar'","\"baz\"","&blong&","\u00e9"]

Tags: ["\u003Cfoo\u003E","'bar'","\"baz\"","&blong&","\u00e9"]

Apos: ["<foo>","\u0027bar\u0027","\"baz\"","&blong&","\u00e9"]

Quot: ["<foo>","'bar'","\u0022baz\u0022","&blong&","\u00e9"]

Amp: ["<foo>","'bar'","\"baz\"","\u0026blong\u0026","\u00e9"]

Unicode: ["<foo>","'bar'","\"baz\"","&blong&","é"]

All: ["\u003Cfoo\u003E","\u0027bar\u0027","\u0022baz\u0022","\u0026blong\u0026","é"]

Empty array output as array: []

Empty array output as object: {}

Non-associative array output as array: [[1,2,3]]

Non-associative array output as object: {"0":{"0":1,"1":2,"2":3}}

Associative array always output as object: {"foo":"bar","baz":"long"}

Associative array always output as object: {"foo":"bar","baz":"long"}

json_last_error_msg — Returns the error string of the last json_encode() or json_decode() call

此函数没有参数。

返回值：Returns the error message on success, "No Error" if no error has occurred, 或者在失败时返回 FALSE.

参见：json_last_error() - 返回最后发生的错误

json_last_error — 返回最后发生的错误

如果有，返回 JSON 编码解码时最后发生的错误。参数：

此函数没有参数。

返回值：返回一个整型（integer），这个值会是以下的常量之一：

JSON 错误码
常量	含义	可用性
`JSON_ERROR_NONE`	没有错误发生
`JSON_ERROR_DEPTH`	到达了最大堆栈深度
`JSON_ERROR_STATE_MISMATCH`	无效或异常的 JSON
`JSON_ERROR_CTRL_CHAR`	控制字符错误，可能是编码不对
`JSON_ERROR_SYNTAX`	语法错误
`JSON_ERROR_UTF8`	异常的 UTF-8 字符，也许是因为不正确的编码。	PHP 5.3.3
`JSON_ERROR_RECURSION`	One or more recursive references in the value to be encoded	PHP 5.5.0
`JSON_ERROR_INF_OR_NAN`	One or more `NAN` or `INF` values in the value to be encoded	PHP 5.5.0
`JSON_ERROR_UNSUPPORTED_TYPE`	A value of a type that cannot be encoded was given	PHP 5.5.0

例子：

<?php
// 一个有效的 json 字符串
$json[] = '{"Organization": "PHP Documentation Team"}';
// 一个无效的 json 字符串会导致一个语法错误，在这个例子里我们使用 ' 代替了 " 作为引号
$json[] = "{'Organization': 'PHP Documentation Team'}";
foreach ($json as $string) {
    echo 'Decoding: ' . $string;
    json_decode($string);
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            echo ' - No errors';
        break;
        case JSON_ERROR_DEPTH:
            echo ' - Maximum stack depth exceeded';
        break;
        case JSON_ERROR_STATE_MISMATCH:
            echo ' - Underflow or the modes mismatch';
        break;
        case JSON_ERROR_CTRL_CHAR:
            echo ' - Unexpected control character found';
        break;
        case JSON_ERROR_SYNTAX:
            echo ' - Syntax error, malformed JSON';
        break;
        case JSON_ERROR_UTF8:
            echo ' - Malformed UTF-8 characters, possibly incorrectly encoded';
        break;
        default:
            echo ' - Unknown error';
        break;
    }
    echo PHP_EOL;
}
?>

以上例程会输出：

Decoding: {"Organization": "PHP Documentation Team"} - No errors

Decoding: {'Organization': 'PHP Documentation Team'} - Syntax error, malformed JSON

Example #2 json_encode() 的 json_last_error()

<?php
// 无效的 UTF8 序列
$text = "\xB1\x31";
$json  = json_encode($text);
$error = json_last_error();
var_dump($json, $error === JSON_ERROR_UTF8);
?>

以上例程会输出：

string(4) "null"

bool(true)

----------------------------------------------------------------------------------------------------------------------------------

URL函数：

base64_decode — 对使用 MIME base64 编码的数据进行解码

对 base64 编码的 data 进行解码。参数：

data

编码过的数据。

strict

如果输入的数据超出了 base64 字母表，则返回 FALSE。

返回值：返回原始数据，或者在失败时返回 FALSE。返回的数据可能是二进制的。

<?php
$str = 'VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==';
echo base64_decode($str);
?>

以上例程会输出：

This is an encoded string

base64_encode — 使用 MIME base64 对数据进行编码

使用 base64 对 data 进行编码。设计此种编码是为了使二进制数据可以通过非纯 8-bit 的传输层传输，例如电子邮件的主体。Base64-encoded 数据要比原始数据多占用 33% 左右的空间。参数：

data

要编码的数据。

返回值：编码后的字符串数据，或者在失败时返回 FALSE。

<?php
$str = 'This is an encoded string';
echo base64_encode($str);
?>

以上例程会输出：

VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==

get_headers — 取得服务器响应一个 HTTP 请求所发送的所有标头

get_headers() 返回一个数组，包含有服务器响应一个 HTTP 请求所发送的标头。参数：

url

目标 URL。

format

如果将可选的 format 参数设为 1，则 get_headers() 会解析相应的信息并设定数组的键名。

返回值：返回包含有服务器响应一个 HTTP 请求所发送标头的索引或关联数组，如果失败则返回 FALSE。

<?php
$url = 'http://www.example.com';
print_r(get_headers($url));
print_r(get_headers($url, 1));
?>

以上例程会输出：

Array ( [0] => HTTP/1.0 200 OK [1] => Accept-Ranges: bytes [2] => Cache-Control: max-age=604800 [3] => Content-Type: text/html [4] => Date: Mon, 13 Jul 2015 07:05:11 GMT [5] => Etag: "359670651" [6] => Expires: Mon, 20 Jul 2015 07:05:11 GMT [7] => Last-Modified: Fri, 09 Aug 2013 23:54:35 GMT [8] => Server: ECS (cpm/F9D5) [9] => X-Cache: HIT [10] => x-ec-custom-error: 1 [11] => Content-Length: 1270 [12] => Connection: close ) Array ( [0] => HTTP/1.0 200 OK [Accept-Ranges] => bytes [Cache-Control] => max-age=604800 [Content-Type] => text/html [Date] => Mon, 13 Jul 2015 07:05:11 GMT [Etag] => "359670651" [Expires] => Mon, 20 Jul 2015 07:05:11 GMT [Last-Modified] => Fri, 09 Aug 2013 23:54:35 GMT [Server] => ECS (cpm/F9D5) [X-Cache] => HIT [x-ec-custom-error] => 1 [Content-Length] => 1270 [Connection] => close )

get_headers() using HEAD example

<?php
// By default get_headers uses a GET request to fetch the headers. If you
// want to send a HEAD request instead, you can do so using a stream context:
stream_context_set_default(
 array(
 'http' => array(
 'method' => 'HEAD'
 )
 )
);
$headers = get_headers('http://example.com');
?>

get_meta_tags — 从一个文件中提取所有的 meta 标签 content 属性，返回一个数组

打开 filename 逐行解析文件中的 <meta> 标签。解析工作将在 </head> 处停止。参数：

filename

HTML 文件的路径字符串。此参数可以是本地文件也可以是一个 URL。

Example #1 get_meta_tags() 解析了什么

<meta name="author" content="name">

<meta name="keywords" content="php documentation">

<meta name="DESCRIPTION" content="a php manual">

<meta name="geo.position" content="49.33;-86.59">

</head> <!-- 解析工作在此处停止 -->

（注意回车换行－ PHP 使用一个本地函数来解析输入，所以 Mac 上的文件将不能在 Unix 上正常工作）。use_include_path

将 use_include_path 设置为 TRUE 将使 PHP 尝试按照 include_path 标准包含路径中的每个指向去打开文件。这只用于本地文件，不适用于 URL。

返回值：

返回一个数组，包含所有解析过的 meta 标签。

返回的关联数组以属性 name 的值作为键，属性 content 的值作为值，所以你可以很容易地使用标准数组函数遍历此关联数组或访问某个值。属性 name 中的特殊字符将使用‘_’替换，而其它字符则转换成小写。如果有两个 meta 标签拥有相同的 name，则只返回最后出现的那一个。

例子：

<?php
// 假设上边的标签是在 www.example.com 中
$tags = get_meta_tags('http://www.example.com/');
// 注意所有的键（key）均为小写，而键中的‘.’则转换成了‘_’。
echo $tags['author']; // name
echo $tags['keywords']; // php documentation
echo $tags['description']; // a php manual
echo $tags['geo_position']; // 49.33;-86.59
?>

只有包含 name 属性的 meta 标签才会被解析。

http_build_query — 生成 URL-encode 之后的请求字符串

使用给出的关联（或下标）数组生成一个经过 URL-encode 的请求字符串。参数：

query_data

可以是数组或包含属性的对象。

一个 query_data 数组可以是简单的一维结构，也可以是由数组组成的数组（其依次可以包含其它数组）。

如果 query_data 是一个对象，只有 public 的属性会加入结果。

numeric_prefix

如果在基础数组中使用了数字下标同时给出了该参数，此参数值将会作为基础数组中的数字下标元素的前缀。

这是为了让 PHP 或其它 CGI 程序在稍后对数据进行解码时获取合法的变量名。

arg_separator

除非指定并使用了这个参数，否则会用 arg_separator.output 来分隔参数。

enc_type

默认使用 PHP_QUERY_RFC1738。

如果 enc_type 是 PHP_QUERY_RFC1738，则编码将会以 » RFC 1738 标准和 application/x-www-form-urlencoded 媒体类型进行编码，空格会被编码成加号（+）。

如果 enc_type 是 PHP_QUERY_RFC3986，将根据 » RFC 3986 编码，空格会被百分号编码（%20）。

返回值：返回一个 URL 编码后的字符串。

<?php
$data = array('foo'=>'bar',
 'baz'=>'boom',
 'cow'=>'milk',
 'php'=>'hypertext processor');
echo http_build_query($data) . "\n";
echo http_build_query($data, '', '&');
?>

以上例程会输出：

foo=bar&baz=boom&cow=milk&php=hypertext+processor foo=bar&baz=boom&cow=milk&php=hypertext+processor

http_build_query() 使用数字下标的元素

<?php
$data = array('foo', 'bar', 'baz', 'boom', 'cow' => 'milk', 'php' =>'hypertext processor');
echo http_build_query($data) . "\n";
echo http_build_query($data, 'myvar_');
?>

以上例程会输出：

0=foo&1=bar&2=baz&3=boom&cow=milk&php=hypertext+processor myvar_0=foo&myvar_1=bar&myvar_2=baz&myvar_3=boom&cow=milk&php=hypertext+processor

http_build_query() 使用复杂的数组

<?php
$data = array('user'=>array('name'=>'Bob Smith',
 'age'=>47,
 'sex'=>'M',
 'dob'=>'5/12/1956'),
 'pastimes'=>array('golf', 'opera', 'poker', 'rap'),
 'children'=>array('bobby'=>array('age'=>12,
 'sex'=>'M'),
 'sally'=>array('age'=>8,
 'sex'=>'F')),
 'CEO');l
echo http_build_query($data, 'flags_');
?>

以上例程会输出：

user%5Bname%5D=Bob+Smith&user%5Bage%5D=47&user%5Bsex%5D=M&

user%5Bdob%5D=5%2F12%2F1956&pastimes%5B0%5D=golf&pastimes%5B1%5D=opera&

pastimes%5B2%5D=poker&pastimes%5B3%5D=rap&children%5Bbobby%5D%5Bage%5D=12&

children%5Bbobby%5D%5Bsex%5D=M&children%5Bsally%5D%5Bage%5D=8&

children%5Bsally%5D%5Bsex%5D=F&flags_0=CEO

parse_url — 解析 URL，返回其组成部分

本函数解析一个 URL 并返回一个关联数组，包含在 URL 中出现的各种组成部分。

本函数不是用来验证给定 URL 的合法性的，只是将其分解为下面列出的部分。不完整的 URL 也被接受，parse_url()会尝试尽量正确地将其解析。参数：

url

要解析的 URL。无效字符将使用 _ 来替换。

component

指定 PHP_URL_SCHEME、 PHP_URL_HOST、 PHP_URL_PORT、 PHP_URL_USER、 PHP_URL_PASS、 PHP_URL_PATH、PHP_URL_QUERY 或 PHP_URL_FRAGMENT 的其中一个来获取 URL 中指定的部分的 string。（除了指定为PHP_URL_PORT 后，将返回一个 integer 的值）。

返回值：对严重不合格的 URL，parse_url() 可能会返回 FALSE。

如果省略了 component 参数，将返回一个关联数组 array，在目前至少会有一个元素在该数组中。数组中可能的键有以下几种：

scheme - 如 http
host
port
user
pass
path
query - 在问号 ? 之后
fragment - 在散列符号 # 之后

如果指定了 component 参数， parse_url() 返回一个 string （或在指定为 PHP_URL_PORT 时返回一个 integer）而不是 array。如果 URL 中指定的组成部分不存在，将会返回 NULL。

parse_url() 例子

<?php
$url = 'http://username:password@hostname/path?arg=value#anchor';
print_r(parse_url($url));
echo parse_url($url, PHP_URL_PATH);
?>

以上例程会输出：

Array ( [scheme] => http [host] => hostname [user] => username [pass] => password [path] => /path [query] => arg=value [fragment] => anchor ) /path

parse_url() 解析丢失协议的例子

<?php $url = '//www.example.com/path?googleguy=googley'; // 在 5.4.7 之前这会输出路径 "//www.example.com/path" var_dump(parse_url($url)); ?>

以上例程会输出：

array(2) { ["path"]=> string(22) "//www.example.com/path" ["query"]=> string(17) "googleguy=googley" }

rawurldecode — 对已编码的 URL 字符串进行解码

返回字符串，此字符串中百分号（%）后跟两位十六进制数的序列都将被替换成原义字符。参数：

str

要解码的 URL。

返回值：返回解码后的 URL 字符串。

例子：

<?php
echo rawurldecode('foo%20bar%40baz'); // foo bar@baz
?>

rawurldecode() 不会把加号（'+'）解码为空格，而 urldecode() 可以。

rawurlencode — 按照 RFC 1738 对 URL 进行编码

根据 » RFC 3986 编码指定的字符。参数：

str

要编码的 URL。

返回值：返回字符串，此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）后跟两位十六进制数。这是在» RFC 3986 中描述的编码，是为了保护原义字符以免其被解释为特殊的 URL 定界符，同时保护 URL 格式以免其被传输媒体（像一些邮件系统）使用字符转换时弄乱。

在 FTP URL 里包含一个密码

<?php
echo '<a href="ftp://user:', rawurlencode('foo @+%/'),
'@ftp.example.com/x.txt">';
?>

以上例程会输出：

<a href="ftp://user:foo%20%40%2B%25%2F@ftp.example.com/x.txt">

<?php
echo '<a href="http://example.com/department_list_script/',
rawurlencode('sales and marketing/Miami'), '">';
?>

<a href="http://example.com/department_list_script/sales%20and%20marketing%2FMiami">

urldecode — 解码已编码的 URL 字符串

解码给出的已编码字符串中的任何 %##。加号（'+'）被解码成一个空格字符。参数：

str

要解码的字符串。

返回值：返回解码后的字符串。

<?php
$query = "my=apples&are=green+and+red";
foreach (explode('&', $query) as $chunk) {
 $param = explode("=", $chunk);
 if ($param) {
 printf("Value for parameter \"%s\" is \"%s\" \n", urldecode($param[0]), urldecode($param[1]));
 }
}
?>

Warning

超全局变量 $_GET 和 $_REQUEST 已经被解码了。对 $_GET 或 $_REQUEST 里的元素使用 urldecode()将会导致不可预计和危险的结果。

urlencode — 编码 URL 字符串

此函数便于将字符串编码并将其用于 URL 的请求部分，同时它还便于将变量传递给下一页。参数：

str

要编码的字符串。

返回值：返回字符串，此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）后跟两位十六进制数，空格则编码为加号（+）。此编码与 WWW 表单 POST 数据的编码方式是一样的，同时与 application/x-www-form-urlencoded 的媒体类型编码方式一样。由于历史原因，此编码在将空格编码为加号（+）方面与 RFC1738 编码（参见rawurlencode()）不同。

urlencode() 例子

<?php
echo '<a href="mycgi?foo=', urlencode($userinput), '">';
?>

urlencode() 与 htmlentities() 例子

<?php
$query_string = 'foo=' . urlencode($foo) . '&bar=' . urlencode($bar);
echo '<a href="mycgi?' . htmlentities($query_string) . '">';
?>

----------------------------------------------------------------------------------------------------------------------------------

PHP函数库（core）的更多相关文章

Web---JSTL(Java标准标签库)-Core核心标签库、I18N国际化、函数库
前面为JSTL中的常用EL函数,后面的为具体演示实例! JSTL简介: JSTL(Java Standard Tag Library) –Java标准标签库. SUN公司制定的一套标准标签库的规范. ...
如何持续集成/交付一个开源.NET函数库到Nuget.org
(此文章同时发表在本人微信公众号"dotNET每日精华文章",欢迎右边二维码来关注.) 题记:这是一个简单的入门向导,涉及到GitHub.AppVeyor和Nuget.org. 最 ...
自定义JSTL标签和函数库
一.自定义JSTL标签 1.编写标签处理类: (1)实现 SimpleTag 接口,通过 setJspContext()方法可以获取到 jspContext 对象,实际上也是 pageContext ...
ABP+AdminLTE+Bootstrap Table权限管理系统第七节--登录逻辑及abp封装的Javascript函数库
经过前几节,我们已经解决数据库,模型,DTO,控制器和注入等问题.那么再来看一下登录逻辑.这里算是前面几节的一个初次试水. 首先我们数据库已经有的相应的数据. 模型和DTO已经建好,所以我们直接在服务 ...
ABP+AdminLTE+Bootstrap Table权限管理系统第七节--登录逻辑及几种abp封装的Javascript函数库
返回总目录:ABP+AdminLTE+Bootstrap Table权限管理系统一期简介经过前几节,我们已经解决数据库,模型,DTO,控制器和注入等问题.那么再来看一下登录逻辑.这 ...
day12（jsp指令&内置对象&动作标签、JavaBean、EL表达式&函数库）
day12 JSP指令 JSP指令概述 JSP指令的格式:<%@指令名 attr1="" attr2="" %>,一般都会把JSP指令放到JSP文件 ...
numpy函数库中一些经常使用函数的记录
##numpy函数库中一些经常使用函数的记录近期才開始接触python,python中为我们提供了大量的库,不太熟悉.因此在<机器学习实战>的学习中,对遇到的一些函数的使用方法进行记录. ...
numpy函数库中一些常用函数的记录
##numpy函数库中一些常用函数的记录最近才开始接触Python,python中为我们提供了大量的库,不太熟悉,因此在<机器学习实战>的学习中,对遇到的一些函数的用法进行记录. (1) ...
composer的autoload来自动加载自己编写的函数库与类库？
1.使用命令composer init生成composer.json文件,并编辑autoload选项内容如下: 其中又包含主要的两个选项: files 和 psr-4. files就是需要compos ...
菜鸟Python学习笔记第一天：关于一些函数库的使用
2017年1月3日星期二大一学习一门新的计算机语言真的很难,有时候连函数拼写出错查错都能查半天,没办法,谁让我英语太渣. 关于计算机语言的学习我想还是从C语言学习开始为好,Python有很多语言的 ...

随机推荐

ubuntu - 14.04，安装JDK1.8（JAVA程序需要的开发、运行环境）
一,如何删除低版本的open JDK? 在ubuntn的软件中心中,如果输入"java",我们会看到open JDK,但是最高版本是1.7,也有1.6版本的,如果我们安装上去,可能 ...
[MOOC程序设计与算法二] 递归二
1.表达式计算输入为四则运算表达式,仅由整数.+.-.* ./ .(.) 组成,没有空格,要求求其值.假设运算符结果都是整数 ."/"结果也是整数表达式也是递归的定义: 表达式 ...
sublime安装插件autoprefixer
安装插件autoprefixer步骤: 1.确保Node.js已经安装,未安装请点击这里>> 2.下载autoprefixer插件 https://github.com/sindres ...
CompressFormat压缩性能
在产品应用场景内有个需求,Bitmap原图压缩保存.但是每次保存一个图片,需要500+ms.原本以为是sd卡写的慢.后来测试发现是图片压缩问题.试验过CompressFormat PNG和JPEG两种 ...
牛客nowcoder NOIP普及组第三场
qtmd AK了直接题解吧题目链接 A-十七边形牛牛想在一个半径为r的圆中,找到一个内接的十七边形,使他的面积最大.输入半径r,输出最大的面积. 1 <= r <= 10000 在1 ...
s5pv210移植Minigui3.0.12
移植平台:ubuntu:14.04 开发板:s5pv210(A8) Minigui版本:3.0.12-------------------------------------------------- ...
ssh 配置无密码登录
下框中在管理机上运行: [root@master ~]# ssh-keygen -t rsa #它在/root/.ssh下生成id_rsa和id_rsa.pub两个文件 [root@master ~] ...
springcloud系列四搭建服务模块重点讲解
首先这个服务地址:一定不要写错,是自己注册中心开启的地址如果注意到这些了,可以简单的进行操作,也可以不需要mybatis与数据库连接,在controller里直接返回相应的数据可以了,不用这么幸苦的 ...
[Groovy]Parse properties file in Groovy
def props = new Properties() new File("foo.properties").withInputStream { s -> props.lo ...
C语言初步学习I/O函数scanf、getchar、printf和putchar
scanf().printf().getchar()和putchar()这四个函数能够让用户和程序交流,所以被称为输入/输出函数,或简称为I/O函数. 这里先结合缓冲输入来讲讲scanf()和getc ...

PHP函数库（core）

PHP函数库（core）的更多相关文章

随机推荐

热门专题