- 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 — 返回数组中指定的一列
input数组中键值为column_key的列， 如果指定了可选参数index_key，那么input数组中的这一列的值将作为返回数组中对应值的键。参数：input 需要取出数组列的多维数组（或结果集）column_key 需要返回值的列，它可以是索引数组的列索引，或者是关联数组的列的键。 也可以是NULL，此时将返回整个数组（配合index_key参数来重置数组键的时候，非常管用）index_key 作为返回数组的索引/键的列，它可以是该列的整数索引，或者字符串键值。返回值：从多维数组中返回单列数组$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 — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
?>
- array_count_values — 统计数组中所有的值出现的次数
input 数组中的值作为键名，该值在 input 数组中出现的次数作为值。参数：input 统计这个数组的值返回值：返回一个关联数组，用 input 数组中的值作为键名，该值在数组中出现的次数作为值。$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
?>
- 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.$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_diff_key — 使用键名比较计算数组的差集
array1 从这个数组进行比较array2 针对此数组进行比较...返回值：array_diff_key() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。$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_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集
对比了 array1 和 array2 并返回不同之处。 注意和 array_diff() 不同的是键名也用于比较。和 array_diff_assoc() 不同的是使用了用户自定义的回调函数，而不是内置的函数。参数：
array1 待比较的数组array2 和这个数组进行比较...key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
返回值：返回一个 array，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。
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_diff_ukey — 用回调函数对键名比较计算数组的差集
array1 中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。本函数和 array_diff() 相同只除了比较是根据键名而不是值来进行的。参数：array1 The array to compare fromarray2 An array to compare against...key_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。返回值：Returns an array containing all the entries from array1 that are not present in any of the other arrays.
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_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填充使用的值。
返回值：返回填充后的数组。
$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
?>
- array_fill — 用给定的值填充数组
value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始。参数：start_index 返回的数组的第一个索引值。如果 start_index 是负数， 那么返回的数组的第一个索引将会是 start_index ，而后面索引则从0开始。 (参见 例子)。
num 插入元素的数量。 必须大于 0。value 用来填充的值。返回值：返回填充后的数组。
$a = array_fill(5, 6, 'banana');
$b = array_fill(-2, 4, 'pear');
print_r($a);
print_r($b);
?>
- array_filter — 用回调函数过滤数组中的单元
input 数组中的每个值传递到 callback 函数。如果 callback 函数返回 TRUE，则 input 数组的当前值会被包含在返回的结果数组中。数组的键名保留不变。参数：input 要循环的数组callback 使用的回调函数如果没有提供 callback 函数， 将删除 input 中所有等值为 FALSE 的条目。
返回值：返回过滤后的数组。
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"));
?>
callback：$entry = array(
0 => 'foo',
1 => false,
2 => -1,
3 => null,
4 => ''
);
print_r(array_filter($entry));
?>
- array_flip — 交换数组中的键和值
array_flip() 返回一个反转后的 array，例如 trans 中的键名变成了值，而 trans 中的值成了键名。
注意 trans 中的值需要能够作为合法的键名，例如需要是 integer 或者 string。如果值的类型不对将发出一个警告，并且有问题的键／值对将不会反转。
如果同一个值出现了多次，则最后一个键名将作为它的值，所有其它的都丢失了。参数：
trans 要交换键/值对的数组。
返回值：成功时返回交换后的数组，如果失败返回 NULL。
$trans = array("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip($trans);
print_r($trans);
?>
- array_intersect_assoc — 带索引检查计算数组的交集
array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。参数：array1 The array with master values to check.array2 An array to compare values against.array要对比的数组变量的列表。
返回值：返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。
$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_intersect_key — 使用键名比较计算数组的交集
array1 中并同时出现在所有其它参数数组中的键名的值。参数：array1The 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.
$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_intersect_uassoc — 带索引检查计算数组的交集，用回调函数比较索引
array1 中也同时出现在所有其它参数数组中的值。注意和 array_intersect() 不同的是键名也用于比较。参数：array1Initial 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.
$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_intersect_ukey — 用回调函数比较键名来计算数组的交集
array1 中并同时出现在所有其它参数数组中的键名的值。参数：array1Initial 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 的整数。
返回值：Returns the values of array1 whose keys exist in all the arguments.
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_intersect — 计算数组的交集
array1 中也同时出现在所有其它参数数组中的值。注意键名保留不变。参数：array1The array with master values to check.
array2
An array to compare values against.
array
A variable list of arrays to compare.
返回值：返回一个数组，该数组包含了所有在 array1 中也同时出现在所有其它参数数组中的值。
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);
?>
- 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 falseisset($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 — 将回调函数作用到给定数组的单元上
arr1 中的所有单元经过 callback 作用过之后的单元。callback 接受的参数数目应该和传递给 array_map() 函数的数组数目一致。参数：callback对每个数组的每个元素作用的回调函数。
arr1
将被回调函数（callback）执行的数组。
array
将被回调函数（callback）执行的数组列表。
返回值：返回一个数组，该数组的每个元素都数组（arr1）里面的每个元素经过回调函数（callback）处理了的。
function cube($n){
return($n * $n * $n);
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>
- array_merge_recursive — 递归地合并一个或多个数组
array_merge_recursive() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。
如果输入的数组中有相同的字符串键名，则这些值会被合并到一个数组中去，这将递归下去，因此如果一个值本身是一个数组，本函数将按照相应的条目把它合并为另一个数组。然而，如果数组具有相同的数组键名，后一个值将不会覆盖原来的值，而是附加到后面。参数：
array1 要合并的初始数组。
...
返回值:一个结果数组，其中的值合并自附加的参数。$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_merge — 合并一个或多个数组
array_merge() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。
如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。
如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。参数：
array1 Initial array to merge.
...
返回值:返回结果数组。$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);
?>
- 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 — 用值将数组填补到指定长度
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 数组的长度则没有任何填补。
$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 数组的最后一个单元，并将数组 array 的长度减一。如果 array 为空（或者不是数组）将返回 NULL。 此外如果被调用不是一个数则会产生一个 Warning。参数：array需要做出栈的数组。
返回值：返回 array 的最后一个值。如果 array 是空（如果不是一个数组），将会返回 NULL 。
$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);
print_r($stack);
?>
- array_product — 计算数组中所有值的乘积
array这个数组。
返回值：以整数或浮点数返回一个数组中所有值的乘积。
$a = array(2, 4, 6, 8);
echo "product(a) = " . array_product($a) . "\n";
echo "product(array()) = " . array_product(array()) . "\n";
?>
- 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 级别的错误。
<?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.
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");
?>这将使 的值为 15， 的值为 1200（= 10*1*2*3*4*5），以及 的值为 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 输入的数组。
返回值：
返回移出的值，如果 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 的整数。
返回值：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 的整数。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_udiff — 用回调函数比较数据来计算数组的差集
array_udiff() 返回一个数组，该数组包括了所有在 array1 中但是不在任何其它参数数组中的值。注意键名保持不变。数据的比较是用 data_compare_func 进行的。如果认为第一个参数小于，等于，或大于第二个参数时必须分别返回一个小于零，等于零，或大于零的整数。这和 array_diff() 不同，后者使用了内部函数来比较数据。参数：
array1第一个数组。array2第二个数组。data_compare_func回调对照函数。在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
返回值：
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 的整数。
返回值：
返回一个数组，该数组包含了所有在 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 的整数。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 的整数。
返回值：
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_flagsThe optional second parametersort_flagsmay 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 numericallySORT_STRING- compare items as stringsSORT_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，将被作为第三个参数传递给 callbackfuncname。
返回值：
成功时返回 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，将被作为第三个参数传递给 callbackfuncname。
返回值：
成功时返回 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() 正好相反。返回将所有变量添加进去后的数组。
任何没有变量名与之对应的字符串都被略过。参数：
varnamecompact() 接受可变的参数数目。每个参数可以是一个包括变量名的字符串或者是一个包含变量名的数组，该数组中还可以包含其它单元内容为变量名的数组， 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。
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。
例子：
<?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);
?>现在包含有如下的键／值对：
Array([1] => bob [value] => bob [0] => 0 [key] => 0
)
<?php
$foo = array("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each($foo);
print_r($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仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。 举个例子，以下情况非常有用：定义一些有效变量，然后从 中仅导入这些已定义的变量。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待搜索的值
haystack
这个数组。
strict
如果第三个参数 strict 的值为 TRUE 则 in_array() 函数还会检查 needle 的类型是否和 haystack 中的相同。
返回值：如果找到 needle 则返回 TRUE，否则返回 FALSE。
$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";
}
?>
$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";
}
?>
- key_exists — 别名 array_key_exists
- key — 从关联数组中取得键名
array该数组。
返回值：key() 函数返回数组中内部指针指向的当前单元的键名。 但它不会移动指针。如果内部指针超过了元素列表尾部，或者数组是空的，key() 会返回 NULL。
$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).'<br />';
}
next($array);
}
?>
fruit4
fruit5
- krsort — 对数组按照键名逆向排序
array输入的数组。
sort_flags
可以用可选参数 sort_flags 改变排序的行为
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
krsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>
- ksort — 对数组按照键名排序
array输入的数组。
sort_flags
可以用可选参数 sort_flags 改变排序的行为
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
$fruits = array("d"=>"lemon", "a"=>"orange", "b"=>"banana", "c"=>"apple");
ksort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>
- list — 把数组中的值赋给一些变量
varname一个变量。
$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。
$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);
?>
- natsort — 用“自然排序”算法对数组排序
array输入的 array。
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
$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);
?>
- next — 将数组中的内部指针向前移动一位
$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 的别名
- prev — 将数组的内部指针倒回一位
arrayThe input array.
返回值：返回数组内部指针指向的前一个单元的值，或当没有更多单元时返回 FALSE。
$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';
?>
- range — 建立一个包含指定范围单元的数组
start序列的第一个值。
limit
序列结束于 limit 的值。
step
如果给出了 step 的值，它将被作为单元之间的步进值。step 应该为正值。如果未指定，step 则默认为 1。
返回值：返回的数组中从 start 到 limit 的单元，包括它们本身。
// 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 — 将数组的内部指针指向第一个单元
array 的内部指针倒回到第一个单元并返回第一个数组单元的值。参数：array输入的数组。
返回值：返回数组第一个单元的值，如果数组为空则返回 FALSE。
$array = array('step one', 'step two', 'step three', 'step four');
// by default, the pointer is on the first element
echo current($array) . "<br />\n"; // "step one"
// skip two steps
next($array);
next($array);
echo current($array) . "<br />\n"; // "step three"
// reset pointer, start again on step one
reset($array);
echo current($array) . "<br />\n"; // "step one"
?>
- rsort — 对数组逆向排序
array输入的数组。
sort_flags
可以用可选参数 sort_flags 改变排序的行为
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
$fruits = array("lemon", "orange", "banana", "apple");
rsort($fruits);
foreach ($fruits as $key => $val) {
echo "$key = $val\n";
}
?>
- shuffle — 将数组打乱
array待操作的数组。
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
$numbers = range(1, 20);
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
?>
- sizeof — 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。$fruits = array("lemon", "orange", "banana", "apple");
sort($fruits);
foreach ($fruits as $key => $val) {
echo "fruits[" . $key . "] = " . $val . "\n";
}
?>
- uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
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);
?>
- uksort — 使用用户自定义的比较函数对数组中的键名进行排序
array输入的数组。
cmp_function
在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
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";
}
?>
- usort — 使用用户自定义的比较函数对数组中的值进行排序
array输入的数组
cmp_function
在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于 0 的整数。
返回值：成功时返回 TRUE， 或者在失败时返回 FALSE。
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";
}
?>
- 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 语言中，上述的所有转换后的字符都是预定义的转义序列。
返回值：返回转义后的字符。
$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 要转义的字符。
返回值：返回转义后的字符。
$str = "Is your name O'reilly?";
// 输出： Is your name O\'reilly?
echo addslashes($str);
?>
- bin2hex — 函数把ASCII字符的字符串转换为十六进制值
str 的十六进制表示。转换使用字节方式，高四位字节优先。参数：str一个字符串。
返回值：返回指定字符串十六进制的表示。
- chop — rtrim 的别名
- chr — 返回指定的字符
返回相对应于 ascii 所指定的单个字符。此函数与 ord() 是互补的。参数：
ascii Ascii 码。返回值：返回规定的字符。$str = "The string ends in escape: ";
$str .= chr(27); /* 在 $str 后边增加换码符 */
/* 通常这样更有用 */
$str = sprintf("The string ends in escape: %c", 27);
?>
- chunk_split — 将字符串分割成小块
body要分割的字符。
chunklen
分割的尺寸。
end
行尾序列符号。
返回值：返回分割后的字符。
// 使用 RFC 2045 语义格式化 $data
$new_string = chunk_split(base64_encode($data));
?>
- convert_cyr_string — 将字符由一种 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 编码的字符串
datauuencode 编码后的数据
返回值：返回解码后的字符串数据， 或者在失败时返回 FALSE.。
/* 你猜会输出啥？:) */
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 - 返回由所有未使用的字节值组成的字符串。
$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";
}
?>
- crc32 — 计算一个字符串的 crc32 多项式
str 的 32 位循环冗余校验码多项式。这通常用于检查传输的数据是否完整。参数：str要校验的数据。
返回值：返回 str crc32 校验的整数。
$checksum = crc32("The quick brown fox jumped over the lazy dog.");
printf("%u\n", $checksum);
?>
- crypt — 单向字符串散列
crypt() 返回一个基于标准 UNIX 算法或系统上其他可用的替代算法的散列字符串。
有些系统支持不止一种散列类型。实际上，有时候，基于 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 字符的字符串，从而保证在失败时与盐值区分开来。$password = crypt('mypassword'); // 自动生成盐值
/* 你应当使用 crypt() 得到的完整结果作为盐值进行密码校验，以此来避免使用不同散列算法导致的问题。（如上所述，基于标准 DES 算法的密码散列使用 2 字符盐值，但是基于 MD5 算法的散列使用 12 个字符盐值。）*/
if (crypt($user_input, $password) == $password) {
echo "Password verified!";
}
?>
// 设置密码
$password = 'mypassword';
// 获取散列值，使用自动盐值
$hash = crypt($password);
?>
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" }
<?php
$str = 'one|two|three|four';
// 正数的 limit
print_r(explode('|', $str, 2));
// 负数的 limit（自 PHP 5.1 起）
print_r(explode('|', $str, -1));
?>
以上例程会输出：
Array ( [0] => one [1] => two|three|four ) Array ( [0] => one [1] => two [2] => three )
- fprintf — 将格式化后的字符串写入到流
format 格式化后的字符串到 由 handle 句柄打开的流中。参数：if (!($fp = fopen('date.txt', 'w'))) {
return;
}
fprintf($fp, "%04d-%02d-%02d", $year, $month, $day);
// will write the formatted ISO date to date.txt
?>
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() 处理后的转换表。
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.
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. |
返回值：将转换表作为一个数组返回。
例子：
<?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)转换为"<br>\n"。
函数将会尝试避免破坏单词。参数：
hebrew_text
逻辑顺序希伯来文字符串。
max_chars_per_line
可选参数，表示每行可返回的最多字符数。
返回值：返回视觉顺序字符串。
- hex2bin — 转换十六进制字符串为二进制字符串
转换十六进制字符串为二进制字符串。
这个函数不是 转换十六进制数字为二进制数字。这种转换可以使用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
$orig = "I'll \"walk\" the <b>dog</b> now";
$a = htmlentities($orig);
$b = html_entity_decode($a);
echo $a; // I'll "walk" the <b>dog</b> now
echo $b; // I'll "walk" the <b>dog</b> now
?>
- htmlentities — Convert all applicable characters to HTML entities
$str = "A 'quote' is <b>bold</b>";
// Outputs: A 'quote' is <b>bold</b>
echo htmlentities($str);
// Outputs: A 'quote' is <b>bold</b>
echo htmlentities($str, ENT_QUOTES);
?>
$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。
ENT_COMPAT | 转换双引号，不转换单引号。 |
ENT_QUOTES | 单引号和双引号都转换。 |
ENT_NOQUOTES | 单引号和双引号都不转换。 |
ENT_HTML401 | 作为HTML 4.01编码处理。 |
ENT_XML1 | 作为XML 1编码处理。 |
ENT_XHTML | 作为XHTML编码处理。 |
ENT_HTML5 | 作为HTML 5编码处理。 |
$str = "<p>this -> "</p>\n";
echo htmlspecialchars_decode($str);
// 注意，这里的引号不会被转换
echo htmlspecialchars_decode($str, ENT_NOQUOTES);
?>
this -> "
this -> "
- htmlspecialchars — Convert special characters to HTML entities
$new = htmlspecialchars("<a href='test'>Test</a>", ENT_QUOTES);
echo $new; // <a href='test'>Test</a>
?>
- implode — 将一个一维数组的值转化为字符串
glue 将一维数组的值连接为一个字符串。参数：glue默认为空的字符串。
pieces
你想要转换的数组。
返回值：返回一个字符串，其内容为由 glue 分割开的数组的值。
$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
- 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。
// 输入拼写错误的单词
$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";
}
?>
- localeconv — Get numeric formatting information
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))，垂直制表符。
$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);
?>
- md5_file — 计算指定文件的 MD5 散列值
filename文件名
raw_output
如果被设置为 TRUE，那么报文摘要将以原始的 16 位二进制格式返回。
返回值：成功返回字符串，否则返回 FALSE。
$file = 'php-5.3.0alpha2-Win32-VC9-x64.zip';
echo 'MD5 file hash of ' . $file . ': ' . md5_file($file);
?>
- md5 — 计算字符串的 MD5 散列值
str原始字符串。
raw_output
如果可选的 raw_output 被设置为 TRUE，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。
返回值：以 32 字符十六进制数字形式返回散列值。
$str = 'apple';
if (md5($str) === '1f3870be274f6c49b3e31a0c6728957f') {
echo "Would you like a green or red apple?";
}
?>
- metaphone — Calculate the metaphone key of a string
FALSE.var_dump(metaphone('programming'));
var_dump(metaphone('programmer'));
?>
var_dump(metaphone('programming', 5));
var_dump(metaphone('programmer', 5));
?>
- money_format — Formats a number as a currency string
$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
- nl2br — 在字符串所有新行之前插入 HTML 换行标记
string 所有新行之前插入 '<br />' 或 '<br>'，并返回。参数：string输入字符串。
is_xhtml
是否使用 XHTML 兼容换行符。
返回值：返回调整后的字符串。
echo nl2br("foo isn't\n bar");
echo nl2br($string);
?>
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.
$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 码值
$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，变量将会以数组元素的形式存入到这个数组，作为替代。
返回值：没有返回值。
$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 格式参数产生输出。参数：- 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。
- 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，可以指定想要删除的字符列表。简单地列出你想要删除的全部字符。使用 .. 格式，可以指定一个范围。
返回值：返回改变后的字符串。
$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);
?>
- 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 散列值
filename要散列的文件的文件名。
raw_output
如果被设置为 TRUE，sha1 摘要将以 20 字符长度的原始格式返回。
返回值：成功返回一个字符串，否则返回 FALSE。
foreach(glob('/home/Kalle/myproject/*.php') as $ent){
if(is_dir($ent)){
continue;
}
echo $ent . ' (SHA1: ' . sha1_file($ent) . ')', PHP_EOL;
}
?>
- sha1 — 计算字符串的 sha1 散列值
str输入字符串。
raw_output
如果可选的 raw_output 参数被设置为 TRUE，那么 sha1 摘要将以 20 字符长度的原始格式返回，否则返回值是一个 40 字符长度的十六进制数字。
返回值：返回 sha1 散列值字符串。
$str = 'apple';
if (sha1($str) === 'd0be2dc421be4fcd0172e5afceea3970e2f3d940') {
echo "Would you like a green or red apple?";
}
?>
- similar_text — 计算两个字符串的相似度
first 第一个字符串。second 第二个字符串。percent 通过引用方式传递第三个参数，similar_text() 将计算相似程度百分数。返回值：返回在两个字符串中匹配字符的数目。- soundex — Calculate the soundex key of a string
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
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 字符串为一个数组
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
searchvalues. An array may be used to designate multiple replacements.
subject
要被搜索和替换的字符串或数组，就像是 haystack。
如果
subject是一个数组，替换操作将遍历整个subject，并且也将返回一个数组。
count
如果设定了，将会设置执行替换的次数。
返回值：返回替换后的字符串或者数组。
$bodytag = str_ireplace("%body%", "black", "<body text=%BODY%>");
?>
- str_pad — 使用另一个字符串填充字符串为指定长度
input 被从左端、右端或者同时两端被填充到制定长度后的结果。如果可选的 pad_string 参数没有被指定，input 将被空格字符填充，否则它将被 pad_string 填充到指定长度。参数：input输入字符串。
pad_length
如果 pad_length 的值是负数，小于或者等于输入字符串的长度，不会发生任何填充。
pad_string
pad_type
可选的 pad_type 参数的可能值为 STR_PAD_RIGHT，STR_PAD_LEFT 或 STR_PAD_BOTH。如果没有指定pad_type，则假定它是 STR_PAD_RIGHT。
返回值：返回填充后的字符串。
$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，函数返回空字符串。
返回值：返回重复后的字符串。
echo str_repeat("-=", 10);
?>
- str_replace — 子字符串替换
该函数返回一个字符串或者数组。该字符串或数组是将 subject 中全部的 search 都被 replace 替换之后的结果。
如果没有一些特殊的替换需求（比如正则表达式），你应该使用该函数替换 ereg_replace() 和 preg_replace()。
如果 search 和 replace 为数组，那么 str_replace() 将对 subject 做二者的映射替换。如果 replace 的值的个数少于 search 的个数，多余的替换将使用空字符串来进行。如果 search 是一个数组而 replace 是一个字符串，那么 search 中每个元素的替换将始终使用这个字符串。该转换不会改变大小写。
如果 search 和 replace 都是数组，它们的值将会被依次处理。
search
replacesearch 的替换值。一个数组可以被用来指定多重替换。
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 = '<br />';
// 首先替换 \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 版本。
echo str_rot13('PHP 4.3.0'); // CUC 4.3.0
?>
- str_shuffle — 随机打乱一个字符串
str输入字符串。
返回值：返回打乱后的字符串。
$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。
$var1 = "Hello";
$var2 = "hello";
if (strcasecmp($var1, $var2) == 0) {
echo '$var1 is equal to $var2 in a case-insensitive string comparison';
}
?>
- strchr — 别名 strstr
- strcmp — 二进制安全字符串比较
str1第一个字符串。
str2
第二个字符串。
返回值：如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
$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
查找的长度。
返回值：以整型数返回子串的长度。
$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输入字符串。
allowable_tags
使用可选的第二个参数指定不被去除的字符列表。
返回值：返回处理后的字符串。
例子：
<?php
$text = '<p>Test paragraph.</p><!-- Comment --> <a href="#fragment">Other text</a>';
echo strip_tags($text);
echo "\n";
// 允许 <p> 和 <a>
echo strip_tags($text, '<p><a>');
?>
以上例程会输出：
Test paragraph. Other text
Test paragraph.
- stripcslashes — 反引用一个使用 addcslashes 转义的字符串
str需要反转义的字符串。
返回值：返回反转义后的字符串。
- stripos — 查找字符串首次出现的位置（不区分大小写）
返回在字符串 haystack 中 needle 首次出现的数字位置。与 strpos() 不同，stripos() 不区分大小写。参数：
haystack
在该字符串中查找。
needle
注意 needle 可以是一个单字符或者多字符的字符串。
如果 needle 不是一个字符串，那么它将被转换为整型并被视为字符顺序值。
offset
可选的 offset 参数允许你指定从 haystack 中的哪个字符开始查找。返回的位置数字值仍然相对于haystack 的起始位置。
返回值：
返回 needle 存在于 haystack 字符串开始的位置(独立于偏移量)。同时注意字符串位置起始于 0，而不是 1。
如果未发现 needle 将返回 FALSE。
例子：
$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";
}
?>
如果 magic_quotes_sybase 项开启，反斜线将被去除，但是两个反斜线将会被替换成一个。
一个使用范例是使用 PHP 检测 magic_quotes_gpc 配置项的 开启情况（在PHP 5.4之 前默认是开启的）并且你不需要将数据插入到一个需要转义的位置（例如数据库）。例如，你只是简单地将表单数据直接输出。参数：
str
输入字符串。
返回值：返回一个去除转义反斜线后的字符串（\' 转换为 ' 等等）。双反斜线（\\）被转换为单个反斜线（\）。
$str = "Is your name O\'reilly?";
// 输出: Is your name O'reilly?
echo stripslashes($str);
?>
Note:stripslashes() 是非递归的。如果你想要在多维数组中使用该函数，你需要使用递归函数。
对数组使用 stripslashes()
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。
$email = '[email protected]';
echo stristr($email, 'e'); // 输出 [email protected]
echo stristr($email, 'e', true); // 自 PHP 5.3.0 起，输出 US
?>
$string = 'Hello World!';
if(stristr($string, 'earth') === FALSE) {
echo '"earth" not found in string';
}
// 输出: "earth" not found in string
?>
$string = 'APPLE';
echo stristr($string, 97); // 97 = 小写字母 a
// 输出: APPLE
?>
- strlen — 获取字符串长度
string 的长度。参数：string需要计算长度的字符串。
返回值：成功则返回字符串 string 的长度；如果 string 为空，则返回 0。
$str = 'abcdef';
echo strlen($str); // 6
$str = ' ab cd ';
echo strlen($str); // 7
?>
- strnatcasecmp — 使用“自然顺序”算法比较字符串（不区分大小写）
str1第一个字符串。
str2
第二个字符串。
返回值：与其他字符串比较函数类似，如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
- strnatcmp — 使用自然排序算法比较字符串
str1第一个字符串。
str2
第二个字符串。
返回值：与其他字符串比较函数类似，如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
$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 — 二进制安全比较字符串开头的若干个字符（不区分大小写）
str1第一个字符串。
str2
第二个字符串。
len
最大比较长度。
返回值：如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
- strncmp — 二进制安全比较字符串开头的若干个字符
该函数与 strcmp() 类似，不同之处在于你可以指定两个字符串比较时使用的长度（即最大比较长度）。
注意该比较区分大小写。参数：
str1
第一个字符串。
str2
第二个字符串。
len
最大比较长度。
返回值：如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
- strpbrk — 在字符串中查找一组字符的任何一个字符
haystack 字符串中查找 char_list 中的字符。参数：haystack在此字符串中查找 char_list。
char_list
该参数区分大小写。
返回值：返回一个以找到的字符开始的子字符串。如果没有找到，则返回 FALSE。
$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。
例子：
$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";
}
?>
$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'";
}
?>
// 忽视位置偏移量之前的字符进行查找
$newstring = 'abcdef abcdef';
$pos = strpos($newstring, 'a', 1); // $pos = 7, 不是 0
?>
- strrchr — 查找指定字符在字符串中的最后一次出现
haystack 字符串中的一部分，这部分以 needle 的最后出现位置开始，直到 haystack 末尾。haystack在该字符串中查找。
needle
如果 needle 包含了不止一个字符，那么仅使用第一个字符。该行为不同于 strstr()。
如果 needle 不是一个字符串，那么将被转化为整型并被视为字符顺序值。
返回值：该函数返回字符串的一部分。如果 needle 未被找到，返回 FALSE。
// 获取 $PATH 中不含磁盘符号的目录
$dir = substr(strrchr($PATH, ":"), 1);
// 获取最后一行内容
$text = "Line 1\nLine 2\nLine 3";
$last = substr(strrchr($text, 10), 1 );
?>
- strrev — 反转字符串
string 反转后的字符串。参数：string待反转的原始字符串。
返回值：返回反转后的字符串。
echo strrev("Hello world!"); // 输出 "!dlrow olleH"
?>
- strripos — 计算指定字符串在目标字符串中最后一次出现的位置（不区分大小写）
haystack在此字符串中进行查找。
needle
注意 needle 可以是一个单字符或者多字符的字符串。
offset
参数 offset 可以被指定来查找字符串中任意长度的子字符串。
负数偏移量将使得查找从字符串的起始位置开始，到 offset 位置为止。
返回值：
返回 needle 相对于 haystack 字符串的位置(和搜索的方向和偏移量无关)。同时注意字符串的起始位置为 0 而非 1。
如果 needle 未被发现，返回 FALSE。
<?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.
检查字串是否存在
$pos = strrpos($mystring, "b");
if ($pos === false) { // 注意: 三个等号
// 未发现...
}
?>
$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");
?> 将被指派为 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 范围的字符串的长度。
echo strspn("foo", "o", 1, 2); // 打印: 2
?>
- strstr — 查找字符串的首次出现
返回 haystack 字符串从 needle 第一次出现的位置开始到 haystack 结尾的字符串。
Note:该函数区分大小写。如果想要不区分大小写，请使用 stristr()。
Note:如果你仅仅想确定 needle 是否存在于 haystack 中，请使用速度更快、耗费内存更少的 strpos() 函数。参数：
haystack输入字符串。
needle
如果 needle 不是一个字符串，那么它将被转化为整型并且作为字符的序号来使用。
before_needle
若为 TRUE，strstr() 将返回 needle 在 haystack 中的位置之前的部分。
返回值：返回字符串的一部分或者 FALSE（如果未发现 needle）。
$email = '[email protected]';
$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 时使用的分界字符。
返回值：标记后的字符串。
$string = "This is\tan example\nstring";
/* 使用制表符和换行符作为分界符 */
$tok = strtok($string, " \n\t");
while ($tok !== false) {
echo "Word=$tok<br />";
$tok = strtok(" \n\t");
}
?>
$first_token = strtok('/something', '/');
$second_token = strtok('/');
var_dump($first_token, $second_token);
?>
$first_token = strtok('/something', '/');
$second_token = strtok('/');
var_dump($first_token, $second_token);
?>
- strtolower — 将字符串转化为小写
string 中所有的字母字符转换为小写并返回。参数：string输入字符串。
返回值：返回转换后的小写字符串。
$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
?>
- strtoupper — 将字符串转化为大写
string 中所有的字母字符转换为大写并返回。参数：string输入字符串。
返回值：返回转换后的大写字符串。
$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
?>
- 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.
$addr = strtr($addr, "äåö", "aao");
?>
$trans = array("hello" => "hi", "hi" => "hello");
echo strtr("hi all, I said hello", $trans);
?>
echo strtr("baab", "ab", "01"),"\n";
$trans = array("ab" => "01");
echo strtr("baab", $trans);
?>
- 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。
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 区分大小写。
haystack
在此字符串中进行搜索。
needle
要搜索的字符串。
offset
开始计数的偏移位置。
length
指定偏移位置之后的最大搜索长度。如果偏移量加上这个长度的和大于 haystack 的总长度，则打印警告信息。
返回值：该函数返回整型。
$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 — 替换字符串的子串
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 是个数组，那么也将返回一个数组。
$var = 'ABCDEFGH:/MNRPQR/';
echo "Original: $var<hr />\n";
/* 这两个例子使用 “bob” 替换整个 $var。*/
echo substr_replace($var, 'bob', 0) . "<br />\n";
echo substr_replace($var, 'bob', 0, strlen($var)) . "<br />\n";
/* 将 “bob” 插入到 $var 的开头处。*/
echo substr_replace($var, 'bob', 0, 0) . "<br />\n";
/* 下面两个例子使用 “bob” 替换 $var 中的 “MNRPQR”。*/
echo substr_replace($var, 'bob', 10, -1) . "<br />\n";
echo substr_replace($var, 'bob', -7, -1) . "<br />\n";
/* 从 $var 中删除 “MNRPQR”。*/
echo substr_replace($var, '', 10, -1) . "<br />\n";
?>
$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";
?>
- 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。
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
?>
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;
?>
- 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 参数指定。一般要列出所有希望过滤的字符，也可以使用 “..” 列出一个字符范围。
返回值：过滤后的字符串。
$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);
?>
function trim_value(&$value) {
$value = trim($value);
}
$fruit = array('apple','banana ', ' cranberry ');
var_dump($fruit);
array_walk($fruit, 'trim_value');
var_dump($fruit);
?>
- ucfirst — 将字符串的首字母转换为大写
str 的首字符（如果首字符是字母）转换为大写字母，并返回这个字符串。参数：str输入字符串。
返回值：返回结果字符串。
$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
输入字符串。
返回值：返回转换后的字符串。
$foo = 'hello world!';
$foo = ucwords($foo); // Hello World!
$bar = 'HELLO WORLD!';
$bar = ucwords($bar); // HELLO WORLD!
$bar = ucwords(strtolower($bar)); // Hello World!
?>
- vfprintf — 将格式化字符串写入流
向由 handle 指定的流资源句柄中写入根据 format 格式化后的字符串。作用与 fprintf() 函数类似，但是接收一个数组参数，而不是一系列可变数量的参数。参数：
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返回值：返回输出字符串的长度。
vprintf("%04d-%02d-%02d", explode('-', '1988-8-1')); // 1988-08-01
?>
- vsprintf — 返回格式化字符串
print vsprintf("%04d-%02d-%02d", explode('-', '1988-8-1')); // 1988-08-01
?>
- wordwrap — 打断字符串为指定数量的字串
str输入字符串。
width
列宽度。
break
使用可选的 break 参数打断字符串。
cut
如果 cut 设置为 TRUE，字符串总是在指定的宽度或者之前位置被打断。因此，如果有的单词宽度超过了给定的宽度，它将被分隔开来。
返回值：返回打断后的字符串。
$text = "The quick brown fox jumped over the lazy dog.";
$newtext = wordwrap($text, 20, "<br />\n");
echo $newtext;
?>
jumped over the lazy
dog.
$text = "A very long woooooooooooord.";
$newtext = wordwrap($text, 8, "\n", true);
echo "$newtext\n";
?>
- json_decode — 对 JSON 格式的字符串进行编码
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.
$json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
var_dump(json_decode($json));
var_dump(json_decode($json, true));
?>
$json = '{"foo-bar": 12345}';
$obj = json_decode($json);
print $obj->{'foo-bar'}; // 12345
?>
// 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 = '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 形式。参数：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 。
$arr = array ('a'=>1,'b'=>2,'c'=>3,'d'=>4,'e'=>5);
echo json_encode($arr);
?>
options 参数的用法$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
FALSE.- json_last_error — 返回最后发生的错误
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)
- base64_decode — 对使用 MIME base64 编码的数据进行解码
data 进行解码。参数：data编码过的数据。
strict
如果输入的数据超出了 base64 字母表，则返回 FALSE。
返回值：返回原始数据， 或者在失败时返回 FALSE。返回的数据可能是二进制的。
$str = 'VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==';
echo base64_decode($str);
?>
- base64_encode — 使用 MIME base64 对数据进行编码
使用 base64 对 data 进行编码。设计此种编码是为了使二进制数据可以通过非纯 8-bit 的传输层传输，例如电子邮件的主体。Base64-encoded 数据要比原始数据多占用 33% 左右的空间。参数：
data
要编码的数据。
返回值：编码后的字符串数据， 或者在失败时返回 FALSE。
$str = 'This is an encoded string';
echo base64_encode($str);
?>
- get_headers — 取得服务器响应一个 HTTP 请求所发送的所有标头
url目标 URL。
format
如果将可选的 format 参数设为 1，则 get_headers() 会解析相应的信息并设定数组的键名。
返回值：返回包含有服务器响应一个 HTTP 请求所发送标头的索引或关联数组，如果失败则返回 FALSE。
$url = 'http://www.example.com';
print_r(get_headers($url));
print_r(get_headers($url, 1));
?>
// 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> 处停止。参数：filenameHTML 文件的路径字符串。 此参数可以是本地文件也可以是一个 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 之后的请求字符串
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 编码后的字符串。
$data = array('foo'=>'bar',
'baz'=>'boom',
'cow'=>'milk',
'php'=>'hypertext processor');
echo http_build_query($data) . "\n";
echo http_build_query($data, '', '&');
?>
$data = array('foo', 'bar', 'baz', 'boom', 'cow' => 'milk', 'php' =>'hypertext processor');
echo http_build_query($data) . "\n";
echo http_build_query($data, 'myvar_');
?>
$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，在目前至少会有一个元素在该数组中。数组中可能的键有以下几种：
- - 如 http
- - 在问号 ? 之后
- - 在散列符号 # 之后
如果指定了 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));
?>- rawurldecode — 对已编码的 URL 字符串进行解码
str要解码的 URL。
返回值：返回解码后的 URL 字符串。
echo rawurldecode('foo%20bar%40baz'); // foo bar@baz
?>
- rawurlencode — 按照 RFC 1738 对 URL 进行编码
str要编码的 URL。
返回值：返回字符串，此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）后跟两位十六进制数。这是在» RFC 3986 中描述的编码，是为了保护原义字符以免其被解释为特殊的 URL 定界符，同时保护 URL 格式以免其被传输媒体（像一些邮件系统）使用字符转换时弄乱。
echo '<a href="ftp://user:', rawurlencode('foo @+%/'),
'@ftp.example.com/x.txt">';
?>
<a href="ftp://user:foo%20%40%2B%25%[email protected]/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要解码的字符串。
返回值：返回解码后的字符串。
$query = "my=apples&are=green+and+red";
foreach (explode('&', $query) as $chunk) {
$param = explode("=", $chunk);
if ($param) {
printf("Value for parameter \"%s\" is \"%s\"<br/>\n", urldecode($param[0]), urldecode($param[1]));
}
}
?>
超全局变量 和 已经被解码了。对 或 里的元素使用 urldecode()将会导致不可预计和危险的结果。
- urlencode — 编码 URL 字符串
str要编码的字符串。
返回值：返回字符串，此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）后跟两位十六进制数，空格则编码为加号（+）。此编码与 WWW 表单 POST 数据的编码方式是一样的，同时与 application/x-www-form-urlencoded 的媒体类型编码方式一样。由于历史原因，此编码在将空格编码为加号（+）方面与 RFC1738 编码（参见rawurlencode()）不同。
echo '<a href="mycgi?foo=', urlencode($userinput), '">';
?>
$query_string = 'foo=' . urlencode($foo) . '&bar=' . urlencode($bar);
echo '<a href="mycgi?' . htmlentities($query_string) . '">';
?>