Функции для работы с массивами

Смотрите также

См. также is_array(), explode(), implode(), split(), preg_split() и unset().

Содержание

  • array_change_key_case — Меняет регистр всех ключей в массиве
  • array_chunk — Разбивает массив на части
  • array_column — Возвращает массив из значений одного столбца входного массива
  • array_combine — Создает новый массив, используя один массив в качестве ключей, а другой в качестве соответствующих значений
  • array_count_values — Подсчитывает количество всех значений массива
  • array_diff_assoc — Вычисляет расхождение массивов с дополнительной проверкой индекса
  • array_diff_key — Вычисляет расхождение массивов, сравнивая ключи
  • array_diff_uassoc — Вычисляет расхождение массивов с дополнительной проверкой индекса, осуществляемой при помощи callback-функции
  • array_diff_ukey — Вычисляет расхождение массивов, используя callback-функцию для сравнения ключей
  • array_diff — Вычислить расхождение массивов
  • array_fill_keys — Создает массив и заполняет его значениями, с определенными ключами
  • array_fill — Заполняет массив значениями
  • array_filter — Фильтрует элементы массива с помощью callback-функции
  • array_flip — Меняет местами ключи с их значениями в массиве
  • array_intersect_assoc — Вычисляет схождение массивов с дополнительной проверкой индекса
  • array_intersect_key — Вычислить пересечение массивов, сравнивая ключи
  • array_intersect_uassoc — Вычисляет схождение массивов с дополнительной проверкой индекса, осуществляемой при помощи callback-функции
  • array_intersect_ukey — Вычисляет схождение массивов, используя callback-функцию для сравнения ключей
  • array_intersect — Вычисляет схождение массивов
  • array_key_exists — Проверяет, присутствует ли в массиве указанный ключ или индекс
  • array_keys — Возвращает все или некоторое подмножество ключей массива
  • array_map — Применяет callback-функцию ко всем элементам указанных массивов
  • array_merge_recursive — Рекурсивное слияние двух или более массивов
  • array_merge — Сливает один или большее количество массивов
  • array_multisort — Сортирует несколько массивов или многомерные массивы
  • array_pad — Дополнить размер массива определенным значением до заданной величины
  • array_pop — Извлекает последний элемент массива
  • array_product — Вычислить произведение значений массива
  • array_push — Добавляет один или несколько элементов в конец массива
  • array_rand — Выбирает одно или несколько случайных значений из массива
  • array_reduce — Итеративно уменьшает массив к единственному значению, используя callback-функцию
  • array_replace_recursive — Рекурсивно заменяет элементы первого массива элементами переданных массивов
  • array_replace — Замена элементов массива элементами других переданных массивов
  • array_reverse — Возвращает массив с элементами в обратном порядке
  • array_search — Осуществляет поиск данного значения в массиве и возвращает ключ первого найденного элемента в случае удачи
  • array_shift — Извлекает первый элемент массива
  • array_slice — Выбирает срез массива
  • array_splice — Удаляет часть массива и заменяет её чем-нибудь ещё
  • array_sum — Вычисляет сумму значений массива
  • array_udiff_assoc — Вычисляет расхождение в массивах с дополнительной проверкой индексов, используя для сравнения значений callback-функцию
  • array_udiff_uassoc — Вычисляет расхождение в массивах с дополнительной проверкой индексов, используя для сравнения значений и индексов callback-функцию
  • array_udiff — Вычисляет расхождение массивов, используя для сравнения callback-функцию
  • array_uintersect_assoc — Вычисляет пересечение массивов с дополнительной проверкой индексов, используя для сравнения значений callback-функцию
  • array_uintersect_uassoc — Вычисляет пересечение массивов с дополнительной проверкой индекса, используя для сравнения индексов и значений индивидуальные callback-функции
  • array_uintersect — Вычисляет пересечение массивов, используя для сравнения значений callback-функцию
  • array_unique — Убирает повторяющиеся значения из массива
  • array_unshift — Добавляет один или несколько элементов в начало массива
  • array_values — Выбирает все значения массива
  • array_walk_recursive — Рекурсивно применяет пользовательскую функцию к каждому элементу массива
  • array_walk — Применяет заданную пользователем функцию к каждому элементу массива
  • array — Создает массив
  • arsort — Сортирует массив в обратном порядке, сохраняя ключи
  • asort — Сортирует массив, сохраняя ключи
  • compact — Создает массив, содержащий названия переменных и их значения
  • count — Подсчитывает количество элементов массива или что-то в объекте
  • current — Возвращает текущий элемент массива
  • each — Возвращает текущую пару ключ/значение из массива и смещает его указатель
  • end — Устанавливает внутренний указатель массива на его последний элемент
  • extract — Импортирует переменные из массива в текущую таблицу символов
  • in_array — Проверяет, присутствует ли в массиве значение
  • key_exists — Псевдоним array_key_exists
  • key — Выбирает ключ из массива
  • krsort — Сортирует массив по ключам в обратном порядке
  • ksort — Сортирует массив по ключам
  • list — Присваивает переменным из списка значения подобно массиву
  • natcasesort — Сортирует массив, используя алгоритм "natural order" без учета регистра символов
  • natsort — Сортирует массив, используя алгоритм "natural order"
  • next — Передвигает внутренний указатель массива на одну позицию вперёд
  • pos — Псевдоним current
  • prev — Передвигает внутренний указатель массива на одну позицию назад
  • range — Создает массив, содержащий диапазон элементов
  • reset — Устанавливает внутренний указатель массива на его первый элемент
  • rsort — Сортирует массив в обратном порядке
  • shuffle — Перемешивает массив
  • sizeof — Псевдоним count
  • sort — Сортирует массив
  • uasort — Сортирует массив, используя пользовательскую функцию для сравнения элементов с сохранением ключей
  • uksort — Сортирует массив по ключам, используя пользовательскую функцию для сравнения ключей
  • usort — Сортирует массив по значениям используя пользовательскую функцию для сравнения элементов
