Как изменить значение массива php

Пример #1 Пример использования array_replace()

Результат выполнения данного примера:

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


<?php
// we wanted the output of only selected array_keys from a big array from a csv-table
// with different order of keys, with optional suppressing of empty or unused values$values = array
(
    'Article'=>'24497',
    'Type'=>'LED',
    'Socket'=>'E27',
    'Dimmable'=>'',
    'Wattage'=>'10W'
);$keys = array_fill_keys(array('Article','Wattage','Dimmable','Type','Foobar'), ''); // wanted array with empty value$allkeys = array_replace($keys, array_intersect_key($values, $keys));    // replace only the wanted keys$notempty = array_filter($allkeys, 'strlen'); // strlen used as the callback-function with 0==falseprint '<pre>';
print_r($allkeys);
print_r($notempty);/*
Array
(
    [Article] => 24497
    [Wattage] => 10W
    [Dimmable] =>
    [Type] => LED
    [Foobar] =>
)
Array
(
    [Article] => 24497
    [Wattage] => 10W
    [Type] => LED
)
*/
?>




Simple function to replace array keys. Note you have to manually select wether existing keys will be overrided.


Here is a simple array_replace_keys function:


To get exactly same result like in PHP 5.3, the foreach loop in your code should look like:


In some cases you might have a structured array from the database and one
of its nodes goes like this;


I got hit with a noob mistake. :)


if(!function_exists('array_replace'))
{
  function array_replace()
  {
    $args = func_get_args();
    $num_args = func_num_args();
    $res = array();
    for($i=0; $i<$num_args; $i++)
    {
      if(is_array($args[$i]))
      {
        foreach($args[$i] as $key => $val)
        {
          $res[$key] = $val;
        }
      }
      else
      {
        trigger_error(__FUNCTION__ .'(): Argument #'.($i+1).' is not an array', E_USER_WARNING);
        return NULL;
      }
    }
    return $res;
  }
}



Instead of calling this function, it's often faster and simpler to do this instead:


If the arrays are associative (that is, their keys are strings), then I believe this function is identical to (the older) array_merge.



Concerning the affirmation:
If you want to append array elements from the second array to the first array while not overwriting the elements from the first array and not re-indexing, use the + array union operator


You can also use:


I would like to add to my previous note about my polecat_array_replace function that if you want to add a single dimensional array to a multi, all you must do is pass the matching internal array key from the multi as the initial argument as such:


The documentation is wrongly phrased: "array_replace() replaces the values of array1"  No replacing is done. A new array is created which looks like the one that would have resulted from the described replacement.


