php：从数组中删除元素


PHP: Delete an element from an array

有没有一种简单的方法可以使用php从数组中删除元素，这样foreach ($array)就不再包含该元素了？

我原以为把它设置到null就可以了，但显然不起作用。

相关讨论

删除数组元素有不同的方法，其中一些方法对某些特定任务比其他方法更有用。

删除一个数组元素

如果只想删除一个数组元素，可以使用\unset()或\array_splice()。

另外，如果您有值并且不知道删除元素的键，那么可以使用\array_search()获取键。

\unset()法

注意，当使用\unset()时，数组键不会更改/重新索引。如果要重新索引键，可以在\unset()之后使用\array_values()，它将从0开始将所有键转换为数字枚举键。

代码

1
2
3
4
5
6
7
<?php

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

?>

产量

1
2
3
4
[
    [0] => a
    [2] => c
]

\array_splice()法

如果使用\array_splice()键，键将自动重新索引，但关联键不会改变，而不是\array_values()键将所有键转换为数字键。

另外，\array_splice()需要偏移量，而不是键！作为第二个参数。

代码

1
2
3
4
5
6
7
<?php

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

?>

产量

1
2
3
4
[
    [0] => a
    [1] => c
]

array_splice()与\unset()相同，通过引用获取数组，这意味着您不想将这些函数的返回值赋回数组。

删除多个数组元素

如果要删除多个数组元素并且不想多次调用\unset()或\array_splice()，则可以使用函数\array_diff()或\array_diff_key()，具体取决于您是否知道要删除的元素的值或键。

\array_diff()法

如果您知道要删除的数组元素的值，那么可以使用\array_diff()。和以前的\unset()一样，它不会更改/重新索引数组的键。

代码

1
2
3
4
5
6
7
<?php

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

?>

产量

1
2
3
[
    [1] => b
]

\array_diff_key()法

如果您知道要删除的元素的键，那么您需要使用\array_diff_key()。在这里，必须确保将键作为第二个参数中的键传递，而不是作为值传递。否则，您必须使用\array_flip()翻转数组。而且这里的钥匙不会改变/重新索引。

代码

1
2
3
4
5
6
<?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
2
3
[
    [1] => b
]

如果要使用\unset()或\array_splice()删除具有相同值的多个元素，也可以使用\array_keys()获取特定值的所有键，然后删除所有元素。

相关讨论

需要注意的是，unset()将保持索引不变，这是使用字符串索引(array as hashtable)时所期望的，但在处理整数索引数组时会非常令人惊讶：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$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()。另一种选择是在unset()之后使用array_values()：

1
2
3
4
5
6
7
8
9
10
11
12
13
$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)
} */
相关讨论

1
2
3
4
5
6
7
  // 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);

这是上面代码的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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()：

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

输出

1
2
3
4
5
6
7
8
Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)
相关讨论

1
2
3
4
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
相关讨论

1
unset($array[$index]);

如果您有一个数字索引数组，其中所有值都是唯一的(或者它们不是唯一的，但您希望删除某个特定值的所有实例)，则只需使用array_diff()删除匹配的元素，如下所示：

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

例如：

1
2
3
4
5
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) ."
";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

显示以下内容：

1
2
4
3

在本例中，值为"charles"的元素将被移除，可以通过size of()调用进行验证，该调用报告初始数组的大小为4，移除后为3。

另外，对于命名元素：

1
unset($array["elementName"]);
相关讨论

销毁数组的单个元素

unset()

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

输出将是：

1
2
3
4
5
6
7
8
9
10
array(4) {
  [0]=>
  string(1)"A"
  [1]=>
  string(1)"B"
  [3]=>
  string(1)"D"
  [4]=>
  string(1)"E"
}

如果需要重新索引数组：

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

然后输出为：

1
2
3
4
5
6
7
8
9
10
array(4) {
  [0]=>
  string(1)"A"
  [1]=>
  string(1)"B"
  [2]=>
  string(1)"D"
  [3]=>
  string(1)"E"
}