add a note add a note

User Contributed Notes 10 notes

up
10
dave at davidhbrown dot us
5 years ago
While PHP has well over three-score array functions, array_rotate is strangely missing as of PHP 5.3. Searching online offered several solutions, but the ones I found have defects such as inefficiently looping through the array or ignoring keys.

The following array_rotate() function uses array_merge and array_shift to reliably rotate an array forwards or backwards, preserving keys. If you know you can trust your $array to be an array and $shift to be between 0 and the length of your array, you can skip the function definition and use just the return expression in your code.

<?php
function array_rotate($array, $shift) {
    if(!
is_array($array) || !is_numeric($shift)) {
        if(!
is_array($array)) error_log(__FUNCTION__.' expects first argument to be array; '.gettype($array).' received.');
        if(!
is_numeric($shift)) error_log(__FUNCTION__.' expects second argument to be numeric; '.gettype($shift)." `$shift` received.");
        return
$array;
    }
   
$shift %= count($array); //we won't try to shift more than one array length
   
if($shift < 0) $shift += count($array);//handle negative shifts as positive
   
return array_merge(array_slice($array, $shift, NULL, true), array_slice($array, 0, $shift, true));
}
?>
A few simple tests:
<?php
$array
=array("foo"=>1,"bar"=>2,"baz"=>3,4,5);

print_r(array_rotate($array, 2));
print_r(array_rotate($array, -2));
print_r(array_rotate($array, count($array)));
print_r(array_rotate($array, "4"));
print_r(array_rotate($array, -9));
?>
up
9
kolkabes at googlemail dot com
4 years ago
Short function for making a recursive array copy while cloning objects on the way.

<?php
function arrayCopy( array $array ) {
       
$result = array();
        foreach(
$array as $key => $val ) {
            if(
is_array( $val ) ) {
               
$result[$key] = arrayCopy( $val );
            } elseif (
is_object( $val ) ) {
               
$result[$key] = clone $val;
            } else {
               
$result[$key] = $val;
            }
        }
        return
$result;
}
?>
up
0
Ewan
2 months ago
I was looking for an array aggregation function here and ended up writing this one.

Note: This implementation assumes that none of the fields you're aggregating on contain The '@' symbol.

<?php
 
function array_group_by($flds, $arr) {
   
$groups = array();
    foreach (
$arr as $rec) {
     
$keys = array_map(function($f) use($rec) { return $rec[$f]; }, $flds);
     
$k = implode('@', $keys);
      if (isset(
$groups[$k])) {
       
$groups[$k][] = $rec;
      } else {
       
$groups[$k] = array($rec);
      }
    }
    return
$groups;
  }

?>
up
1
renatonascto at gmail dot com
8 years ago
Big arrays use a lot of memory possibly resulting in memory limit errors. You can reduce memory usage on your script by destroying them as soon as you´re done with them. I was able to get over a few megabytes of memory by simply destroying some variables I didn´t use anymore.
You can view the memory usage/gain by using the funcion memory_get_usage(). Hope this helps!
up
0
callmeanaguma at gmail dot com
4 years ago
If you need to flattern two-dismensional array with single values assoc subarrays, you could use this function:

<?php
function arrayFlatten($array) {
       
$flattern = array();
        foreach (
$array as $key => $value){
           
$new_key = array_keys($value);
           
$flattern[] = $value[$new_key[0]];
        }
        return
$flattern;
}
?>
up
-5
ob at babcom dot biz
10 years ago
Here is a function to find out the maximum depth of a multidimensional array.

<?php
// return depth of given array
// if Array is a string ArrayDepth() will return 0
// usage: int ArrayDepth(array Array)

