Verification: a143cc29221c9be0

Php array как удалить элемент

Как удалить элемент массива в PHP?

Если вы знаете ключ, то удаление сводится к вызову функции unset().

$a = array('a','b','c');

unset($a[1]); //удалим элемент с ключем - 1

print_r($a);

//увидем на экране : Array ( [0] => a [2] => c )

?>

Как удалить первый элемент массива в PHP?

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

$stack = array(3 => 'a', 5 => 'b', 'third element' => 'c');

$elm = array_shift($stack);

print_r($stack);

//увидим на экране : Array ( [0] => b [third element] => c )

?>

В итоге, первый элемент удален, а элемент 5 => ‘b’, попадает под перенумерацию. Элементы со строковыми ключами перенумерацией не затрагиваются.

Как в PHP удалить последний элемент массива?

Похожим образом удаляется последний элемент из массива. В PHP для этого послужит функция array_pop().

$stack = array(3 => 'a', 5 => 'b', 'third element' => 'c');

$elm = array_pop($stack);

print_r($stack);

//увидим на экране : Array ( [3] => a [5] => b )

?>

Последний элемент массива удален, перенумерация оставшихся элементов не производится.

Как удалить из массива пустые элементы в PHP?

Разберемся с понятием пустой элемент. Под «пустыми» элементами можно понимать разные скалярные и не скалярные значения. Наиболее полно определение «пустого значения» определяет результат работы функции empty(). Она возвращает true для пустого элемента (не только скалярного). В этом можно убедиться на следующем примере.

$stack = array(3 => 'a', 5 => 'b', '3rd' => 'c', array(), null, false, 0, '', '0', '00');

foreach ($stack as $k => $v)

    if (empty($v)) unset($stack[$k]);

print_r($stack);

//увидим на экране : Array ( [3] => a [5] => b [3rd] => c [12] => 00 )  

?>

Т.е. мы в цикле проверяем каждый элемент массива функцией empty(), и удаляем пустые. Обратите внимание, что строковый скаляр ‘0’ — тоже считается пустым элементом. А вот ’00’ — уже не является пустым.

Если проверка массива по-элементно кажется вам не оптимальной, то можно воспользоваться функций сравнения массивов — array_diff(), где перечислить все элементы, которые мы считаем «нулевыми».

$stack = array(3 => 'a', 5 => 'b', '3rd' => 'c', array(), null, false, 0, '', '0', '00', ' ');

$stack = array_diff($stack, array(array(), null, false, 0, '', '0', '00', ' '));

print_r($stack);

//увидим на экране : Array ( [3] => a [5] => b [3rd] => c )  

?>

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

30 ответов


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

если вы хотите удалить только один элемент массива, вы можете использовать unset() или альтернатива array_splice().

также, если у вас есть значение и не знаете ключ для удаления элемента, вы можете использовать array_search() получить ключ.

unset() метод

обратите внимание, что при использовании unset() ключи массива не изменятся/reindex. Если вы хотите переиндексировать ключи вы можете использовать array_values() после unset() который преобразует все ключи в числовые перечисляемые ключи, начиная с 0.

код

 "a", 1 => "b", 2 => "c");
    unset($array[1]);
               //↑ Key which you want to delete

?>

выход

Array (
    [0] => a
    [2] => c
)

array_splice() метод

если вы используете array_splice() ключи будут автоматически переиндексируется, но ассоциативные ключи не будут меняться в отличие от array_values() который преобразует все ключи в числовые ключи.

и array_splice() требуется смещение, а не ключ! в качестве второго параметра.

код

 "a", 1 => "b", 2 => "c");
    array_splice($array, 1, 1);
                       //↑ Offset which you want to delete

?>

выход

Array (
    [0] => a
    [1] => c
)

array_splice() же unset() принять массив по ссылке, это означает, что вы не хотите присвоить возвращаемые значения этих функций в массив.

если вы хотите удалить несколько элементов массива и не хочу называть unset() или array_splice() несколько раз, вы можете использовать функции array_diff() или array_diff_key() в зависимости от того, знаете ли Вы значения или ключи элементов, которые вы хотите удалить.

array_diff() метод