将元素从数组末尾弹出-返回已删除元素的值

mixed array_pop(array &$array)

1
2
3
4
$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

输出将是

1
2
3
4
5
6
7
Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

从数组中移除第一个元素(红色)，-返回移除元素的值

mixed array_shift ( array &$array )

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

输出将是：

1
2
3
4
5
6
Array
(
    [b] => green
    [c] => blue
)
First Color: red
相关讨论

1
2
3
4
5
6
7
<?php
    $stack = array("fruit1","fruit2","fruit3","fruit4");
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

输出：

1
2
3
4
5
6
7
8
Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1
相关讨论

为了避免进行搜索，可以与array_diff一起玩：

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

在这种情况下，不必搜索/使用密钥。

unset()销毁指定的变量。

函数内部的unset()的行为可能因您试图破坏的变量类型而异。

如果一个全局变量在函数内部是unset()，那么只破坏局部变量。调用环境中的变量将保留与调用unset()之前相同的值。

1
2
3
4
5
6
7
8
9
10
11
<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

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

以上代码的答案将是bar。

对于unset()，函数内部的全局变量：

1
2
3
4
5
6
7
8
9
<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

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

如果您必须删除一个数组中的多个值，而该数组中的条目是对象或结构化数据，那么最好选择[array_filter][1]。那些从回调函数返回true的条目将被保留。

1
2
3
4
5
6
7
8
9
$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：

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

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

数字数组

对于数字数组，使用array_splice：

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

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

注释

对数字数组使用unset不会产生错误，但会使索引混乱：

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

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

如果需要从关联数组中删除多个元素，可以使用array diff_key()(此处与array_flip()一起使用)：

1
2
3
4
5
6
7
8
9
10
11
12
13
$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);

输出：

1
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
相关讨论

1
2
3
4
5
6
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

我只想说我有一个特殊的对象，它有可变的属性(它基本上是映射一个表，我正在更改表中的列，所以对象中反映表的属性也会有所不同)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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数组内容，以反映新的属性。

假设您有以下数组：

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

要删除storage，请执行以下操作：

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

你得到：

1
2
3
4
Array
(
    [user_id] => 193
)
相关讨论

遵循默认功能：

i)

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

unset($Array[2]);

二)

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

array_pop($Array);

iii)

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

array_splice($Array,1,2);

四)

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

array_shift($Array);