a little enhancement to dyer85 at gmail dot com's function below:
<?php
if (!function_exists('array_replace'))
{
  function array_replace( array &$array, array &$array1, $filterEmpty=false )
  {
    $args = func_get_args();
    $count = func_num_args()-1;


If you work on some realy old server below PHP5 you can use array_merge like "necessary evil" to replace values in array:

Определение при помощи array()

Массив (тип array) может быть создан языковой конструкцией array().
В качестве параметров она принимает любое количество разделённых запятыми пар
key => value
(ключ => значение).

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

Запятая после последнего элемента массива необязательна и может быть опущена.
Обычно это делается для однострочных массивов, то есть array(1, 2)
предпочтительней array(1, 2, ). Для многострочных массивов с другой
стороны обычно используется завершающая запятая, так как позволяет легче добавлять
новые элементы в конец массива.

Замечание:

Существует короткий синтаксис массива, который заменяет
array() на [].

key может быть либо типа int, либо типа
string. value может быть любого типа.

Дополнительно с ключом key будут сделаны следующие преобразования:

• 
  Строки (string), содержащие целое число (int) (исключая случаи, когда число предваряется знаком +) будут преобразованы к типу int.
  Например, ключ со значением "8" будет в действительности сохранён со
  значением 8. С другой стороны, значение "08" не
  будет преобразовано, так как оно не является корректным десятичным целым.
  
• 
  Числа с плавающей точкой (float) также будут преобразованы к типу
  int, то есть дробная часть будет отброшена. Например, ключ со значением
  8.7 будет в действительности сохранён со значением 8.
  
• 
  Тип bool также преобразовываются к типу int.
  Например, ключ со значением true будет сохранён со значением
  1 и ключ со значением false будет сохранён со
  значением 0.
  
• 
  Тип null будет преобразован к пустой строке. Например, ключ со
  значением null будет в действительности сохранён со значением
  "".
  
• 
  Массивы (array) и объекты (object) не
  могут использоваться в качестве ключей. При подобном использовании будет
  генерироваться предупреждение: Недопустимый тип смещения (Illegal offset type).
  

Если несколько элементов в объявлении массива используют одинаковый ключ, то только
последний будет использоваться, а все другие будут перезаписаны.

array(1) {
  [1]=>
  string(1) "d"
}

Массивы в PHP могут содержать ключи типов int и string
одновременно, так как PHP не делает различия между индексированными и ассоциативными
массивами.

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

Параметр key является необязательным. Если он не указан,
PHP будет использовать предыдущее наибольшее значение ключа типа
int, увеличенное на 1.

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hallo"
  [3]=>
  string(5) "world"
}

Возможно указать ключ только для некоторых элементов и пропустить для других:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

Доступ к элементам массива с помощью квадратных скобок

Доступ к элементам массива может быть осуществлён с помощью синтаксиса array[key].

string(3) "bar"
int(24)
string(3) "foo"

Замечание:

До PHP 8.0.0 квадратные и фигурные скобки могли использоваться взаимозаменяемо для доступа
к элементам массива (например, в примере выше $array[42] и $array{42}
делали то же самое).
Синтаксис фигурных скобок устарел в PHP 7.4.0
и больше не поддерживается в PHP 8.0.0.

Замечание:

Попытка доступа к неопределённому ключу в массиве — это то же самое,
что и попытка доступа к любой другой неопределённой переменной:
будет сгенерирована ошибка уровня E_WARNING
(ошибка уровня E_NOTICE до PHP 8.0.0),
и результат будет null.

Замечание:

Массив, разыменовывающий скалярное значение, которое не является строкой
(string), отдаст null. До PHP 7.4.0 не выдаётся сообщение об ошибке.
Начиная с PHP 7.4.0, выдаётся ошибка E_NOTICE;
с PHP 8.0.0 выдаётся ошибка E_WARNING.

Создание/модификация с помощью синтаксиса квадратных скобок

Существующий массив может быть изменён путём явной установкой значений в нем.

Это выполняется присвоением значений массиву (array) с указанием в
скобках ключа. Кроме того, ключ можно опустить, в результате получится пустая пара скобок ([]).

    $arr[key] = value;
    $arr[] = value;
    // key может быть int или string
    // value может быть любым значением любого типа

Если массив $arr ещё не существует или для него
задано значение null или false, он будет создан.
Таким образом, это ещё один способ определить массив array. Однако такой
способ применять не рекомендуется, так как если переменная $arr
уже содержит некоторое значение (например, значение типа string из
переменной запроса), то это значение останется на месте и [] может на
самом деле означать доступ к символу в
строке. Лучше инициализировать переменную путём явного присваивания значения.

Замечание:

Начиная с PHP 7.1.0, используя в оператор «пустой индекс» на строке, приведёт к
фатальной ошибке. Ранее, в этом случае, строка молча преобразовывалась в массив.

Замечание:

Начиная с PHP 8.1.0, создание нового массива с помощью значения false устарело.
Создание нового массива из null и неопределённого значения по-прежнему разрешено.

Для изменения определённого значения просто присвойте новое значение элементу,
используя его ключ. Если вы хотите удалить пару ключ/значение, вам необходимо
использовать функцию unset().

Замечание:

Как уже говорилось выше, если ключ не был указан, то будет взят максимальный из
существующих целочисленных (int) индексов, и новым ключом будет
это максимальное значение (в крайнем случае 0) плюс 1. Если целочисленных (int) индексов
ещё нет, то ключом будет 0 (ноль).

Учтите, что максимальное целое значение ключа не обязательно
существует в массиве в данный момент. Оно могло просто существовать
в массиве какое-то время, с тех пор как он был переиндексирован в последний раз.
Следующий пример это иллюстрирует:


<?php
// Создаём простой массив.
$array = array(1, 2, 3, 4, 5);
print_r($array);// Теперь удаляем каждый элемент, но сам массив оставляем нетронутым:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);// Добавляем элемент (обратите внимание, что новым ключом будет 5, вместо 0).
$array[] = 6;
print_r($array);// Переиндексация:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>



Результат выполнения данного примера:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Деструктуризация массива

Массивы могут быть деструктурированы с помощью языковых конструкций [] (начиная с PHP 7.1.0)
или list(). Эти конструкции могут быть использованы для деструктуризации массива на отдельные переменные.

Деструктуризация массива может быть использована в конструкции foreach
для деструктуризации многомерного массива во время итерации по нему.

Элементы массива будут игнорироваться, если переменная не указана.
Деструктуризация массива всегда начинается с индекса 0.

Начиная с PHP 7.1.0, ассоциативные массивы также могут быть деструктурированы.
Это позволяет легче выбирать нужный элемент в массивах с числовым индексом,
так как индекс может быть указан явно.

Деструктуризация массива может быть использована для простой замены двух переменных местами.

Замечание:

Оператор ... не поддерживается в присваиваниях.

Замечание:

Попытка получить доступ к ключу массива, который не был определён,
аналогична обращению к любой другой неопределённой переменной:
будет выдано сообщение об ошибке уровня E_WARNING
(ошибка уровня E_NOTICE до PHP 8.0.0),
а результатом будет null.

Почему $foo[bar] неверно?

Всегда заключайте в кавычки строковый литерал в индексе ассоциативного массива.
К примеру, пишите $foo['bar'], а не
$foo[bar]. Но почему? Часто в старых скриптах можно встретить
следующий синтаксис:

Это неверно, хотя и работает. Причина в том, что этот код содержит неопределённую
константу (bar), а не строку ('bar' — обратите внимание
на кавычки). Это работает, потому что PHP автоматически преобразует
«голую строку» (не заключённую в кавычки строку,
которая не соответствует ни одному из известных символов языка) в строку
со значением этой «голой строки». Например, если константа с именем bar
не определена, то PHP заменит bar на
строку 'bar' и использует её.

Замечание:

Это не означает, что нужно всегда заключать
ключ в кавычки. Нет необходимости заключать в кавычки константы или переменные, поскольку это
помешает PHP обрабатывать их.


<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Простой массив:
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
echo "nПроверяем $i: n";
echo "Плохо: " . $array['$i'] . "n";
echo "Хорошо: " . $array[$i] . "n";
echo "Плохо: {$array['$i']}n";
echo "Хорошо: {$array[$i]}n";
}
?>