function ArrayDepth($Array,$DepthCount=-1,$DepthArray=array()) {
 
$DepthCount++;
  if (
is_array($Array))
    foreach (
$Array as $Key => $Value)
     
$DepthArray[]=ArrayDepth($Value,$DepthCount);
  else
    return
$DepthCount;
  foreach(
$DepthArray as $Value)
   
$Depth=$Value>$Depth?$Value:$Depth;
  return
$Depth;
}
?>
up
-9
mo dot longman at gmail dot com
9 years ago
to 2g4wx3:
i think better way for this is using JSON, if you have such module in your PHP. See json.org.

to convert JS array to JSON string: arr.toJSONString();
to convert JSON string to PHP array: json_decode($jsonString);

You can also stringify objects, numbers, etc.
up
-10
cyberchrist at futura dot net
9 years ago
Lately, dealing with databases, I've been finding myself needing to know if one array, $a, is a proper subset of $b.

Mathematically, this is asking (in set theory) [excuse the use of u and n instead of proper Unicode):

( A u B ) n ( ~ B )

What this does is it first limits to known values, then looks for anything outside of B but in the union of A and B (which would be those things in A which are not also in B).

If any value exists in this set, then A is NOT a proper subset of B, because a value exists in A but not in B.  For A to be a proper subset, all values in A must be in B.

I'm sure this could easily be done any number of ways but this seems to work for me.  It's not got a lot of error detection such as sterilizing inputs or checking input types.

// bool array_subset( array, array )
// Returns true if $a is a proper subset of $b, returns false otherwise.

function array_subset( $a, $b )
{
    if( count( array_diff( array_merge($a,$b), $b)) == 0 )
        return true;
    else
        return false;
}
up
-8
nicoolasens at gmail dot com
1 year ago
/*to change an index without rewriting the whole table and leave at the same place.
*/
<?php
function change_index(&$tableau, $old_key, $new_key) {
   
$changed = FALSE;
   
$temp = 0;
    foreach (
$tableau as $key => $value) {
        switch (
$changed) {
            case
FALSE :
               
//creates the new key and deletes the old
               
if ($key == $old_key) {
                   
$tableau[$new_key] = $tableau[$old_key];
                    unset(
$tableau[$old_key]);
                   
$changed = TRUE;
                }
                break;

            case
TRUE :
               
//moves following keys
               
if ($key != $new_key){
               
$temp= $tableau[$key];
                unset(
$tableau[$key]);
               
$tableau[$key] = $temp;
                break;
                }
                else {
$changed = FALSE;} //stop
       
}
    }
   
array_values($tableau); //free_memory
}

//Result :
$tableau = array(1, 2 , 3, 4,5, 6, 7, 8, 9, 10);
$res = print_r($tableau, TRUE);
$longueur = strlen($res) -1;
echo
"Old array :\n" . substr($res, 8, $longueur) . "\n" ;

change_index ($tableau, 2, 'number 2');
$res = print_r($tableau, TRUE);
$longueur = strlen($res) -10;
echo
"New array :\n" . substr($res, 8, $longueur) . "\n" ;

/*
Old array :
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
)

New array :
    [0] => 1
    [1] => 2
    [numéro 2] => 3
    [3] => 4
    [4] => 5
    [5] => 6
    [6] => 7
    [7] => 8
    [8] => 9
    [9] => 10
*/
?>
up
-11
oliverSPAMMENOT at e-geek dot com dot au
7 years ago
Function to pretty print arrays and objects. Detects object recursion and allows setting a maximum depth. Based on arraytostring and u_print_r from the print_r function notes. Should be called like so:

<?php
egvaluetostring
($value)   //no max depth, or
egvaluetostring($value, $max_depth)   //max depth set

function egvaluetostring($value, $max_depth, $key = NULL, $depth = 0, $refChain = array()) {
  if(
$depth > 0)
   
$tab = str_repeat("\t", $depth);
 
$text .= $tab . ($key !== NULL ? $key . " => " : "");
 
  if (
is_array($value) || is_object($value)) {
   
$recursion = FALSE;
    if (
is_object($value)) {
      foreach (
$refChain as $refVal) {
        if (
$refVal === $value) {
         
$recursion = TRUE;
          break;
        }
      }
     
array_push($refChain, $value);
    }
   
   
$text .= (is_array($value) ? "array" : "object") . " ( ";
   
    if (
$recursion) {
     
$text .= "*RECURSION* ";
    }
    elseif (isset(
$max_depth) && $depth >= $max_depth) {
     
$text .= "*MAX DEPTH REACHED* ";
    }
    else {
      if (!empty(
$value)) {
       
$text .= "\n";
        foreach (
$value as $child_key => $child_value) {
         
$text .= egvaluetostring($child_value, $max_depth, (is_array($value) ? "[" : "") . $child_key . (is_array($value) ? "]" : ""), $depth+1, $refChain) . ",\n";
        }
       
$text .= "\n" . $tab;
      }
    }
   
   
$text .= ")";
   
    if (
is_object($value)) {
     
array_pop($refChain);
    }
  }
  else {
   
$text .= "$value";
  }

  return
$text;
}
?>
To Top