если вы знаете значения элементов массива, которые хотите удалить, вы можете использовать array_diff(). Как и раньше с unset() это не изменится/reindex ключи от массива.

код

 "a", 1 => "b", 2 => "c");
    $array = array_diff($array, ["a", "c"]);
                              //└────────┘→ Array values which you want to delete

?>

выход

Array (
    [1] => b
)

array_diff_key() метод

если вы знаете ключи элементов, которые вы хотите удалить, затем вы хотите использовать array_diff_key(). Здесь вы должны убедиться, что передаете ключи как ключи во втором параметре, а не как значения. В противном случае вам нужно перевернуть массив с помощью array_flip(). А также здесь ключи не будут изменить / переиндексировать.

код

 "a", 1 => "b", 2 => "c");
    $array = array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                   //↑           ↑ Array keys which you want to delete
?>

выход

Array (
    [1] => b
)

также, если вы хотите использовать unset() или array_splice() для удаления нескольких элементов с одинаковым значением можно использовать array_keys() чтобы получить все ключи для определенного значения, а затем удалить все элементы.


следует отметить, что unset() сохранит индексы нетронутыми, чего и следовало ожидать при использовании строковых индексов (массив в качестве хэш-таблицы), но может быть довольно удивительно при работе с целочисленными индексированными массивами:

$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [3]=>
  int(3)
} */

$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

так array_splice() может использоваться, если вы хотите нормализовать целочисленные ключи. Другой вариант-использовать array_values() после unset():

$array = array(0, 1, 2, 3);

unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

1306

автор: Stefan Gehrig


  // our initial array  
   $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");  
  print_r($arr);

  // remove the elements who's values are yellow or red  
   $arr = array_diff($arr, array("yellow", "red"));
  print_r($arr);  

это вывод из кода выше:

Array
(
    [0] => blue
    [1] => green
    [2] => red
    [3] => yellow
    [4] => green
    [5] => orange
    [6] => yellow
    [7] => indigo
    [8] => red
)

Array
(
    [0] => blue
    [1] => green
    [4] => green
    [5] => orange
    [7] => indigo
)

теперь array_values () красиво переиндексирует числовой массив, но удалит все ключевые строки из массива и заменит их числами. Если вам нужно сохранить имена ключей (строки) или переиндексировать массив, если все ключи числовые, используйте array_merge ():

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

выходы

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

$key = array_search($needle,$array);
if($key!==false){
    unset($array[$key]);
}


Если у вас есть численно индексированный массив, где все значения уникальны (или они не уникальны, но вы хотите удалить все экземпляры определенного значения), вы можете просто использовать array_diff () для удаления соответствующего элемента, например:

$my_array = array_diff($my_array, array('Value_to_remove'));

например:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

это отображает следующее:

4
3

в этом примере элемент со значением 'Charles' удаляется, что может быть проверено вызовами sizeof (), которые сообщают размер 4 для исходный массив, и 3 после удаления.


также для именованного элемента:

unset($array["elementName"]);

50

автор: DefenestrationDay


уничтожить один элемент массива

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

выход будет:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

Если вам нужно повторно индексировать массив:

$array1 = array_values($array1);
var_dump($array1);

тогда выход будет:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Pop элемент с конца массива - возвращает значение удаленного элемента

mixed array_pop(array &$array)

$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array

выход будь

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

удалить первый элемент (красный) из массива, - возвращает значение удаленного элемента

mixed array_shift ( array &$array )

$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);

выход будет:

Array
(
    [b] => green
    [c] => blue
)
First Color: red

выход:

Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1

23

автор: Saurabh Chandra Patel


чтобы избежать поиска, можно поиграть с array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

в этом случае не нужно искать/использовать ключ.

21

автор: Mugoma J. Okomba


unset() уничтожает указанные переменные.

поведение unset() внутри функции может варьироваться в зависимости от типа переменной, которую вы пытаетесь уничтожить.

если глобализованная переменная unset() внутри функции уничтожается только локальная переменная. Переменная в вызывающей среде сохранит то же значение, что и раньше unset() называлась.

ответ вышеуказанного кода будет бар

