This article mainly introduces some built-in php functions for operating arrays.
1. Merge arrays
The array_merge () function combines arrays and returns a Union array. The obtained array starts with the first input array parameter and is immediately added according to the order in which the following array parameters appear. The format is:
The code is as follows:
Array array_merge (array array1 array2 ..., ArrayN)
This function combines the units of one or more arrays. the values of an array are appended to the values of the previous array. Returns an array of results.
If the input array contains the same string key name, the value after the key name overwrites the previous value. However, if the array contains a number key name, the subsequent values will not overwrite the original values, but will be appended to the back.
If only one array is assigned and the array is indexed by number, the key name is re-indexed continuously.
The code is as follows:
$ Fruits = array ("apple", "banana", "pear ");
$ Numbered = array ("1", "2", "3 ");
$ Cards = array_merge ($ fruits, $ numbered );
Print_r ($ cards );
// Output
// Array ([0] => apple [1] => banana [2] => pear [3] => 1 [4] => 2 [5] => 3)
?>
2. append an array
The array_merge_recursive () function is the same as the array_merge () function. two or more numbers can be combined to form a combined array. the difference between the two is that when a key in an input array already exists in the result array, the function will adopt different processing methods. array_merge () overwrites the existing key/value pairs and replaces them with the key/value pairs in the current input array. array_merge_recursive () merges the two values, form a new array and use the original key as the array name. Another form of array merging is recursively appending an array. The format is:
The code is as follows:
Array array_merge_recursive (array array1, array array2 [..., Array arrayN])
The program example is as follows:
The code is as follows:
$ Fruit1 = array ("apple" => "red", "banana" => "yellow ");
$ Fruit2 = array ("pear" => "yellow", "apple" => "green ");
$ Result = array_merge_recursive ($ fruit1, $ fruit2 );
Print_r ($ result );
// Output
// Array ([apple] => Array ([0] => red [1] => green) [banana] => yellow [pear] => yellow)
?>
Now, the key apple points to an array consisting of two color values.
3. connect to an array
The array_combine () function returns a new array consisting of a set of submitted keys and corresponding values. The format is:
The code is as follows:
Array array_combine (array keys, array values)
Note: the two input arrays must be of the same size and cannot be empty. Example:
The code is as follows:
$ Name = array ("apple", "banana", "orange ");
$ Color = array ("red", "yellow", "orange ");
$ Fruit = array_combine ($ name, $ color );
Print_r ($ fruit );
// Output
// Array ([apple] => red [banana] => yellow [orange] => orange)
?>
4. split the array array_slice ()
The array_slice () function returns a part of the array, starting from the key offset and ending at the offset + length position. Form:
The code is as follows:
Array array_slice (array, int offset [, int length])
When offset is a positive value, the split starts from the offset position starting from the array. if offset is a negative value, the split starts from the offset position at the end of the array. If the optional length parameter is omitted, the split starts from offset to the last element of the array. If length is given and it is a positive number, it will end at the offset + length position starting with the array. On the contrary, if length is given and it is a negative number, it ends at the count (input_array)-| length | position starting with the array. Consider an example:
The code is as follows:
$ Fruits = array ("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon ");
$ Subset = array_slice ($ fruits, 3 );
Print_r ($ subset );
// Output
// Array ([0] => Pear [1] => Grape [2] => Lemon [3] => Watermelon)
?>
Then we use the following negative length:
The code is as follows:
$ Fruits = array ("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon ");
$ Subset = array_slice ($ fruits, 2,-2 );
Print_r ($ subset );
// Output
// Array ([0] => Orange [1] => Pear [2] => Grape)
?>
5. join array array_splice ()
The array_splice () function deletes all elements in the array from offset to offset + length, and returns the deleted elements in an array. The format is:
The code is as follows:
Array array_splice (array, int offset [, length [, array replacement])
When offset is a positive value, the join starts from the offset position starting from the array. when offset is a negative value, the join starts from the offset position at the end of the array. If the optional length parameter is ignored, all elements from the offset position to the end of the array will be deleted. If length is given and it is a positive value, the join ends at the offset + leng th position starting with the array. Conversely, if length is given and it is a negative value, the combination ends at the position of count (input_array)-length starting with the array. Example:
The code is as follows:
$ Fruits = array ("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon ");
$ Subset = array_splice ($ fruits, 4 );
Print_r ($ fruits );
Print_r ($ subset );
// Output
// Array ([0] => Apple [1] => Banana [2] => Orange [3] => Pear)
// Array ([0] => Grape [1] => Lemon [2] => Watermelon)
?>
You can use the optional parameter replacement to specify an array that replaces the target part. Example:
The code is as follows:
$ Fruits = array ("Apple", "Banana", "Orange", "Pear", "Grape", "Lemon", "Watermelon ");
$ Subset = array_splice ($ fruits, 2,-1, array ("Green Apple", "Red Apple "));
Print_r ($ fruits );
Print_r ($ subset );
// Output
// Array ([0] => Apple [1] => Banana [2] => Green Apple [3] => Red Apple [4] => Watermelon)
// Array ([0] => Orange [1] => Pear [2] => Grape [3] => Lemon)
?>
The program clearly shows how to use this function.
6. array intersection array_intersect ()
The array_intersect () function returns an array with keys retained. this array is composed of only values that appear in the first array and appear in each other input array. The format is as follows:
The code is as follows:
Array array_intersect (array array1, array array2 [, arrayN…])
The following example returns all fruits that appear in the $ fruit1 array and also appear in $ fruit2 and $ fruit3:
The code is as follows:
$ Fruit1 = array ("Apple", "Banana", "Orange ");
$ Fruit2 = array ("Pear", "Apple", "Grape ");
$ Fruit3 = array ("Watermelon", "Orange", "Apple ");
$ Intersection = array_intersect ($ fruit1, $ fruit2, $ fruit3 );
Print_r ($ intersection );
// Output
// Array ([0] => Apple)
?>
The array_intersect () function considers the two elements to be identical only when they have the same data type.
7. array_intersect_assoc ()
The array_intersect_assoc () function is basically the same as the array_intersect () function, except that the array key is also considered during comparison. Therefore, only key/value pairs that appear in the first array and also appear in all other input arrays are returned to the result array.
The format is as follows:
The code is as follows:
Array array_intersect_assoc (array array1, array array2 [, arrayN…])
The following example returns all key/value pairs that appear in the $ fruit1 array and $ fruit2 and $ fruit3 at the same time:
The code is as follows:
$ Fruit1 = array ("red" => "Apple", "yellow" => "Banana", "orange" => "Orange ");
$ Fruit2 = array ("yellow" => "Pear", "red" => "Apple", "purple" => "Grape ");
$ Fruit3 = array ("green" => "Watermelon", "orange" => "Orange", "red" => "Apple ");
$ Intersection = array_intersect_assoc ($ fruit1, $ fruit2, $ fruit3 );
Print_r ($ intersection );
// Output
// Array ([red] => Apple)
?>
8. array difference set array_diff ()
The array_diff () function returns a value that appears in the first array but does not exist in other input arrays. This function is opposite to array_intersect.
The code is as follows:
Array array_diff (array array1, array array2 [, arrayN…])
Example:
The code is as follows:
$ Fruit1 = array ("Apple", "Banana", "Orange ");
$ Fruit2 = array ("Pear", "Apple", "Grape ");
$ Fruit3 = array ("Watermelon", "Orange", "Apple ");
$ Intersection = array_diff ($ fruit1, $ fruit2, $ fruit3 );
Print_r ($ intersection );
// Output
// Array ([1] => Banana)
?>
9. array_diff_assoc ()
The array_diff_assoc () function is basically the same as the array_diff () function, except that the array key is also considered during comparison. Therefore, only key/value pairs that appear in the first array instead of other input arrays are returned to the result array. The format is as follows:
The code is as follows:
Array array_diff_assoc (array array1, array array2 [, arrayN…])
In the following example, only [yellow] => Banana is returned, because this special key/value pair exists in $ fruit1, and does not exist in $ fruit2 or $ fruit3.
The code is as follows:
$ Fruit1 = array ("red" => "Apple", "yellow" => "Banana", "orange" => "Orange ");
$ Fruit2 = array ("yellow" => "Pear", "red" => "Apple", "purple" => "Grape ");
$ Fruit3 = array ("green" => "Watermelon", "orange" => "Orange", "red" => "Apple ");
$ Intersection = array_diff_assoc ($ fruit1, $ fruit2, $ fruit3 );
Print_r ($ intersection );
// Output
// Array ([yellow] => Banana)
?>
When using arrays, you often need to traverse arrays. It is usually necessary to traverse the array and obtain each key or value (or simultaneously obtain the key and value), so it is not surprising that PHP provides some functions to meet the needs. Many functions can complete two tasks, not only to obtain the key or value of the current pointer position, but also to move the pointer to the next appropriate position.
10. get the current array key ()
The key () function returns the key where the current pointer is located in input_array. The format is as follows:
The code is as follows:
Mixed key (array)
The following example outputs the key of the $ fruits array by iteratively processing the array and moving the pointer:
The code is as follows:
$ Fruits = array ("apple" => "red", "banana" => "yellow ");
While ($ key = key ($ fruits )){
Printf ("% s
", $ Key );
Next ($ fruits );
}
// Apple
// Banana
Note that the pointer is not moved every time key () is called. Therefore, the next () function must be used to complete the task of advancing the pointer.
11. get the current array value current ()
The current () function returns the array value of the current pointer position in the array. The format is as follows:
The code is as follows:
Mixed current (array)
Next, modify the previous example to obtain the array value:
The code is as follows:
$ Fruits = array ("apple" => "red", "banana" => "yellow ");
While ($ fruit = current ($ fruits )){
Printf ("% s
", $ Fruit );
Next ($ fruits );
}
// Red
// Yellow
12. get the current array key and value each ()
The each () function returns the current key/value pair of input_array and pushes the pointer to a position. The format is as follows:
The code is as follows:
Array each (array)
The returned array contains four keys. Keys 0 and key contain the key name, while Keys 1 and value contain the corresponding data. If the pointer before execution of each () is located at the end of the array, false is returned.
The code is as follows:
$ Fruits = array ("apple", "banana", "orange", "pear ");
Print_r (each ($ fruits ));
// Array ([1] => apple [value] => apple [0] => 0 [key] => 0)
Each () is often used in combination with list () to traverse arrays. This example is similar to the previous example, but the entire array is output cyclically:
The code is as follows:
$ Fruits = array ("apple", "banana", "orange", "pear ");
Reset ($ fruits );
While (list ($ key, $ val) = each ($ fruits ))
{
Echo "$ key => $ val
";
}
// 0 => apple
// 1 => banana
// 2 => orange
// 3 => pear
Because the original array pointer is reset when an array is assigned to another array, if $ fruits is assigned to another variable in the previous example, an infinite loop will occur.
This completes the array traversal.
Searching, filtering, and searching array elements are common functions of array operations. The following describes several related functions.
13. in_array () function
The in_array () function searches for a specific value in an array. if this value is found, true is returned. otherwise, false is returned. The format is as follows:
The code is as follows:
Boolean in_array (mixed needle, array haystack [, boolean strict]);
Let's take a look at the example below to check whether the variable apple is already in the array. if so, a piece of information is output:
The code is as follows:
$ Fruit = "apple ";
$ Fruits = array ("apple", "banana", "orange", "pear ");
If (in_array ($ fruit, $ fruits ))
Echo "$ fruit is already in the array ";
The third parameter is optional. it forces in_array () to consider the type during search.
14. array_key_exists () function
If a specified key is found in an array, the array_key_exists () function returns true; otherwise, false. The format is as follows:
The code is as follows:
Boolean array_key_exists (mixed key, array );
The following example searches for apple in the array key. if it is found, the color of the fruit is output:
The code is as follows:
$ Fruit ["apple"] = "red ";
$ Fruit ["banana"] = "yellow ";
$ Fruit ["pear"] = "green ";
If (array_key_exists ("apple", $ fruit )){
Printf ("apple's color is % s", $ fruit ["apple"]);
}
// Apple's color is red
15. array_search () function
The array_search () function searches for a specified value in an array. If yes, the corresponding key is returned. otherwise, false is returned. The format is as follows:
The code is as follows:
Mixed array_search (mixed needle, array haystack [, boolean strict])
The following example searches for a specific date (December 7) in $ fruits. if it is found, information about the corresponding state is returned:
The code is as follows:
$ Fruits ["apple"] = "red ";
$ Fruits ["banana"] = "yellow ";
$ Fruits ["watermelon"] = "green ";
$ Founded = array_search ("green", $ fruits );
If ($ founded)
Printf ("% s was founded on % s.", $ founded, $ fruits [$ founded]);
// Watermelon was founded on green.
16. array_keys () function
The array_keys () function returns an array containing all the keys found in the searched array. The format is as follows:
The code is as follows:
Array array_keys (array [, mixed search_value])
If the optional parameter search_value is included, only the key that matches the value is returned. The following example outputs all the arrays found in the $ fruit array:
The code is as follows:
$ Fruits ["apple"] = "red ";
$ Fruits ["banana"] = "yellow ";
$ Fruits ["watermelon"] = "green ";
$ Keys = array_keys ($ fruits );
Print_r ($ keys );
// Array ([0] => apple [1] => banana [2] => watermelon)
17. array_values () function
The array_values () function returns all values in an array and automatically provides a numerical index for the returned array. The format is as follows:
The code is as follows:
Array array_values (array)
The following example gets the values of each element found in $ fruits:
The code is as follows:
$ Fruits ["apple"] = "red ";
$ Fruits ["banana"] = "yellow ";
$ Fruits ["watermelon"] = "green ";
$ Values = array_values ($ fruits );
Print_r ($ values );
// Array ([0] => red [1] => yellow [2] => green)
Sometimes we need to expand an array or delete a part of the array. PHP provides some functions for extending and downgrading the array. For programmers who want to simulate various queue implementations (FIFO and LIFO), these functions can be convenient. As the name suggests, the function names (push, pop, shift, and unshift) of these functions clearly reflect their functions.
PS: The traditional queue is a data structure. Deleting elements is in the same order as adding elements, which is called FIFO or FIFO. On the contrary, the stack is another data structure, in which the order in which elements are deleted is the opposite of the order when they are added, which is either backward-forward, FIFO, or LIFO.
18. add elements to the array header
The array_unshift () function adds elements to the array header. All existing numeric keys are modified accordingly to reflect their new positions in the array, but the associated keys are not affected. The format is as follows:
The code is as follows:
Int array_unshift (array, mixed variable [, mixed variable])
In the following example, two fruits are added before the $ fruits array:
The code is as follows:
$ Fruits = array ("apple", "banana ");
Array_unshift ($ fruits, "orange", "pear ")
// $ Fruits = array ("orange", "pear", "apple", "banana ");
19. add elements at the end of the array
The return value of the array_push () function is int type, which is the number of elements in the array after data is pressed. for this function, multiple variables can be passed as parameters and multiple variables can be pushed to the array at the same time. The format is:
The code is as follows:
(Array, mixed variable [, mixed variable...])
The following example adds two more fruits to the $ fruits array:
The code is as follows:
$ Fruits = array ("apple", "banana ");
Array_push ($ fruits, "orange", "pear ")
// $ Fruits = array ("apple", "banana", "orange", "pear ")
20. delete the value from the array header
The array_shift () function deletes and returns the elements found in the array. The result is that if a numeric value is used, all corresponding values are moved down, and the array using the correlated key is not affected. The format is
The code is as follows:
Mixed array_shift (array)
The following example deletes the first element apple in the $ fruits array:
The code is as follows:
$ Fruits = array ("apple", "banana", "orange", "pear ");
$ Fruit = array_shift ($ fruits );
// $ Fruits = array ("banana", "orange", "pear ")
// $ Fruit = "apple ";
21. delete elements from the end of the array
The array_pop () function deletes the array and returns the last element of the array. The format is:
The code is as follows:
Mixed array_pop (aray target_array );
The following example deletes the last state from the $ states array:
The code is as follows:
$ Fruits = array ("apple", "banana", "orange", "pear ");
$ Fruit = array_pop ($ fruits );
// $ Fruits = array ("apple", "banana", "orange ");
// $ Fruit = "pear ";
