foreach ($array)더 이상 해당 요소를 포함하지 않도록 PHP를 사용하여 배열에서 요소를 삭제하는 쉬운 방법이 있습니까?

나는 그것을 설정하면 그렇게 될 null것이라고 생각 했지만 분명히 작동하지 않습니다.

배열 요소를 삭제하는 방법에는 여러 가지가 있으며, 일부는 다른 것보다 특정 작업에 더 유용합니다.

하나의 배열 요소 삭제

하나의 배열 요소 만 삭제하려는 경우 unset()또는 대신 사용할 수 있습니다 \array_splice().

또한 값이 있고 요소를 삭제할 키를 모르는 경우 키 \array_search()를 얻는 데 사용할 수 있습니다 .

unset()

unset()배열 키 를 사용 하면 변경 / 재 인덱싱되지 않습니다. 키를 다시 인덱싱하려면 \array_values()이후에 사용할 수있는 키를 unset()모두 0부터 시작하는 숫자 열거 키로 변환합니다.

암호

<?php

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

?>

산출

[
    [0] => a
    [2] => c
]

\array_splice() 방법

\array_splice()키 를 사용 하면 자동으로 색인이 다시 생성되지만 \array_values()모든 키를 숫자 키로 변환하는 것과 달리 연관 키는 변경되지 않습니다 .

또한 \array_splice()키가 아닌 오프셋이 필요합니다! 두 번째 매개 변수로

암호

<?php

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

?>

산출

[
    [0] => a
    [1] => c
]

array_splice()unset()참조로 배열 을 가져 오는 것과 동일 하며 이는 해당 함수의 반환 값을 배열에 다시 할당하지 않으려는 것을 의미합니다.

여러 배열 요소 삭제

여러 배열 요소를 삭제하고 호출 unset()하거나 \array_splice()여러 번 원하지 않는 경우 함수를 사용 \array_diff()하거나 \array_diff_key()삭제할 요소의 값 또는 키를 알고 있는지 여부에 따라 기능을 사용할 수 있습니다 .

\array_diff() 방법

삭제하려는 배열 요소의 값을 알고 있으면을 사용할 수 있습니다 \array_diff(). 이전과 마찬가지로 unset()배열의 키를 변경하거나 다시 색인화하지 않습니다.

암호

<?php

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

?>

산출

[
    [1] => b
]

\array_diff_key() 방법

삭제하려는 요소의 키를 알고 있으면을 사용하려고합니다 \array_diff_key(). 여기서 키가 값이 아닌 두 번째 매개 변수의 키로 전달되는지 확인해야합니다. 그렇지 않으면 배열을로 뒤집어 야합니다 \array_flip(). 또한 여기서 키는 변경 / 재 인덱싱되지 않습니다.

암호

<?php

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

산출

[
    [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()after를 사용하고 있습니다 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)
} */

  // 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]);
}

unset($array[$index]);

모든 값이 고유 한 숫자 인덱스 배열이 있거나 고유하지 않지만 특정 값의 모든 인스턴스를 제거하려는 경우 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'인 요소는 초기 배열에 대해 크기 4를보고하고 제거 후 3을보고하는 sizeof () 호출로 확인할 수있는대로 제거됩니다.

또한 명명 된 요소의 경우 :

unset($array["elementName"]);

배열의 단일 요소를 파괴

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"
}

배열의 끝에서 요소를 팝 -제거 된 요소의 값을 반환

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

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

산출:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

검색을 피하기 위해 다음을 수행 할 수 있습니다 array_diff.

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

이 경우 키를 검색하거나 사용할 필요가 없습니다.

배열에서 여러 값을 삭제해야하고 해당 배열의 항목이 객체 또는 구조화 된 데이터 인 [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 ) 

unset() 지정된 변수를 삭제합니다.

unset()함수 내부의 동작은 파괴하려는 변수 유형에 따라 달라질 수 있습니다.

전역 변수가 unset()함수 내에 있으면 로컬 변수 만 파괴됩니다. 호출 환경의 변수는 이전 호출과 동일한 값을 유지합니다 unset().

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

위 코드의 대답은 바입니다. 입니다.

에 unset()함수의 전역 변수의 내부 :

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

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

색인이 지정된 경우 :

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

색인이 지정되지 않은 경우 :

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

if경우 때문에 조건이 필요하다 index발견되지 않는, unset()자동으로 우리가 원하지 않는 무엇 인 배열의 첫 번째 요소를 삭제합니다

솔루션 :

1. 하나의 요소를 삭제하려면 unset ()을 사용하십시오 .

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

2. 연속 되지 않은 여러 요소를 삭제하려면 unset ()을 사용하십시오 .

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

3. 연속 된 여러 요소를 삭제하려면 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 a new element
$animals[ ] = 'gnu'; // Add a 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 () 을 사용하십시오.

다음과 같은 배열이 있다고 가정하십시오.

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

를 삭제하려면 다음 storage을 수행하십시오.

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

그리고 당신은 얻을 :

Array
(
    [user_id] => 193
)

변수 속성이있는 특정 객체가 있다고 말하고 싶습니다 (기본적으로 테이블을 매핑하고 테이블의 열을 변경했기 때문에 테이블을 반영하는 객체의 속성도 다양 함).

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 배열 내용을 변경하여 새로운 내용을 반영합니다. 속성.

기본 기능을 따르십시오.

나는)

$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);

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

변수에 배열을 $array만든 다음 '삭제하려는 요소'를 넣은 곳에 "a"와 같은 것을 넣습니다. 그리고 여러 항목을 삭제하려면 "a", "b".

array_search를 사용하여 키를 가져 오면 발견되지 않은 상태로 키를 제거하십시오.

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

배열에서 여러 개의 조각난 요소 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);

대신, foreach 루프에서 unset ()을 동적으로 사용할 수 있습니다.

$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' ]

키를 기준으로 배열 요소를 제거하십시오.

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
        )

*/

인덱스 순서를 유지하면서 첫 번째 항목의 키 이름을 모르는 경우 배열의 첫 번째 항목을 제거하는 두 가지 방법.

해결책 # 1

// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);

해결책 # 2

// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);

이 샘플 데이터의 경우 :

$array = array(10 => "a", 20 => "b", 30 => "c");

이 결과가 있어야합니다.

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

다음 코드를 사용하십시오.

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

<?php
    // If you want to remove a particular array element use this method
    $my_array = array("key1"=>"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";
    }
?>

<?php
    //To remove first array element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1);
    print_r($new_array);
?>


<?php
    echo "<br/>    ";
    // 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 )

정수가 아닌 키가있는 연관 배열의 경우 :

간단히, unset($array[$key]) 하게 작동합니다.

정수 키가 있고 키를 유지하려는 경우 :

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

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

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

이것은 도움이 될 수 있습니다 ...

<?php
    $a1 = array("a"=>"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 )

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

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);