# 数组部分 #
1. ## array_chunk($arr, $size [, $preserve_key = false]) ##
将一个数组分割成多个
$arr: 需要操作的数组
$size: 每个数组的单元数目
$preserve_keys: 设为true，可以保留原来的键名，设为false,每个结果数组从零开始索引
return 多维数组，从0开始索引，每一维包含了size个元素
eg:
$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
)
)
2. ## array_column($arr, $column_key [, $index_key]) ##
返回$arr中键值为$column_key的列
$arr: 需要操作的数组,如果是对象数组，只有public属性可以取出，如果要取出private或protected,类必须实现__get()和__isset()魔术方法
$column_key: 需要返回值的列，可以是索引或关联的键值，也可以是属性值。如是null,返回整个数组，配合index_key可重置数组键
$index_key: 做为返回数组的索引或键名
return 从多维数组返回单列数组
eg:
从数组中取出first_name列
$records = array(
array(
'id' => 2135,
'first_name' => 'John',
'last_name' => 'Doe',
),
array(
'id' => 3245,
'first_name' => 'Sally',
'last_name' => 'Smith',
),
array(
'id' => 5342,
'first_name' => 'Jane',
'last_name' => 'Jones',
),
array(
'id' => 5623,
'first_name' => 'Peter',
'last_name' => 'Doe',
)
);
$first_names = array_column($records, 'first_name');
print_r($first_names);
Array
(
[0] => John
[1] => Sally
[2] => Jane
[3] => Peter
)
`
从数组中取出last_name列，用相应的id做为键值
`
$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);
?>
Array
(
[2135] => Doe
[3245] => Smith
[5342] => Jones
[5623] => Doe
)
3. ## array_count_values($arr) ##
统计数组中所有的值
$arr
return 一个数组，键是$arr中的值，值是$arr中值出现的次数
eg:
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
?>
输出结果：
Array
(
[1] => 2
[hello] => 2
[world] => 1
)
4. ## array_diff_assoc($arr1, $arr2 [,$arr3 ...]) ##
抽取出两个数组中$arr1独有的元素（键名键值都比较）
$arr1 从这个数组进行比较
$arr2 被比较的数组
return 数组
eg:
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Array
(
[b] => brown
[c] => blue
[0] => red
)
上面的例子中可以看到键值对 "a" => "green" 在两个数组中都有，因此不在本函数的输出中。与此不同，键值对 0 => "red" 出现在输出中是因为第二个参数中的 "red" 的键名是 1。
$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
Array
(
[0] => 0
[1] => 1
)
键值对 key => value 中的两个值仅在 (string) $elem1 === (string) $elem2 时被认为相等。也就是说使用了严格检查，字符串的表达必须相同。
5. ## array_diff_key( $arr1, $arr2 [,$arr3 ... ] ) ##
根据$arr1的键名和$arr2进行比较，返回只存在$arr1中的元素
$arr1 从这个数组进行比较
$arr2 针对此数组进行比较
return 根据比较键名返回只存在$arr1中的元素
note 只能比较一维
eg:
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_key($array1, $array2));
?>
array(2)
{
["red"]=>
int(2)
["purple"]=>
int(4)
}
6. ## array_diff($arr1, $arr2 [,$arr3 ... ]) ##
对比$arr1和其他数组，返回$arr1独有的元素，只比较值
$arr1 要被比对的数组
$arr2 和这个数组进行比较
return 返回数组，其中是$arr1中独有的元素
note
- 返回的数组中键名保持不变
- 两个单元仅在 (string) $elem1 === (string) $elem2 时被认为是相同的
- 本函数只检查了多维数组的一维
eg:
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);
print_r($result);
?>
Array
(
[1] => blue
)
7. ## array_fill_keys( $keys, $value ) ##
使用指定的键和值填充数组
$keys 键名数组
$value 填充数组的键值
return 数组
eg:
$keys = array('foo', 5, 10, 'bar');
$a = array_fill_keys($keys, 'banana');
print_r($a);
?>
Array
(
[foo] => banana
[5] => banana
[10] => banana
[bar] => banana
)
8. ## array_fill( $start_index, $num, $value ) ##
用$value的值将一个数组填充$num个条目，键名由$start_index指定的开始
eg:
$a = array_fill(5, 6, 'banana');
$b = array_fill(-2, 4, 'pear');
print_r($a);
print_r($b);
?>
Array
(
[5] => banana
[6] => banana
[7] => banana
[8] => banana
[9] => banana
[10] => banana
)
Array
(
[-2] => pear
[0] => pear
[1] => pear
[2] => pear
)
8. ## array_filter($arr [, $callback [, $flag = 0]]) ##
依次将$arr中的每个值传递到$callback函数中。如果$callback返回true,则$array中的当前值会被包含在返回的结果数组中，该值对应的键名保持不变。
$arr 要循环的数组
$callback 使用的回调函数。如果没提供回调函数，则将删除$arr中所有等值为false的条目
$flag 决定$callback接收的参数的形式
0 默认接受键值做为唯一的参数
ARRAY_FILTER_USE_KEY $callback接受键名做为唯一的参数
ARRAY_FILTER_USE_BOTH $callback同时接受键名和键值
eg:
example 1:
function odd($var)
{
// 判断是否为奇数
return($var & 1);
}
function even($var)
{
// 判断是否为偶数
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 "奇数 :\n";
print_r(array_filter($array1, "odd"));
echo "偶数:\n";
print_r(array_filter($array2, "even"));
?>
奇数 :
Array
(
[a] => 1
[c] => 3
[e] => 5
)
偶数 :
Array
(
[0] => 6
[2] => 8
[4] => 10
[6] => 12
)
exemple 2:
$entry = array
(
0 => 'foo',
1 => false,
2 => -1,
3 => null,
4 => ''
);
print_r(array_filter($entry));
?>
Array
(
[0] => foo
[2] => -1
)
example 3:
$arr = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
var_dump(array_filter($arr, function($k) {
return $k == 'b';
}, ARRAY_FILTER_USE_KEY));
//注意： 先$v 后$k
var_dump(array_filter($arr, function($v, $k) {
return $k == 'b' || $v == 4;
}, ARRAY_FILTER_USE_BOTH));
?>
array(1){
["b"]=>
int(2)
}
array(2) {
["b"]=>
int(2)
["d"]=>
int(4)
}
10. ## array_flip($arr) ##
返回反转后的$arr,即$arr中的键名变成了键值，而$arr中的键值变成了键名
note：
- $arr中的值需要能够做为合法的键名（例如是integer或者string）,如果类型不对，会发出警告，并且有问题的键名/键值不会出现在结果中
- 如果$arr中一个值出现多次，则最后一个键将做为输出数组中对应的值，其他键将会被丢弃
eg:
example 1:
$input = array("oranges", "apples", "pears");
$flipped = array_flip($input);
print_r($flipped);
?>
Array
(
[oranges] => 0
[apples] => 1
[pears] => 2
)
example 2:
$input = array("a" => 1, "b" => 1, "c" => 2);
$flipped = array_flip($input);
print_r($flipped);
?>
Array
(
[1] => b
[2] => c
)
11. ## array_intersect_key( $arr1, $arr2 [ ,$arr3 ... ] ) ##
返回一个数组，包含了$arr1中所有与其他数组中的键名相同的键值对
note
- 在 key => value 对中的两个键名仅在 (string) $key1 === (string) $key2 时被认为相等。换句话说，执行的是严格类型检查，因此字符串的表达必须完全一样。
eg:
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_intersect_key($array1, $array2));
?>
array(2)
{
["blue"]=>
int(1)
["green"]=>
int(3)
}
上例中可以看到只有 'blue' 和 'green' 两个键名出现在两个数组中，因此被返回。此外注意 'blue' 和 'green' 的值在两个数组中是不同的。但因为只检查键名，因此还是匹配。返回的值只是 array1 中的。
12. ## array_intersect($arr1, $arr2 [, $arr3 ... ]) ##
返回一个数组，包含了所有在$arr1中出现且在其他参数数组也出现了的数组的值，键名保持不变
note:
- 两个单元仅在 (string) $elem1 === (string) $elem2 时被认为是相同的.
eg:
$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);
?>
Array
(
[a] => green
[0] => red
)
13. ## array_key_exists($key, $arr) ##
数组里含有键$key时，返回true。$key可以时任何能做为数组索引的值。
note:
- 仅仅搜索第一维，多维数组里嵌套的键不会被搜索到
eg:
$search_array = array('first' => 1, 'second' => 4);
if (array_key_exists('first', $search_array)) {
echo "The 'first' element is in the array";
}
?>
14. ## array_keys( $arr [, $search_value=null [, $strict = false]] ) ##
返回数组中部分的或所有的键名
$search_value 如果指定了这个参数，只有包含这些值的键才会返回
$strict 判断在搜索的时候是否该使用严格的比较（===）
eg:
$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
)
15. ## array_map( $callback, $arr1 [, $arr2 ... ] ) ##
循环数组，为数组的每个元素应用回调函数
note:
- callback函数形参的数量必须和传给array_map()传入数组的数量一致
eg:
example 1:
function cube($n)
{
return($n * $n * $n);
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>
Array
(
[0] => 1
[1] => 8
[2] => 27
[3] => 64
[4] => 125
)
example 2: 使用匿名函数
$func = function($value) {
return $value * 2;
};
print_r(array_map($func, range(1, 5)));
?>
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
example 3:
function show_Spanish($n, $m)
{
//PHP会在双引号中的字符串中寻找变量进行替换
return("The number $n is called $m in Spanish");
}
function map_Spanish($n, $m)
{
return(array($n => $m));
}
$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$c = array_map("show_Spanish", $a, $b);
print_r($c);
$d = array_map("map_Spanish", $a , $b);
print_r($d);
?>
Array
(
[0] => The number 1 is called uno in Spanish
[1] => The number 2 is called dos in Spanish
[2] => The number 3 is called tres in Spanish
[3] => The number 4 is called cuatro in Spanish
[4] => The number 5 is called cinco in Spanish
)
Array
(
[0] => Array
(
[1] => uno
)
[1] => Array
(
[2] => dos
)
[2] => Array
(
[3] => tres
)
[3] => Array
(
[4] => cuatro
)
[4] => Array
(
[5] => cinco
)
)
- 传入两个及以上的数组时，它们元素数量将会相同。
- 因为回调函数会并行地处理相互对应的元素。
- 如果几个数组的元素数量不一致：空元素会扩展短那个数组，直到长度和最长的数组一样。
example 4:多维数组
$a = array(1, 2, 3, 4, 5);
$b = array("one", "two", "three", "four", "five");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>
Array
(
[0] => Array
(
[0] => 1
[1] => one
[2] => uno
)
[1] => Array
(
[0] => 2
[1] => two
[2] => dos
)
[2] => Array
(
[0] => 3
[1] => three
[2] => tres
)
[3] => Array
(
[0] => 4
[1] => four
[2] => cuatro
)
[4] => Array
(
[0] => 5
[1] => five
[2] => cinco
)
)
16. ## array_merge_recursive( $arr1 [, $arr2 ... ] ) ##
将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。
如果输入的数组中有相同的字符串键名，则这些值会被合并到一个数组中去，并且如果其子元素中还有相同的字符串键名，则递归其子元素。
如果输入的数组中有相同的数字键名，后一个值不会覆盖原来的值，而是附加到后面。
eg:
$ar1 = array("color" => array("favorite" => "red"), 5);
$ar2 = array(10, "color" => array("favorite" => "green", "blue"));
$result = array_merge_recursive($ar1, $ar2);
print_r($result);
?>
Array
(
[color] => Array
(
[favorite] => Array
(
[0] => red
[1] => green
)
[0] => blue
)
[0] => 5
[1] => 10
)
17. ## array_merge($arr1 [, $arr2 ... ]) ##
合并一个或多个数组
将一个或多个数组的单元合并起来，一个数组的值附加在前一个数组的后面。
如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。
数组中包含的数字键名，后面的值将不会覆盖原来的值，而是重编索引附加到后面
如果只给了一个数组并且该数组时数字索引的，则键名会以连续方式重新索引。
eg:
example 1:
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);
?>
Array
(
[color] => green
[0] => 2
[1] => 4
[2] => a
[3] => b
[shape] => trapezoid
[4] => 4
)
example 2:
$array1 = array();
$array2 = array(1 => "data");
$result = array_merge($array1, $array2);
?>
- 别忘了数字键名将会被重新编号！
Array
(
[0] => data
)
example 3:
- 如果你想完全保留原有数组并只想新的数组附加到后面，用 + 运算符：
$array1 = array(0 => 'zero_a', 2 => 'two_a', 3 => 'three_a');
$array2 = array(1 => 'one_b', 3 => 'three_b', 4 => 'four_b');
$result = $array1 + $array2;
var_dump($result);
?>
- 第一个数组的键名将会被保留。
- 在两个数组中存在相同的键名时，第一个数组中的同键名
- 的元素将会被保留，第二个数组中的元素将会被忽略
array(5) {
[0]=>
string(6) "zero_a"
[2]=>
string(5) "two_a"
[3]=>
string(7) "three_a"
[1]=>
string(5) "one_b"
[4]=>
string(6) "four_b"
}
18. ## array_pad($arr1, $size, $value) ##
返回一个$arr1的拷贝，并用$value将其填补到$size指定的长度。
如果$size为正，则填补到数组的右侧，如果为负则从左侧开始填补。
如果$size的绝对值小于或者等于$arr1的长度则没有任何填补。
eg:
$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
?>
19. ## array_replace_recursive( $arr1, $arr2 [, $arr3] ) ##
使用传递的数组递归替换第一个数组的元素
note:
- 使用后面数组元素的值替换数组$arr1的值。
如果一个键存在于第一个数组同时也存在与第二个数组，它的值将被第二个数组中的值替换。
如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。
如果一个键仅存在于第一个数组，它将保持不变。
如果传递了多个替换数组，它们将被按照顺序依次处理，后面的数组将覆盖前面的数组。
- 该方法时递归的，它将遍历数组并将相同的处理应用到数组的内部值。
- 如果数组$arr1中的值时标量，它的值将被$arr2中的值替换，这时它可能时一个标量或一个数组。
如果$arr1和$arr2中的值都是数组，该函数将会递归地替换它们各自的值。
eg:
$base = array('citrus' => array("orange") , 'berries' => array("blackberry", "raspberry"), 'others' => 'banana' );
$replacements = array('citrus' => 'pineapple', 'berries' => array('blueberry'), 'others' => array('litchis'));
$replacements2 = array('citrus' => array('pineapple'), 'berries' => array('blueberry'), 'others' => 'litchis');
$basket = array_replace_recursive($base, $replacements, $replacements2);
print_r($basket);
?>
Array
(
[citrus] => Array
(
[0] => pineapple
)
[berries] => Array
(
[0] => blueberry
[1] => raspberry
)
[others] => litchis
)
20. ## array_replace( $arr1, $arr2 [, $arr3 ... ] ) ##
使用传递的数组替换第一个数组的元素
- 使用后面数组元素相同的key的值替换$arr1中的值。
如果一个键存在于第一个数组同时也存在于第二个数组，它的值将被第二个数组中的值替换。
如果一个键存在于第二个数组，但是不存在于第一个数组，则会在第一个数组中创建这个元素。
如果一个键仅存在于第一个数组，则保持不变。
如果传递了多个替换数组，它们将被按顺序依次处理，后面的数组将覆盖之前的值。
- 该函数时非递归的，它将第一个数组的值进行替换而不管第二个数组中是什么类型。
eg:
$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
)
21. ## array_search( $value, $arr [, $strict = false] ) ##
在数组中搜索给定的值，如果成功则返回首个相应的键名，否则返回false。
如果$strict为true，则将检查完全相同的元素，即检查类型、数值，并且对象必须是同一个实例。
eg:
$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');
$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array); // $key = 1;
?>
22. ## array_slice($arr1, $offset [, $length [, $preserve_keys]]) ##
根据$offset和$length返回$arr1中的一段序列
$offset
- $offset为正，则序列从$arr1中的此偏移量开始
- $offset为负，则序列从$arr1中距离末端这么远的地方开始
$length
- $length为正，则序列中将有这么多的单元。
- $length为负，则序列终止在距离数组末端这么远的地方
- $length省略，则序列将从offset开始一直到array的末端
$preserve_keys
- false时，会重新排序并重置数组的数字索引
- true时，不会重新排序，不重置数组的数字索引
eg:
$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"
print_r(array_slice($input, 2, -1)); //Array([0] => c,[1] => d)
print_r(array_slice($input, 2, -1, true)); //Array([2] => c,[3] => d)
?>
23. ## array_udiff( $arr1, $arr2 [, $arr3 ...],$value_compare_func ) ##
使用回调函数比较数据，计算数组的不同之处。
value_compare_func 在第一个参数小于，等于或大于第二个参数时，该比较函数必须相应地返回一个小于，等于或大于0的整数。
该回调函数只是比较了传入的各个数组中的对应的值的大小，以此来比较。
return $arr1里没有出现在其他参数里的所有值
eg:
$array1 = array('absdf','fdsfsdf','33252');
$array2 = array('asdfsdff','absdf','3dsfs');
function compare_by_area($a, $b) {
if ($a < $b) {
return -1;
} elseif ($a > $b) {
return 1;
} else {
return 0;
}
}
print_r(array_udiff($array1, $array2, 'compare_by_area'));
?>
Array
(
[1] => fdsfsdf
[2] => 33252
)
24. ## array_unique( $arr1 [, $sort_flags = SORT_STRING] ) ##
接受$arr1做为输入并返回没有重复值的新数组，键名不变。
eg:
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>
Array
(
[a] => green
[0] => red
[1] => blue
)
25. ## array_values($arr) ##
返回$arr中所有的值并给其建立数字索引
eg:
$array = array("size" => "XL", "color" => "gold");
print_r(array_values($array));
?>
Array
(
[0] => XL
[1] => gold
)
27. ## array_walk_recursive( $arr, $callback [, $userdata = NULL] ) ##
将用户自定义函数$callback应用到$arr数组中的每个单元。本函数会递归到更深层的数组中去
$callback 典型情况下$callback会接受两个参数，$arr的值做为第一个，键名做为第二个
$userdata 如果提供了userdata,将被做为第三个参数传递给$callback
note:
- 如果$callback需要直接作用于数组中的值，则给$callback的第一个参数指定为引用，这样任何对这些单元的改变也会改变原始数组本身。
eg:
$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
note:
- 注意上例中的键'sweet'并没有显示出来。任何其值为array的键都不会被传递到回调函数中去
26. ## array_walk( $arr, $callback [, $userdata ] ) ##
将用户自定义函数$callback应用到数组中的每个单元
array_walk()不会受到$arr内部数组指针的影响。
array_walk()会遍历整个数组而不管指针的位置。
eg:
$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
\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
28. ## count( $arr [, $mode ] ) ##
统计出数组里所有元素的数量，或者对象里的东西
$mode 如果可选的$mode参数设为COUNT_RECURSIVE(或1),count()将递归地对数组计数，对计算多维数组的所有单元尤其有用。
29. ## in_array( $value, $arr [, $strict ... ] ) ##
检查数组中是否存在某个值
$strict 该值为true则in_array()会检查$value的类型是否和$arr中的相同
30. ## list( $var1 [, $var2 ... ] ) ##
像array()一样，这不是真正的函数，而是语言构造。
list()可以在单次操作就为一组变量赋值。
note:
- 仅能用于数字索引的数组，并假定数字索引从0开始
eg:
example 1:
$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
?>
example 2:
list($a, list($b, $c)) = array(1, array(2, 3));
var_dump($a, $b, $c);
?>
int(1)
int(2)
int(3)
example 3:
$info = array('coffee', 'brown', 'caffeine');
list($a[0], $a[1], $a[2]) = $info;
var_dump($a);
?>
PHP 7:
array(3) {
[0]=>
string(6) "coffee"
[1]=>
string(5) "brown"
[2]=>
string(8) "caffeine"
}
PHP 5:
array(3) {
[2]=>
string(8) "caffeine"
[1]=>
string(5) "brown"
[0]=>
string(6) "coffee"
}
- PHP 5 里，list() 从最右边的参数开始赋值； PHP 7 里，list() 从最左边的参数开始赋值。
example 4:
$foo = array(2 => 'a', 'foo' => 'b', 0 => 'c');
$foo[1] = 'd';
list($x, $y, $z) = $foo;
var_dump($foo, $x, $y, $z);
?>
array(4) {
[2]=>
string(1) "a"
["foo"]=>
string(1) "b"
[0]=>
string(1) "c"
[1]=>
string(1) "d"
}
string(1) "c"
string(1) "d"
string(1) "a"
- list() 使用 array 索引的顺序和它何时定义无关。
31. ## range($start, $end [, $step = 1]) ##
$start 序列的第一个值
$end 序列结束于$end值
$step 步长，应该为正值，不设置step则默认为1.
return 返回的数组中从$start到$end的单元
eg:
// array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
foreach (range(0, 12) as $number) {
echo $number;
}
// step 参数
// array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
foreach (range(0, 100, 10) as $number) {
echo $number;
}
// 字符序列的使用
// 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;
}
?>
note:
- 字符序列值仅限单个字符。 如果长度大于1，仅仅使用第一个字符。
# 字符串部分 #
1. ## chr( $ascii ) ##
返回相对应于ascii所指定的单个字符。
eg:
$str = "The string ends in escape: ";
$str .= chr(27); /* 在 $str 后边增加换码符 */
/* 通常这样更有用 */
$str = sprintf("The string ends in escape: %c", 27);
?>
2. ## count_chars( $string [, $mode = 0] ) ##
统计string中每个字节值(0...255)出现的次数，使用多种模式返回结果。
$mode
- 0 - 以所有的每个字节值作为键名，出现次数作为值的数组。
- 1 - 与 0 相同，但只列出出现次数大于零的字节值。
- 2 - 与 0 相同，但只列出出现次数等于零的字节值。
- 3 - 返回由所有使用了的字节值组成的字符串。
- 4 - 返回由所有未使用的字节值组成的字符串。
eg:
$data = "Two Ts and one F.";
foreach (count_chars($data, 1) as $i => $val) {
echo "There were $val instance(s) of \"" , chr($i) , "\" in the string.\n";
}
?>
There were 4 instance(s) of " " in the string.
There were 1 instance(s) of "." in the string.
There were 1 instance(s) of "F" in the string.
There were 2 instance(s) of "T" in the string.
There were 1 instance(s) of "a" in the string.
There were 1 instance(s) of "d" in the string.
There were 1 instance(s) of "e" in the string.
There were 2 instance(s) of "n" in the string.
There were 2 instance(s) of "o" in the string.
There were 1 instance(s) of "s" in the string.
There were 1 instance(s) of "w" in the string.
3. ## explode( $delimiter, $string [, $limit ] ) ##
使用一个字符串分割另一个字符串
$limit
- 正数 则返回的数组包含最多limit个元素，而最后那个元素将包含string剩余的部分
- 负数 返回除了最后的-limit个元素外的所有元素
- 0 会被当成1
eg:
example 1:
// 示例 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; // *
?>
example 2:
/* 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"
)
example 3:
$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
)
6. ## implode( $glue, $arr ) ##
使用$glue将一维数组的值连接为一个字符串
7. ## lcfirst( $str ) ##
使一个字符串的第一个字符小写
8. ## ltrim( $str [, $character_mask ] ) ##
删除字符串开头的空白字符（或其他字符）
$character_mask 可以指定想要删除的字符，简单的列出想要删除的所有字符即可。使用..可以指定字符的范围。
eg:
$text = "\t\tThese are a few words :) ... ";
$binary = "\x09Example string\x0A";
$hello = "Hello World";
var_dump($text, $binary, $hello);
print "\n";
$trimmed = ltrim($text);
var_dump($trimmed);
$trimmed = ltrim($text, " \t.");
var_dump($trimmed);
$trimmed = ltrim($hello, "Hdle");
var_dump($trimmed);
// 删除 $binary 开头的 ASCII 控制字符
// (从 0 到 31，包括 0 和 31)
$clean = ltrim($binary, "\x00..\x1F");
var_dump($clean);
?>
string(32) " These are a few words :) ... "
string(16) " Example string"
string(11) "Hello World"
string(30) "These are a few words :) ... "
string(30) "These are a few words :) ... "
string(7) "o World"
string(15) "Example string"
9. ## money_format( $format, $number ) ##
将数字格式化成货币字符串
10. ## nl2br( $str [, $is_xhtml ] ) ##
在字符串$str所有新行之前插入'
'或'
',并返回
eg:
example 1:
echo nl2br("foo isn't\n bar");
?>
foo isn't
bar
example 2:
echo nl2br("Welcome\r\nThis is my HTML document", false);
?>
Welcome
This is my HTML document
example 3:
$string = "This\r\nis\n\ra\nstring\r";
echo nl2br($string);
?>
This
is
a
string
11. ## number_format() ##
以千位分隔符方式格式化一个数字
本函数可以接受一个、两个或者四个参数，不能是三个
number_format( $num [, $decimals ] )
number_format( $num, $decimals, $dec_point = '.', $thousands_sep = ',' )
eg:
$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
?>
12. ## ord( $string ) ##
返回字符的ascii码值，如传入字符串，返回字符串第一个字符的ascii码值。
13. ## rtrim( $str [, $character_mask ] ) ##
删除字符串末端的空白字符或其他字符
16. ## sscanf() ##
17. ## printf() ##
17. ## str_ireplace() ##
18. ## str_pad() ##
19. ## str_repeat() ##
20. ## str_replace() ##
21. ## str_split() ##
22. ## str_word_count() ##
23. ## strip_tags() ##
24. ## stripos() ##
25. ## stristr() ##
26. ## strlen() ##
27. ## strnatcasecmp() ##
28. ## strnatcmp() ##
29. ## strpbrk() ##
30. ## strpos() ##
31. ## strrchr() ##
32. ## strripos() ##
33. ## strrpos() ##
34. ## strspn() ##
35. ## strstr() ##
36. ## strtok() ##
37. ## strtolower() ##
38. ## strtoupper() ##
39. ## strtr() ##
40. ## substr_count() ##
41. ## substr_replace() ##
42. ## substr() ##
43. ## trim() ##
44. ## ucfirst() ##
45. ## ucwords() ##
46. ## wordwrap() ##
# 日期和时间 #
1. ## date() ##
2. ## getdate() ##
3. ## strtotime() ##
4. ## time() ##