Результат выполнения данного примера:

Проверяем 0:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Плохо:
Хорошо: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Плохо:
Хорошо: 1

Проверяем 1:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Плохо:
Хорошо: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Плохо:
Хорошо: 2

Дополнительные примеры, демонстрирующие этот факт:

Если вы переведёте error_reporting
в режим отображения ошибок уровня
E_NOTICE (например, такой как
E_ALL), вы сразу увидите эти ошибки. По
умолчанию
error_reporting установлена их не отображать.

Как указано в разделе синтаксис,
внутри квадратных скобок (‘[‘
и ‘]‘) должно быть выражение. Это означает, что можно писать вот так:

Это пример использования возвращаемого функцией значения
в качестве индекса массива. PHP известны также и константы:

Обратите внимание, что E_ERROR — это такой же
верный идентификатор, как и bar в первом примере.
Но последний пример по сути эквивалентен такой записи:

поскольку E_ERROR соответствует 1 и т.д.

Результат выполнения данного примера:

array (
  '' . "" . 'A' . "" . 'B' => NULL,
  '' . "" . '*' . "" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

Результат выполнения данного примера:

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

Пример #9 Простая распаковка массива

Пример #10 Распаковка массива с дублирующим ключом


<?php
// это
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // ключом будет 0
);$b = array('a', 'b', 'c');// . . .полностью соответствует
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // ключом будет 0$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';// после выполнения этого кода, $a будет массивом
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), а $b будет
// array(0 => 'a', 1 => 'b', 2 => 'c'), или просто array('a', 'b', 'c').
?>



Пример #11 Использование array()

Пример #12 Коллекция

Результат выполнения данного примера:

Вам нравится red?
Вам нравится blue?
Вам нравится green?
Вам нравится yellow?