до unset() глобальная переменная внутри функции


Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными,[array_filter][1] это ваш лучший ставку. Те записи, которые возвращают true из функции обратного вызова будут сохранены.

$array = [
    ['x'=>1,'y'=>2,'z'=>3], 
    ['x'=>2,'y'=>4,'z'=>6], 
    ['x'=>3,'y'=>6,'z'=>9]
];

$results = array_filter($array, function($value) {
    return $value['x'] > 2; 
}); //=> [['x'=>3,'y'=>6,z=>'9']]

ассоциативные массивы

для ассоциативных массивов, использовать unset :

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT : array('a' => 1, 'c' => 3)

числовые массивы

для числовых массивов, использовать array_splice :

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT : array(0 => 1, 1 => 3)

Примечание

используя unset для числовых массивов не приведет к ошибке, но это испортит ваши индексы:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT : array(0 => 1, 2 => 3)

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать array_diff_key () (здесь используется с array_flip ()):

$my_array = array(
  "key1" => "value 1",
  "key2" => "value 2",
  "key3" => "value 3",
  "key4" => "value 4",
  "key5" => "value 5",
);

$to_remove = array("key2", "key4");

$result = array_diff_key($my_array, array_flip($to_remove));

print_r($result);

выход:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

11

автор: GigolNet Guigolachvili


Я просто хотел сказать, что у меня был определенный объект, который имел переменные атрибуты (это было в основном отображение таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также будут отличаться

class obj {
    protected $fields = array('field1','field2');
    protected $field1 = array();
    protected $field2 = array();
    protected loadfields(){} 
    // This will load the $field1 and $field2 with rows of data for the column they describe
    protected function clearFields($num){
        foreach($fields as $field) {
            unset($this->$field[$num]); 
            // This did not work the line below worked
            unset($this->{$field}[$num]); // You have to resolve $field first using {}
        }
    }
}

цель $fields было просто так, что мне не нужно смотреть везде в коде, когда они меняются, я просто смотрю в начале класса и меняю список атрибутов и $fields содержимое массива для отражения новых атрибутов.

Мне потребовалось некоторое время, чтобы понять это. Надеюсь, это может кому-то помочь.


следуйте функциям по умолчанию

i)

$Array = array("test1","test2","test3","test3");

unset($Array[2]);

ii)

$Array = array("test1","test2","test3","test3");

array_pop($Array);

iii)

$Array = array("test1","test2","test3","test3");

array_splice($Array,1,2);

iv)

$Array = array("test1","test2","test3","test3");

array_shift($Array);

Предположим, у вас есть такой массив:

Array
(
    [user_id] => 193
    [storage] => 5
)

удалить storage, do:

unset($attributes['storage']);
$attributes = array_filter($attributes);

а также вы получаете:

Array
(
    [user_id] => 193
)

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result= array_pop($arr);
print_r($result);

создайте свой массив в переменной $array, а затем, где я поставил "элемент, который вы хотите удалить", вы поместите что-то вроде:"a". И если вы хотите удалить несколько, то: "a", "b".

4

автор: Joshua Charles Pickwell


unset () несколько фрагментированных элементов из массива

хотя unset() упоминалось здесь несколько раз, еще не упоминалось, что unset () принимает несколько переменных, что упрощает удаление нескольких несмежных элементов из массива за одну операцию:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

unset () динамически

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

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

вместо этого unset () можно использовать динамически в цикле foreach:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

удалите ключи массива, скопировав массив

есть еще одна практика, о которой еще предстоит упомянуть. Иногда самый простой способ избавиться от определенных ключей массива-просто скопировать $array1 в $array2.