解决：

  • 要删除一个元素，请使用unset()：
    • 1
    2
    unset($array[3]);
    unset($array['foo']);
  • 要删除多个非连续元素，还可以使用unset()：
    • 1
    2
    unset($array[3], $array[5]);
    unset($array['foo'], $array['bar']);
  • 要删除多个连续元素，请使用array_splice()：
    • 1
    array_splice($array, $offset, $length);

    进一步解释：

    使用这些函数可以从PHP中删除对这些元素的所有引用。如果要在数组中保留键，但值为空，请将空字符串赋给元素：

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

    除了语法之外，使用unset()和将""分配给元素之间还有逻辑上的区别。第一个说This doesn't exist anymore,，第二个说This still exists, but its value is the empty string.

    如果您处理的是数字，指定0可能是更好的选择。因此，如果一家公司停止生产XL1000型链轮，它将更新其库存：

    1
    unset($products['XL1000']);

    但是，如果它暂时用完了XL1000链轮，但计划在本周晚些时候从工厂接收新的装运，这会更好：

    1
    $products['XL1000'] = 0;

    如果取消设置()元素，PHP将调整数组，以便循环仍能正常工作。它不会压缩数组来填充缺失的孔。这就是我们所说的所有数组都是关联的，即使它们看起来是数字。下面是一个例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    // 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()：

    1
    $animals = array_values($animals);

    或者，array_splice()自动重新索引数组以避免留下孔：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // 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()。

    unset()数组中的多个分段元素

    虽然这里多次提到unset()，但还没有提到unset()接受多个变量，使得在一次操作中可以轻松地从数组中删除多个不相邻的元素：

    1
    2
    3
    4
    5
    // 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()会稍微容易一些)。

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

    相反，unset()可以在foreach循环中动态使用：

    1
    2
    3
    4
    5
    6
    7
    $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。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    $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 ];

    显然，同样的做法也适用于文本字符串：

    1
    2
    3
    4
    5
    6
    7
    8
    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' ]
    1
    2
    3
    4
    <?php
        $array = array("your array");
        $array = array_diff($array, ["element you want to delete"]);
    ?>

    在变量$array中创建数组，然后在我放置"要删除的元素"的位置放置类似"a"的内容。如果你想删除多个项目，那么："A"，"B"。

    基于键移除数组元素：

    使用下面的unset功能：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    $a = array(
           'salam',
           '10',
           1
    );

    unset($a[1]);

    print_r($a);

    /*

        Output:

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

    */

    基于值移除数组元素：

    使用array_search函数获取元素键，并使用上述方法删除数组元素，如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    $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
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    <?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);
    ?>

    产量

    1
    2
    3
    4
    5
    6
     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 )

    使用以下代码：

    1
    2
    3
    $arr = array('orange', 'banana', 'apple', 'raspberry');
    $result = array_pop($arr);
    print_r($result);
    相关讨论

    两种删除数组第一个项的方法，保持索引的顺序，如果不知道第一个项的键名，也可以删除。

    解1

    1
    2
    3
    4
    // 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

    1
    2
    3
    4
    5
    6
    // 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]);

    对于此示例数据：

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

    您必须获得以下结果：

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

    对于关联数组，使用非整数键：

    简单地说，unset($array[$key])是可行的。

    对于具有整数键的数组，如果要维护键：

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

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

  • array_splice($array, 2, 1);

    • 这可能有帮助…

    1
    2
    3
    4
    5
    6
    <?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);
    ?>

    结果将是：

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

    使用array_search获取密钥，如果找到，则使用unset将其移除：

    1
    2
    3
    if (($key = array_search('word', $array)) !== false) {
        unset($array[$key]);
    }
    相关讨论

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

    unset不会改变指数，但array_splice会：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    $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 )

    您只需使用unset()删除一个数组。

    记住，数组必须在foreach函数之后取消设置。

    执行此任务有两种方法：unset()和array_splice()。

    我们假设两个数组：

    1
    2
    3
    $array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');

    $array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');

    带unStand()

    1
    2
    3
    4
    syntax - unset(array_element)

    unset($array_1['a']); // Any valid key
    unset($array_2[0]); // Any valid index
    • 删除数组元素后，数组索引不会更改

    带数组拼接(

    1
    2
    3
    4
    syntax - array_splice(array, index, length)

    array_splice($array_1, 1, 1); // Remove one element from $array_1 from index 1
    array_splice($array_2, 3, 1); // Remove one element from $array_2 from index 3
    • 从数组中删除元素后，所有数组元素都将重新建立索引。

    我们可以通过引用修改变量内容，使用foreach：

    1
    2
    3
    4
    5
    <?php
        // Remove all elements in the array
        foreach ($array as &$arr) {
            $arr = null;
        }
    相关讨论

    对于那些在PHP中寻找Ruby的hash#delete等价物的人：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <?php
        function array_delete(&$array, $key) {
            if (!isset($array[$key])) {
                return null;
            }

            $value = $array[$key];
            unset($array[$key]);
            return $value;
        }

    这不仅将从数组中删除元素，而且还将返回存储在该键中的值，以便以非线性方式使用数组。

    相关讨论

    可以使用array_pop方法删除数组的最后一个元素：

    1
    2
    3
    4
    5
    6
    7
    <?php
        $a = array("one","two","Three");
        array_pop($a);
        print_r($a);
    ?>
    The out put will be
    Array ( [0] => one[1] => two)
    相关讨论