Пример #13 Изменение элемента в цикле

Результат выполнения данного примера:

Array
(
    [0] => RED
    [1] => BLUE
    [2] => GREEN
    [3] => YELLOW
)

Пример #14 Индекс, начинающийся с единицы

Результат выполнения данного примера:

Array
(
    [1] => 'Январь'
    [2] => 'Февраль'
    [3] => 'Март'
)

Пример #15 Заполнение массива

Пример #16 Сортировка массива

Пример #17 Рекурсивные и многомерные массивы


<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 изменился,
// $arr1 всё ещё array(2, 3)$arr3 = &$arr1;
$arr3[] = 4; // теперь $arr1 и $arr3 одинаковы
?>




I think your first, main example is needlessly confusing, very confusing to newbies:


Since PHP 7.1, the string will not be converted to array automatically.


"If you convert a NULL value to an array, you get an empty array."


Note that array value buckets are reference-safe, even through serialization.


Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:


--- quote ---
Note:
Both square brackets and curly braces can be used interchangeably for accessing array elements
--- quote end ---


Regarding the previous comment, beware of the fact that reference to the last value of the array remains stored in $value after the foreach:


to know the depth (dimension) of a ARRAY, you can use this:


//array keys are always integer and string data type and array values are all data type
//type casting and overwriting(data type of array key)
//----------------------------------------------------
$arr = array(
1=>"a",//int(1)
"3"=>"b",//int(3)
"08"=>"c",//string(2)"08"
"80"=>"d",//int(80)
"0"=>"e",//int(0)
"Hellow"=>"f",//string(6)"Hellow"
"10Hellow"=>"h",//string(8)"10Hellow"
1.5=>"j",//int(1.5)
"1.5"=>"k",//string(3)"1.5"
0.0=>"l",//int(0)
false=>"m",//int(false)
true=>"n",//int(true)
"true"=>"o",//string(4)"true"
"false"=>"p",//string(5)"false"
null=>"q",//string(0)""
NULL=>"r",//string(0)"" note null and NULL are same
"NULL"=>"s",//string(4)"NULL" ,,,In last element of multiline array,comma is better to used.
);
//check the data type name of key
foreach ($arr as $key => $value) {
var_dump($key);
echo "<br>";
}


[Editor's note: You can achieve what you're looking for by referencing $single, rather than copying it by value in your foreach statement. See http://php.net/foreach for more details.]


Function unset can delete array's element by reference only when you specify source array. See example:
<?php
$array = [1, 2, 3, 4, 5];
foreach ($array as $k => &$v){
    if ($k >= 3){
        unset($v);
    }
}
echo count($array); // 5
?>
In this case unset delete only reference, however original array didn't change.


Used to creating arrays like this in Perl?


When creating arrays , if we have an element with the same value as another element from the same array, we would expect PHP instead of creating new zval container to increase the refcount and point the duplicate symbol to the same zval. This is true except for value type integer.
Example:


// Before php 5.4
$array = array(1,2,3);


There is another kind of array (php>=  5.3.0) produced by


"Additionally the following key casts will occur: Floats are also cast to ints, which means that the fractional part will be truncated."


In array(key=>value) construct key is also an expression.
This works fine:
  $a = array(
    1     =>0,
    1+1   =>1,
    $k    =>2,
    $x.'4'=>3
  );



Wrappers for (array), returns array with normalize keys (without prefix):
<?php
function to_array_recursive($value): array
{
        if (! is_object($value)) {
                return (array) $value;
        }
        $class = get_class($value);
        $arr = [];
        foreact ((array)  $value as $key => $val) {
                $key = str_replace(["*", "{$class}"], '', $key);
                $arr[$key] = is_object($val) ? to_array_recursive($val) : $val;
        }
        return $arr;
}

__construct($isParent = true)
    {
        if ($isParent) {
            $this->var2 = new self(! $isParent);
        }
    }
}$obj = new Test();
var_dump((array) $obj, to_array_recursive($obj));
?>




It is true that "array assignment always involves value copying", but the copy is a "lazy copy". This means that the data of the two variables occupy the same memory as long as no array element changes.


Note that objects of classes extending ArrayObject SPL class are treated as arrays, and not as objects when converting to array.