$array1 = range(1,10);
foreach ($array1 as $v) {
    // Remove all even integers from the array
    if( $v % 2 ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];

очевидно, что такая же практика применяется к текстовым строкам:

$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
    // Remove all strings beginning with underscore
    if( strpos($v,'_')===false ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 'foo', 'baz' ]

4

автор: Kristoffer Bohmann


решения:

  1. удалить один элемент, используйте unset ():
unset($array[3]);
unset($array['foo']);
  1. чтобы удалить несколько несмежных элементов, также используйте unset ():
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. чтобы удалить несколько смежных элементов, используйте array_splice ():
array_splice($array, $offset, $length);

далее объяснение:

использование этих функций удаляет все ссылки на эти элементы из PHP. Если вы хотите сохранить ключ в массиве, но с пустым значением, присвоить пустую строку к элементу:

$array[3] = $array['foo'] = '';

помимо синтаксиса, есть логическая разница между использованием unset () и присвоение " элементу. Первый говорит:This doesn't exist anymore, в то время как второй говорит This still exists, but its value is the empty string.

если вы имеете дело с числами, присвоение 0 может быть лучшая альтернатива. Таким образом, если компания остановила производство звездочки модели XL1000, она обновит свой инвентарь с помощью:

unset($products['XL1000']);

однако, если у него временно закончились звездочки XL1000, но он планировал получить новую партию с завода позже на этой неделе, это лучше:

$products['XL1000'] = 0;

если вы unset () элемент, PHP настраивает массив так, чтобы цикл все еще работал правильно. Он не компактирует массив, чтобы заполнить недостающие отверстия. Этот это то, что мы имеем в виду, когда говорим, что все массивы ассоциативны, даже когда они кажутся числовыми. Вот пример:

// create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1];  // prints 'bee'
print $animals[2];  // prints 'cat'
count($animals);    // returns 6

// unset( )
unset($animals[1]); // removes element $animals[1] = 'bee'
print $animals[1];  // prints '' and throws an E_NOTICE error
print $animals[2];  // still prints 'cat'
count($animals);    // returns 5, even though $array[5] is 'fox'

// add new element
$animals[ ] = 'gnu'; // add new element (not Unix)
print $animals[1];  // prints '', still empty
print $animals[6];  // prints 'gnu', this is where 'gnu' ended up
count($animals);    // returns 6 

// assign ''
$animals[2] = '';   // zero out value
print $animals[2];  // prints ''
count($animals);    // returns 6, count does not decrease

чтобы сжать массив в плотно заполненный числовой массив, используйте array_values ():

$animals = array_values($animals);

кроме того, array_splice () автоматически оленей массивы, чтобы избежать оставляя отверстия:

// create a "numeric" array
    $animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
    array_splice($animals, 2, 2);
    print_r($animals);
    Array
    (
        [0] => ant
        [1] => bee
        [2] => elk
        [3] => fox
    )

это полезно, если вы используете массив в очереди и хотите, чтобы удалить элементы из очереди в то же время позволяя случайный доступ. Чтобы безопасно удалить первый или последний элемент из массива, используйте array_shift () и array_pop (), соответственно.


"value 1","key2"=>"value 2","key3"=>"value 3");

print_r($my_array);
if(array_key_exists("key1",$my_array)){  
unset($my_array['key1']);
print_r($my_array);
}else{
echo "Key does not exist";
}
?>

"value 1","key2"=>"value 2","key3"=>"value 3");
print_r($my_array);
$new_array=array_slice($my_array,1); 
print_r($new_array);
?>


 ";
//To remove first array element to length
//starts from first and remove two element 
$my_array = array("key1"=>"value 1","key2"=>"value 2","key3"=>"value 3");
print_r($my_array);
$new_array=array_slice($my_array,1,2); 
print_r($new_array);
?>

выход

 Array ( [key1] => value 1 [key2] => value 2 [key3] => 
 value 3 ) Array (    [key2] => value 2 [key3] => value 3 ) 
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 ) 
 Array ( [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 ) 
 Array ( [key2] => value 2 [key3] => value 3 ) 

2

автор: UMAR FAROOQUE KHAN


удалить элемент массива по ключу:

использовать unset функции как ниже:

$a = array(
    'salam',
    '10',
    1
);

unset( $a[1] );

print_r( $a );

/*

Output:

Array
(
    [0] => salam
    [2] => 1
)

*/

удалить элемент массива на основе значения:

использовать array_search функция для получения ключа элемента и использования выше, чтобы удалить элемент массива, как показано ниже:

$a = array(
    'salam',
    '10',
    1
);

$key = array_search( 10, $a );

if( $key !== false ) {
    unset( $a[ $key ] );
}

print_r( $a );

/*

Output:

Array
(
    [0] => salam
    [2] => 1
)

*/

для ассоциативных массивов с целочисленными ключами:

просто unset($array[$key]) будет работать.

для массивов, имеющих целочисленные ключи, и если вы хотите сохранить ваши ключи:

  1. $array = [ 'mango', 'red', 'orange', 'grapes'];

unset($array[2]); $array = array_values($array);

  1. array_splice($array, 2, 1);

Это может помочь...

"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("a"=>"purple","b"=>"orange");
    array_splice($a1,0,2,$a2);
    print_r($a1);
    ?>

результат будет:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

при удалении элемента из массива в PHP хорошей функцией является функция unset. Вот пример его использования:

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

вывод функции var_dump будет следующим:

array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }

Вы можете просто использовать unset() удалить массив.

помните, что массив должен быть сброшен после


unset не изменяет индекс, но array_splice делает

$arrayName = array( '1' => 'somevalue',
                        '2' => 'somevalue1',
                        '3' => 'somevalue3',
                        500 => 'somevalue500',
                             );


    echo $arrayName['500']; 
    //somevalue500
    array_splice($arrayName, 1,2);

    print_r( $arrayName );
    //Array ( [0] => somevalue [1] => somevalue500 )



    $arrayName = array( '1' => 'somevalue',
                        '2' => 'somevalue1',
                        '3' => 'somevalue3',
                        500 => 'somevalue500',
                             );


    echo $arrayName['500']; 
    //somevalue500
    unset($arrayName[1]);

    print_r( $arrayName );
    //Array ( [0] => somevalue [1] => somevalue500 )

$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // here is key to be delete
echo '
'; array_values($x); var_dump($x);

автор: Wakar Ahmad Khan


ассоциативные массивы

для ассоциативных массивов, использовать unset :

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT : array('a' => 1, 'c' => 3)

числовые массивы

для числовых массивов, использовать array_splice :

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT : array(0 => 1, 1 => 3)

Примечание

используя unset для числовых массивов не приведет к ошибке, но это испортит ваши индексы:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT : array(0 => 1, 2 => 3)

unset () несколько фрагментированных элементов из массива

хотя unset() упоминалось здесь несколько раз, еще не упоминалось, что unset () принимает несколько переменных, что упрощает удаление нескольких несмежных элементов из массива за одну операцию:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

unset () динамически

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

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

вместо этого unset () можно использовать динамически в цикле foreach:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

Задача

Необходимо удалить один или более элементов из массива.

Решение

Для удаления одного элемента используйте функцию unset():

unset($array[3]);
unset($array['foo']);

Для удаления нескольких непоследовательных элементов применяется функция unset():

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

Для удаления нескольких последовательных элементов используйте функцию array_splice():

array_splice($array, $offset, $length);

Удаление элемента в массиве по его ключу

Если известен ключ элемента, то задача очень проста. Функция unset() позволяет удалить элемент массива или любую переменную (так же будет очищена задействованная под переменную память компьютера).

Например, имеем массив:

$myArr = array(1,2,3,4,5);

Для удаления элемента со значением "3" используем код:

unset($myArr[2]);

Обратите внимание, что указывается не значение (3), а ключ элемента (2), начинающийся, в данном случае с 0. Так, если нужно удалить первый элемент массива, то указываем нулевой элемент:

unset($myArr[0]);

Так же стоит учитывать, что после наших двух удалений, массив теперь содержит три элемента:

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

Все ключи оставшихся элементов сохраняются. Соответственно, если теперь нужно будет удалить первый элемент, то указывать надо будет в качестве ключа единицу. Поэтому, а так же, потому что мы не всегда знаем номер элемента в массиве, а лишь его значения такой вариант может не подходить.

Удаление элемента массива по его значению

Если ключ элемента не известен, а известно только значение массива, то придется перебрать все элементы массива циклом и удалить искомый. Например, удаляем элемент со значением "3":

$myArr = array(1,2,3,4,5);
foreach($myArr as $key => $item){
if ($item == 3){
unset($myArr[$key]);
}
}

Обратите внимание, что проверяется в условии значение массива, доступное в цикле в переменной $item, а при удалении, указывается ключ элемента (переменная $key).

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