array_splice

(PHP 4, PHP 5, PHP 7, PHP 8)

array_splice — 移除数组的一部分并用其他内容替换它

描述

array_splice(
    数组 &$array,
    整数 $offset,
    ?整数 $length = null,
    混合 $replacement = []
): 数组

从 array 数组中移除由 offset 和 length 指定的元素，并用 replacement 数组的元素替换它们（如果提供）。

注意:
array 中的数字键不会保留。

注意: 如果 replacement 不是数组，它将被类型转换为数组（即 (array) $replacement）。当使用对象或 null replacement 时，这可能会导致意外的行为。

参数

array

输入数组。

offset

如果 offset 为正数，则移除部分的起点位于 array 数组的开头处的该偏移量。

如果 offset 为负数，则移除部分的起点位于 array 数组的结尾处的该偏移量。

length

如果省略 length，则移除从 offset 到数组结尾的所有内容。

如果指定 length 并且为正数，则将移除该数量的元素。

如果指定 length 并且为负数，则移除部分的结尾将位于数组结尾处的该数量的元素。

如果指定 length 并且为零，则不会移除任何元素。

提示

当也指定了 replacement 时，要移除从 offset 到数组结尾的所有内容，请使用 count($input) 作为 length。

replacement

如果指定了 replacement 数组，则移除的元素将被此数组的元素替换。

如果 offset 和 length 使得没有移除任何内容，则 replacement 数组中的元素将插入 offset 指定的位置。

注意:
replacement 数组中的键不会保留。

如果 replacement 只有一个元素，则无需在它周围放置 array() 或方括号，除非元素本身是数组、对象或 null。

返回值

返回一个包含提取元素的数组。

变更日志

版本	描述
8.0.0	`length` 现在可以为空。

示例

示例 #1 array_splice() 示例

<?php
$input = array("red", "green", "blue", "yellow");
array_splice($input, 2);
var_dump($input);

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, -1);
var_dump($input);

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, count($input), "orange");
var_dump($input);

$input = array("red", "green", "blue", "yellow");
array_splice($input, -1, 1, array("black", "maroon"));
var_dump($input);
?>

上面的示例将输出

array(2) {
  [0]=>
  string(3) "red"
  [1]=>
  string(5) "green"
}
array(2) {
  [0]=>
  string(3) "red"
  [1]=>
  string(6) "yellow"
}
array(2) {
  [0]=>
  string(3) "red"
  [1]=>
  string(6) "orange"
}
array(5) {
  [0]=>
  string(3) "red"
  [1]=>
  string(5) "green"
  [2]=>
  string(4) "blue"
  [3]=>
  string(5) "black"
  [4]=>
  string(6) "maroon"
}

示例 #2 等同于各种 array_splice() 示例的语句

以下语句是等同的

<?php

// 将两个元素追加到 $input
array_push($input, $x, $y);
array_splice($input, count($input), 0, array($x, $y));

// 移除 $input 的最后一个元素
array_pop($input);
array_splice($input, -1);

// 移除 $input 的第一个元素
array_shift($input);
array_splice($input, 0, 1);

// 在 $input 的开头插入一个元素
array_unshift($input, $x, $y);
array_splice($input, 0, 0, array($x, $y));

// 替换 $input 中索引为 $x 的值
$input[$x] = $y; // 对于键等于偏移量的数组
array_splice($input, $x, 1, $y);

?>

参见

array_merge() - 合并一个或多个数组
array_slice() - 提取数组的一部分
unset() - 取消设置给定变量

改善此页面

了解如何改进此页面 • 提交拉取请求 • 报告错误

＋添加注释

用户贡献的注释 39 个注释

上移

下移

mrsohailkhan at gmail dot com ¶

12 年前

array_splice，将数组拆分为两个数组。返回的数组实际上是第二个参数，而使用的数组（例如这里的 $input）包含第一个参数（例如）


<?php 
$input = array("red", "green", "blue", "yellow"); 
print_r(array_splice($input, 3)); // Array ( [0] => yellow ) 
print_r($input); //Array ( [0] => red [1] => green [2] => blue ) 
?> 

如果要替换任何数组值，可以像这样简单地进行操作：


首先搜索要替换的数组索引


<?php $index = array_search('green', $input);// index = 1 ?> 

然后根据定义使用它


<?php 
array_splice($input, $index, 1, array('mygreeen')); //Array ( [0] => red [1] => mygreeen [2] => blue [3] => yellow ) 
?> 

所以这里 green 被替换为 mygreen。


这里 array_splice 中的 1 代表要替换的项目数量。所以这里从索引 '1' 开始，只替换了一个项目，即 'green'

上移

下移

royanee at yahoo dot com ¶

11 年前

当尝试将一个关联数组拼接进另一个数组时，array_splice 缺少两个关键要素
- 用于识别偏移量的字符串键
- 能够在替换数组中保留键

这主要在您想要用另一个项目替换数组中的一个项目时有用，但希望保持数组的排序，而无需逐个重建数组。

<?php
function array_splice_assoc(&$input, $offset, $length, $replacement) {
 $replacement = (array) $replacement;
 $key_indices = array_flip(array_keys($input));
 if (isset($input[$offset]) && is_string($offset)) {
 $offset = $key_indices[$offset];
 }
 if (isset($input[$length]) && is_string($length)) {
 $length = $key_indices[$length] - $offset;
 }

 $input = array_slice($input, 0, $offset, TRUE)
 + $replacement
 + array_slice($input, $offset + $length, NULL, TRUE);
}

$fruit = array(
 'orange' => 'orange',
 'lemon' => 'yellow',
 'lime' => 'green',
 'grape' => 'purple',
 'cherry' => 'red',
);

// Replace lemon and lime with apple
array_splice_assoc($fruit, 'lemon', 'grape', array('apple' => 'red'));

// Replace cherry with strawberry
array_splice_assoc($fruit, 'cherry', 1, array('strawberry' => 'red'));
?>

注意：我还没有用负偏移量和长度测试过这个。

上移

下移

StanE ¶

8 年前

array_splice() 不会保留数字键。 “weikard at gmx dot de” 发布的函数也不会这样做，因为 array_merge() 也不会保留数字键。

请改用以下函数

<?php
function arrayInsert($array, $position, $insertArray)
{
 $ret = [];

 if ($position == count($array)) {
 $ret = $array + $insertArray;
 }
 else {
 $i = 0;
 foreach ($array as $key => $value) {
 if ($position == $i++) {
 $ret += $insertArray;
 }

 $ret[$key] = $value;
 }
 }

 return $ret;
}
?>

示例
<?php
$a = [
 295 => "Hello",
 58 => "world",
];

$a = arrayInsert($a, 1, [123 => "little"]);

/*
Output:
Array
(
 [295] => Hello
 [123] => little
 [58] => world
)
*/
?>

它保留了数字键。注意，该函数没有使用对原始数组的引用，而是返回一个新的数组（我认为没有绝对的理由说明通过 PHP 脚本代码修改数组时使用引用会提高性能）。

上移

下移

daniele centamore ¶

15 年前

只有一些使用 array_splice 移动元素的有用函数。

<?php

// info at danielecentamore dot com

// $input (Array) - 包含元素的数组
// $index (int) - 需要移动的元素的索引

function moveUp($input,$index) {
 $new_array = $input;
 
 if((count($new_array)>$index) && ($index>0)){
 array_splice($new_array, $index-1, 0, $input[$index]);
 array_splice($new_array, $index+1, 1);
 } 

 return $new_array;
}

function moveDown($input,$index) {
 $new_array = $input;
 
 if(count($new_array)>$index) {
 array_splice($new_array, $index+2, 0, $input[$index]);
 array_splice($new_array, $index, 1);
 } 
 
 return $new_array;
 } 

$input = array("red", "green", "blue", "yellow");

$newinput = moveUp($input, 2);
// $newinput is array("red", "blue", "green", "yellow")

$input = moveDown($newinput, 1);
// $input is array("red", "green", "blue", "yellow")

?>

上移

下移

charette dot s at gmail ¶

14 年前

如果你想追加空值，请将它们包装在数组中

<?php

 $a = array('Hey', 'hey', 'my', 'my');
 array_splice($a, 1, 0, null);
 print_r($a);

?>
Array
(
[0] => Hey
[1] => hey
[2] => my
[3] => my
)

<?php

 $b = array('Hey', 'hey', 'my', 'my');
 array_splice($b, 1, 0, array(null));
 print_r($b);

?>
Array
(
[0] => Hey
    [1] => 
[2] => hey
[3] => my
[4] => my
)

上移

下移

gideon at i6developments dot com ¶

20 年前

array_splice 动态更新数组中条目的总数。例如，我有一个需要将值插入到从后往前数组中每第 4 个条目的情况。问题是，当它添加第一个值时，因为总数量是动态更新的，它只会添加在第 3 个之后，然后是第 2 个，以此类推。我找到的解决方法是跟踪完成的插入次数并动态地考虑它们。

代码
<?php
 $modarray = array_reverse($mili);
 $trig=1;
 foreach($modarray as $rubber => $glue) {
 if($rubber!="<BR>") {
 $i++;
 $b++;
 if ($i==4) {
 $trig++;
 if($trig<=2) {
 array_splice($modarray,$b,0,"<BR>");
 }elseif($trig>=3){
 array_splice($modarray,$b+($trig-2),0,"<BR>");
 } 
 $i=0;
 };
 };
 }; 
 $fixarray = array_reverse($modarray);

?>

上移

下移

weikard at gmx dot de ¶

18 年前

你不能使用 array_splice 插入带有你自己的键的数组。array_splice 总是会使用键“0”插入它。


<?php 
// [DATA] 
$test_array = array ( 
 row1 => array (col1 => 'foobar!', col2 => 'foobar!'), 
 row2 => array (col1 => 'foobar!', col2 => 'foobar!'), 
 row3 => array (col1 => 'foobar!', col2 => 'foobar!') 
); 
 
// [ACTION] 
array_splice ($test_array, 2, 0, array ('rowX' => array ('colX' => 'foobar2'))); 
echo '<pre>'; print_r ($test_array); echo '</pre>'; 
?> 

[结果]


Array (
[row1] => Array (
[col1] => foobar!
[col2] => foobar!
        )



[row2] => Array (
[col1] => foobar!
[col2] => foobar!
        )



[0] => Array (
[colX] => foobar2
        )



[row3] => Array (
[col1] => foobar!
[col2] => foobar!
        )

)



但你可以使用以下函数


function array_insert (&$array, $position, $insert_array) {
$first_array = array_splice ($array, 0, $position);
$array = array_merge ($first_array, $insert_array, $array);
}



<?php 
// [ACTION] 
 
array_insert ($test_array, 2, array ('rowX' => array ('colX' => 'foobar2'))); 
echo '<pre>'; print_r ($test_array); echo '</pre>'; 
?> 

[结果]


Array (
[row1] => Array (
[col1] => foobar!
[col2] => foobar!
        )



[row2] => Array (
[col1] => foobar!
[col2] => foobar!
        )



[rowX] => Array (
[colX] => foobar2
        )



[row3] => Array (
[col1] => foobar!
[col2] => foobar!
        )

)



[注意]


位置“0”将插入数组的第一个位置（如 array_shift）。如果你尝试的位置高于数组的长度，你将像函数 array_push 一样将它添加到数组中。

上移

下移

plintus at smtp dot ru ¶

21 年前

键安全


<?php 
function array_kslice ($array, $offset, $length = 0) { 
$k = array_slice (array_keys ($array), $offset, $length); 
$v = array_slice (array_values ($array), $offset, $length); 
for ($i = 0; $i < count ($k); $i ++) $r[$k[$i]] = $v[$i]; 
return $r; 
} 
?> 

类似于此。希望你喜欢它比上面的版本更好:)

上移

下移

gilberg_vrn ¶

8 年前

array_splice 保留键

<?php
function array_splice_preserve_keys(&$array, $from, $length = null) {
 $result = array_slice($array, $from, $length, true);
 $array = array_slice($array, $from + $length, null, true);
 
 return $result;
}
?>

示例

<?php
$array = [
 1 => 'a',
 2 => 'b',
 26 => 'z'
];

var_dump(array_splice_preserve_keys($array, 0, 1), $array);
/**
 * array(1) {
 * [1]=>
 * string(1) "a"
 * }
 * array(2) {
 * [2]=>
 * string(1) "b"
 * [26]=>
 * string(1) "z"
 * }
 */
?>

上移

下移

guillaume dot lacourt at gmail dot com ¶

9 年前

当你使用内部指针函数遍历数组时使用 array_splice 会重置数组，例如

<?php
end($arrOfData);
$last = key($arrOfData);
reset($arrOfData);
while (($data = current($arrOfData))) {
 if ($last === key($arrOfData)) {
 array_splice($arrOfData, $last, 1);
 // current($arrOfData) => first value of $arrOfData
 }
}

上移

下移

csaba at alum dot mit dot edu ¶

19 年前

追加数组
如果你有一个数组 $a2，你想将它的值追加到一个数组 $a1 中，那么你可以使用四种方法，下面按时间递增的顺序列出它们。最后两种方法所花的时间明显比前两种方法多。最令人惊讶的是，使用 & 会造成时间上的损耗。


<?php 
foreach ($a2 as $elem) $a1[]=$elem; 
foreach ($a2 as &$elem) $a1[]=$elem; 
array_splice ($a1, count($a1), 0, $a2); 
$a1 = array_merge($a1, $a2); 
?> 

来自维也纳的 Csaba Gabor

上移

下移

thom ¶

10 年前

也许这对其他人有帮助：我试图使用以下部分去除数组的最后一部分，大体如下所示

<?php array_splice($array, $offset); ?>

现在在我的代码中可能出现 <?php $offset === 0 ?>，在这种情况下，数组将按原样返回，而不是像您预期的那样返回一个空数组，因为所有内容都被剥离了。显然，无论如何，“剥离所有内容”并不是真正有用，但我被艰难地提醒了这一点，希望这能为某些人节省一些时间。

上移

下移

kbrown at horizon dot sk dot ca ¶

21 年前

[ 编辑注：如果您不关心索引是否连续编号（例如关联数组），那么 unset($ar[$ind]); 将实现与以下代码相同的目的，而无需使用 splice/splice/merge。如果连续编号是一个问题（例如索引数组），您仍然可以使用以下方法节省时间：unset($ar[$ind]); $ar = array_values($ar); ]


从数组中删除元素


这更好用 - 速度快得多


<?php 
$ar = array("einstein", "bert", "colin", "descartes", "renoir"); 
$a = array_slice($ar, 0, $ind); 
$b = array_slice($ar, $ind + 1); 
$ar = array_merge($a, $b); 
?>

上移

下移

news_yodpeirs at thoftware dot de ¶

14 年前

使用 NULL 作为替换进行拼接也可能会导致意外行为。将 NULL 转换为数组会得到一个空数组（因为“(array)NULL”等于“array()”）。这意味着，没有创建具有值 NULL 的元素，而是没有创建新的元素（就像没有指定替换一样）。

如果您希望拼接创建具有值 NULL 的新元素，则必须使用“array(NULL)”而不是 NULL。

如果您仔细阅读解释，您应该预期会发生这种情况，但是，正如对象被视为替换的特殊情况一样，NULL 也应该如此。

替换的解释最好写成：“如果替换只是一个元素，则无需将 array() 放在它周围，除非该元素本身是一个数组、一个对象或 NULL。”

注释最好写成：“如果替换不是数组，它将被转换为数组（即 (array) $parameter）。在使用对象或 NULL 替换时，这可能会导致意外行为。”

jmtc

上移

下移

jrhardytwothousandtwo at yahoo dot com ¶

22 年前

这里提到了使用 array_splice 将元素插入数组中，但解释得不太好。我希望这个例子能帮助其他人找到我花了几天时间才研究出来的问题。


<?php 
$original_array = array(1,2,3,4,5); 
$insert_into_key_position = 3; 
$item_to_insert = "blue"; 
 
$returned = array_splice($original_array, $insert_into_key_position, 0, $item_to_insert); 
 
// $original_array 将显示： 
 
// 1,2,3,blue,4,5 
?> 

请记住，您正在告诉数组将元素插入 KEY 位置。因此，元素从键 0 开始，依此类推 0=>1、1=>2、2=>3、3=>blue、4=>4、5=>5。就这样，您已经插入了。我无法说这对于命名键或多维数组是否有用。但是它确实适用于一维数组。


$returned 应该是一个空数组，因为没有返回任何内容。如果您正在执行替换，则这将有意义。

上移

下移

pauljamescampbell at gmail dot com ¶

16 年前

这是我对保留关联数组键的数组切片方法的看法。


<?php 
/** 
 * 保留关联键的数组切片函数 
 * 
 * @function associativeArraySlice 
 * 
 * @param Array $array 要切片的数组 
 * @param Integer $start 
 * @param Integer $end 
 * 
 * @return Array 
 */ 
function associativeArraySlice($array, $start, $end) { 
 // 方法参数限制 
 if($start < 0) $start = 0; 
 if($end > count($array)) $end = count($array); 
 
 // 处理变量 
 $new = Array(); 
 $i = 0; 
 
 // 循环 
 foreach($array as $key => $value) { 
 if($i >= $start && $i < $end) { 
 $new[$key] = $value; 
 } 
 $i++; 
 } 
 return($new); 
} 
?>

上移

下移

randomdestination at gmail dot com ¶

19 年前

要根据关联数组的键将其拆分，请使用此函数

<?php
function &array_split(&$in) {
 $keys = func_get_args();
 array_shift($keys);
 
 $out = array();
 foreach($keys as $key) {
 if(isset($in[$key]))
 $out[$key] = $in[$key];
 else
 $out[$key] = null;
 unset($in[$key]);
 }
 
 return $out;
}
?>

示例
<?php
$testin = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4);
$testout =& array_split($testin, 'a', 'b', 'c');

print_r($testin);
print_r($testout);
?>

将打印

数组
(
[d] => 4
)
数组
(
[a] => 1
[b] => 2
[c] => 3
)

希望这对任何人都有所帮助！

上移

下移

ahigerd at stratitec dot com ¶

17 年前

关于 array_merge 的评论提到了 array_splice 比 array_merge 更快地插入值。这可能是真的，但是，如果您的目标是重新索引数字数组，则 array_values() 是最佳选择。在 100,000 次迭代循环中执行以下函数，我得到了以下时间：($b 是一个 3 元素数组)

array_splice($b, count($b)) => 0.410652
$b = array_splice($b, 0) => 0.272513
array_splice($b, 3) => 0.26529
$b = array_merge($b) => 0.233582
$b = array_values($b) => 0.151298

上移

下移

mip at ycn dot com ¶

17 年前

曾经想知道 array_splice 对您的引用做了什么，然后尝试一下这个小程序，看看输出。

<?php

$a = "a";
$b = "b";
$c = "c";
$d = "d";
$arr = array();
$arr[] =& $a;
$arr[] =& $b;
$arr[] =& $c;
array_splice($arr,1,0,array($d));
$sec_arr = array();
$sec_arr[] =& $d;
array_splice($arr,1,0,$sec_arr);

$arr[0] = "test"; // 应该是 $a
$arr[3] = "test2"; // 应该是 $b
$arr[1] = "this be d?"; // 应该是 $d
$arr[2] = "or this be d?"; // 应该是 $d
var_dump($arr);
var_dump($a);
var_dump($b);
var_dump($d);
?>

输出将是 (PHP 4.3.3)

array(5) {
  [0]=>
&string(4) "test"
  [1]=>
&string(10) "this be d?"
  [2]=>
string(13) "or this be d?"
  [3]=>
&string(5) "test2"
  [4]=>
&string(1) "c"
}
string(4) "test"
string(5) "test2"
string(10) "this be d?"

所以 array_splice 是引用安全的，但您必须小心替换数组的生成。

玩得开心，欢呼！

上移

下移

Paul ¶

18 年前

至少在 PHP 4.3.10 中，似乎作为替换数组的一部分插入的元素是通过引用插入的（也就是说，就像使用 =& 而不是 = 赋值操作一样）。因此，如果您的替换数组包含引用到您也可以通过其他变量名称访问的变量的元素，那么最终数组中的元素也将是这种情况。

特别是，这意味着对对象数组使用 array_splice() 是安全的，因为您不会创建对象的副本（这在 PHP 4 中很容易做到）。

上移

下移

匿名 ¶

3 年前

以下
        
$input = [[5=>"richard=red"], [15=>"york=yellow"], [25=>"gave=green"], [30=>"battle=blue"], [35=>"in=indigo"], [40=>"vain=violet"]];
array_splice($input, 2, 0, [[10=>"of=orange"]]);
var_dump($input);

给出以下结果

array (size=7)
  0 => 
array (size=1)
5 => string 'richard=red' (length=11)
  1 => 
array (size=1)
15 => string 'york=yellow' (length=11)
  2 => 
array (size=1)
10 => string 'of=orange' (length=9)
  3 => 
array (size=1)
25 => string 'gave=green' (length=10)
  4 => 
array (size=1)
30 => string 'battle=blue' (length=11)
  5 => 
array (size=1)
35 => string 'in=indigo' (length=9)
  6 => 
array (size=1)
40 => string 'vain=violet' (length=11)

上移

下移

dead dot screamer at seznam dot cz ¶

15 年前

我需要 <?php array_Splice()?> 函数，它使用数组键而不是顺序（偏移量和长度），因为它是关联数组，这是结果

<?php
/**
 * 第一种变体
 *
 * $input 是输入数组
 * $start 是切片开始的索引
 * $end 是切片结束的索引，如果为空，则插入 $replacement（与原始 array_Slice() 相同）
 * $replacement 的索引在两个示例中都保留
 */
function array_KSplice1(&$input, $start, $end=null, $replacement=null)
{
 $keys=array_Keys($input);
 $values=array_Values($input);
 if($replacement!==null)
 {
 $replacement=(array)$replacement;
 $rKeys=array_Keys($replacement);
 $rValues=array_Values($replacement);
 }

 $start=array_Search($start,$keys,true);
 if($start===false)
 return false;
 if($end!==null)
 {
 $end=array_Search($end,$keys,true);
 // 如果 $end 未找到，退出
 if($end===false)
 return false;
 // 如果 $end 在 $start 之前，退出
 if($end<$start)
 return false;
 // 索引到长度
 $end-=$start-1;
 }

 // 可选参数
 if($replacement!==null)
 {
 array_Splice($keys,$start,$end,$rKeys);
 array_Splice($values,$start,$end,$rValues);
 }
 else
 {
 array_Splice($keys,$start,$end);
 array_Splice($values,$start,$end);
 }

 $input=array_Combine($keys,$values);

 return $input;
}

/**
 * 第二种变体
 *
 * $input 是输入数组
 * $start 是切片开始的索引
 * $length 是切片的长度，它将被替换，如果为零，则插入 $replacement（与原始 array_Slice() 相同）
 */
function array_KSplice2(&$input, $start, $length=0, $replacement=null)
{
 $keys=array_Keys($input);
 $values=array_Values($input);
 if($replacement!==null)
 {
 $replacement=(array)$replacement;
 $rKeys=array_Keys($replacement);
 $rValues=array_Values($replacement);
 }

 $start=array_Search($start,$keys,true);
 if($start===false)
 return false;

 // 可选参数
 if($replacement!==null)
 {
 array_Splice($keys,$start,$length,$rKeys);
 array_Splice($values,$start,$length,$rValues);
 }
 else
 {
 array_Splice($keys,$start,$length);
 array_Splice($values,$start,$length);
 }

 $input=array_Combine($keys,$values);

 return $input;
}

$array=range(1,10);
var_Dump(array_KSplice1($array,3,3,array(100=>101,102,103,104)));

$array=range(1,10);
var_Dump(array_KSplice2($array,3,3,array(100=>101,102,103,104)));

?>

两个示例都输出
array(11) {
  [0]=>
int(1)
  [1]=>
int(2)
  [2]=>
int(3)
  [100]=>
int(101)
  [101]=>
int(102)
  [102]=>
int(103)
  [103]=>
int(104)
  [6]=>
int(7)
  [7]=>
int(8)
  [8]=>
int(9)
  [9]=>
int(10)
}

上移

下移

paule at cs dot tamu dot edu ¶

22 年前

给 [email protected]

关于代码没有按预期执行的观点很好。

然而，您指出的没有检查插入情况的错误并不是一个错误。我没有添加代码来处理这个问题，因为在无序关联数组中，这种添加索引的键基本上是未定义的。换句话说，如果您的数组是关联数组而不是自动索引的，那么您很可能非常在意您的键，并且想要显式地设置它们。

上移

下移

匿名 ¶

22 年前

请注意，array_splice() 的第二个参数是偏移量而不是索引。


假设您想要
$array_of_items = array ('nothing','myitem','hisitem','heritem');
$sid = array_search('myitem',$array_of_items);
echo $sid; /* 打印 1，因为索引元素 1 是 "myitem" */


现在，假设我们要从数组中删除 "myitem"


<?php 
$array_of_items = array_splice($array_of_items,(1+$sid),1); 
?> 

注意您必须在 $sid 变量中添加一个 1 吗？这是因为偏移量项 1 是 "nothing"，并且由于 $sid 当前为 1（"myitem" 的索引），因此我们再添加一个 1 来找出
它的偏移量。


不要这样做
$array_of_items = array_splice($array_of_items,$sid,1);

上移

下移

vitospericolato at gmail dot com ¶

8 年前

要根据数组值从数组中删除元素

<?php
$i_to_remove=array();

foreach($array_to_prune as $i=>$value){
 if(cond_to_delete($value)) $i_to_remove[]=$i;
}
foreach($i_to_remove as $j=>$i)
 array_splice($array_to_prune,$i-$j,1);

?>

上移

下移

Hayley Watson ¶

6 年前

对于在字符串而不是数组上工作的类似函数，请参阅 substr_replace。

上移

下移

antrik ¶

10 年前

在迫切的需求和一些现有笔记的启发下，我想出了这个

/* 类似于 array_splice()，但保留替换数组的键。 */
function array_splice_assoc(&$input, $offset, $length = 0, $replacement = array()) {
$tail = array_splice($input, $offset);
$extracted = array_splice($tail, 0, $length);
$input += $replacement + $tail;
return $extracted;
};

除了保留键之外，它在所有我能想到的情况下，就像普通的 array_splice() 一样。

例如，普通的 array_splice()

$input = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' =>6);
print_r(array_splice($input, -4, 3, array('foo1' => 'bar', 'foo2' => 'baz')));
print_r($input);

将给出

数组
(
[c] => 3
[d] => 4
[e] => 5
)
数组
(
[a] => 1
[b] => 2
[0] => bar
[1] => baz
[f] => 6
)

但是使用 array_splice_assoc()

$input = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' =>6);
print_r(array_splice_assoc($input, -4, 3, array('foo1' => 'bar', 'foo2' => 'baz')));
print_r($input);

我们得到

数组
(
[c] => 3
[d] => 4
[e] => 5
)
数组
(
[a] => 1
[b] => 2
[foo1] => bar
[foo2] => baz
[f] => 6
)

一个典型的用例是替换由特定键标识的元素，我们可以通过以下方式实现

$input = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' =>6);
array_splice_assoc($input, array_search('d', array_keys($input)), 1, array('foo' => 'bar'));
print_r($input);

给我们

数组
(
[a] => 1
[b] => 2
[c] => 3
[foo] => bar
[e] => 5
[f] => 6
)

上移

下移

news_yodpeirs at thoftware dot de ¶

13 年前

有时你可能想将一个数组插入另一个数组，然后继续处理结果数组。array_splice() 不支持这个，因为结果数组不是返回值，而是第一个参数，它通过引用被修改。


因此，您可以使用以下函数，该函数在数组 $src 的位置 $pos 插入数组 $ins。 $rep 可用于 $ins 不仅仅是插入，而是应该替换一些现有元素（要替换的元素数量在 $rep 中给出）。


<?php 
function array_insert($src,$ins,$pos,$rep=0) { 
 array_splice($src,$pos,$rep,$ins); 
 return($src); 
} 
?>

上移

下移

bdjumakov at gmail dot com ¶

17 年前

有人可能会发现这个函数很有用。它只是从数组中获取给定的元素，并将它移动到给定元素之前，放到同一个数组中。

<?php
function array_move($which, $where, $array)
{
 $tmp = array_splice($array, $which, 1);
 array_splice($array, $where, 0, $tmp);
 return $array;
}
?>

上移

下移

paule at cs dot tamu dot edu ¶

22 年前

在阅读了上面的 KoKos 的帖子后，我认为我在他帖子之前发布的代码应该能实现他想要的效果。但是，我最初的帖子忽略了上面文档中关于单个元素替换的小“提示”。


如果将我上面代码中的以下行


<?php 
 if(is_array($replacement)) 
 foreach($replacement as $r_key=>$r_value) 
 $new_array[$r_key]=$r_value; 
?> 

改为


<?php 
 if(is_string($replacement)) 
 $new_array[$key]=$replacement; 
 elseif(is_array($replacement)) 
 foreach($replacement as $r_key=>$r_value) 
 $new_array[$r_key]=$r_value; 
?> 

就能解决问题。


抱歉遗漏了这一点。

上移

下移

kokos at lac dot lviv dot ua ¶

22 年前

从上面的帖子中可能看起来很明显，但花费了我一些时间
脑力才能弄明白…


与本页面上提到的等价性相反
$input[$x] = $y <==> array_splice ($input, $x, 1, $y)
array_splice() 并不总是按预期工作，
即使你只有整数键！


以下代码
$t=array('a','b','c','d','e');
var_dump($t);


<?php 
 unset($t[0],$t[1],$t[3]); 
 $t[0]='f'; 
 var_dump($t); 
 
 array_splice($t,0,1,'g'); 
 var_dump($t); 
?> 

将产生
array(5) {
  [0]=>

string(1) "a"
  [1]=>

string(1) "b"
  [2]=>

string(1) "c"
  [3]=>

string(1) "d"
  [4]=>

string(1) "e"
}

array(3) {
  [2]=>

string(1) "c"
  [4]=>

string(1) "e"
  [0]=>

string(1) "f"
}

array(3) {
  [0]=>

string(1) "g"
  [1]=>

string(1) "e"
  [2]=>

string(1) "f"
}



注意第二次调用 var_dump() 时 $t[0] 的位置。
当然，array_splice() 保持了它，而是改变了 $t[2]。
这是因为它操作的是 _偏移量_，而不是 _索引_。 :)
我认为“等价性说明”应该被认为是有错误的。 ;)))


祝一切顺利。
KoKos。

上移

下移

-1

rolandfoxx at yahoo dot com ¶

20 年前

注意，如果尝试将对象作为替换参数传递给 array_splice，它不会像你预期的那样工作。请考虑以下情况

<?php
//非常简化
class Tree {
 var $childNodes

 function addChild($offset, $node) {
 array_splice($this->childNodes, $offset, 0, $node);
 //...函数的其余部分
 }

}

class Node {
 var $stuff
 ...
}

$tree = new Tree();
// ...使用其他函数设置 2 个节点...
echo (count($tree->childNodes)); //给出 2
$newNode = new Node();
// ...在此处设置节点属性...
$tree->addChild(1, $newNode);
echo(count($tree->childNodes)); //预期为 3？错了！
?>

在这种情况下，数组中添加的项目数量等于新 Node 对象中的属性数量及其值，例如，如果 Node 对象具有 2 个属性，其值为“foo”和“bar”，那么 count($tree->childNodes) 现在将返回 4，其中添加了“foo”和“bar”项。我不确定这是否算作错误，或者仅仅是 PHP 处理对象的方式造成的副产品。

以下是解决此问题的变通方法
function array_insertobj(&$array, $offset, $insert) {
$firstPart = array_slice($array, 0, $offset);
$secondPart = array_slice($array, $offset);
$insertPart = array($insert);
$array = array_merge($firstPart, $insertPart, $secondPart);
}

注意，此函数在 $offset 等于数组中第一个或最后一个索引时没有任何设置。这是因为 array_unshift 和 array_push 在这些情况下运行良好。只有 array_splice 会导致问题。显然，这非常适合具有数字键的数组，在这种情况下你并不关心这些键是什么，但如果你需要，我相信你也可以将其改编为关联数组。

上移

下移

-2

madmax at max-worlds dot net ¶

15 年前

注意：如果 replacement 不是数组，它将被强制转换为数组（即 (array) $parameter）。当使用对象替换时，这可能会导致意外行为。


示例


<?php 
class A() 
{ 
 private $a; 
 private $b; 
 public function __construct() 
 { 
 $this->a = "foo"; 
 $this->b = "bar"; 
 } 
} 
 
$array = array(); 
array_splice($array, 0, 0, new A()); 
print_r($array); 
?> 

输出


Array : Array
{

[0] => foo
[1] => bar
}



解决方法：在对象上强制使用 array()。


<?php 
array_splice($array, 0, 0, array(new Object()); 
?> 

来源：http://bugs.php.net/bug.php?id=44485

上移

下移

-2

tsunaquake DOESNTLIKESPAM @ wp DOT pl ¶

21 年前

可以使用字符串而不是偏移量，例如，如果你想删除条目 $myArray['entry']，你可以这样操作：


<?php 
array_splice($myArray, 'entry', 1); 
?> 

请注意，你也可以使用 unset($myArray['entry'])，但是它不能删除多个条目，也不能替换数组中的任何内容，如果你想这样做的话。

上移

下移

-2

Anonymous ¶

9 年前

<?php
function array_slice2( $array, $offset, $length = 0 )
{
 if( $offset < 0 )
 $offset = sizeof( $array ) + $offset;

 $length = ( !$length ? sizeof( $array ) : ( $length < 0 ? sizeof( $array ) - $length : $length + $offset ) );

 for( $i = $offset; $i < $length; $i++ )
 $tmp[] = $array[$i];

 return $tmp; 
}
?>

上移

下移

-5

strata_ranger at hotmail dot com ¶

15 年前

如果你想要一个类似的函数来拼接字符串，这里有一个粗略的等效函数：

<?php
function str_splice($input, $offset, $length=null, $splice='')
{
 $input = (string)$input;
 $splice = (string)$splice;
 $count = strlen($input);
 
 // 偏移量处理（负值从字符串末尾开始计算）
 if ($offset<0) $offset = $count + $offset;

 // 长度处理（正值从 $offset 开始计算；负值从字符串末尾开始计算；省略则表示字符串末尾）
 if (is_null($length)) $length = $count;
 elseif ($length < 0) $length = $count-$offset+$length;

 // 执行拼接
 return substr($input, 0, $offset) . $splice . substr($input, $offset+$length);
}

$string = "The fox jumped over the lazy dog.";

// 输出 "The quick brown fox jumped over the lazy dog."
echo str_splice($string, 4, 0, "quick brown ");

?>

显然，这并不适合只需要简单搜索和替换的情况。

上移

下移

-4

leingang AT math DOT rutgers DOT edu ¶

22 年前

array_splice 会重置 $input 的内部指针。事实上，许多数组函数都会这样做。程序员要注意!

上移

下移

-3

loushou - life dot 42 at gmail dot com ¶

16 年前

我错误地发布了实际的函数...
这是真正的函数，哈哈

<?php

function q_sort(&$Info, $Index, $Left, $Right)
{
 echo "memory usage <b>".memory_get_usage()."</b><br/>\n";
 $L_hold = $Left;
 $R_hold = $Right;
 $Pivot = $Left;
 $PivotValue = $Info[$Left];
 while ($Left < $Right)
 {
 while (($Info[$Right][$Index] >= $PivotValue[$Index]) && ($Left < $Right))
 $Right--;
 if ($Left != $Right)
 {
 $Info[$Left] = $Info[$Right];
 $Left++;
 }
 while (($Info[$Left][$Index] <= $PivotValue[$Index]) && ($Left < $Right))
 $Left++;
 if ($Left != $Right)
 {
 $Info[$Right] = $Info[$Left];
 $Right--;
 }
 }
 $Info[$Left] = $PivotValue;
 $Pivot = $Left;
 $Left = $L_hold;
 $Right = $R_hold;
 if ($Left < $Pivot)
 q_sort($Info, $Index, $Left, $Pivot-1);
 if ($Right > $Pivot)
 q_sort($Info, $Index, $Pivot+1, $Right);
}

?>

上移

下移

-7

Francis ¶

16 年前

你需要对二维数组中的一个变量进行排序，同时试图保持原有顺序吗？


<?php 
 
function sort_2d_array($array, $position, $order = "ASC"){ 
 if (!is_array($array)) return $array; 
 if (count($array) < 2) return $array; 
 $new = array($array[0]); 
 for ($cnt = 1; $cnt <= count($array) - 1; $cnt++){ 
 $stop = 0; 
 $splice = 0; 
 for ($newcnt = 0; $newcnt <= count($new) - 1; $newcnt++){ 
 if ($stop == 0){ 
 if ($order == "ASC") 
 if ($array[$cnt][$position] < $new[$newcnt][$position]){ 
 $splice = $newcnt; 
 $stop = 1; 
 } // splice position for ASC 
 if ($order == "DESC") 
 if ($array[$cnt][$position] > $new[$newcnt][$position]){ 
 $splice = $newcnt; 
 $stop = 1; 
 } // splice position for DESC 
 } // stop vying for position 
 } // cycle through new array to find position 
 if ($stop == 0){ 
 $new[] = $array[$cnt]; 
 } else { 
 array_splice($new, $splice, 0, array($array[$cnt])); 
 } // splice into new array while keeping somewhat the original order 
 } // cycle through original array 
 return $new; 
} // sort_2d_array 
 
?> 

应用示例：内部搜索引擎
这里，我们尝试通过最近出现次数的排序来查找网站中的“apple”这个词，但首先要查找出现次数。


我们已经通过日期降序对 MySQL 输出进行了排序，并且统计了出现次数，并将这些次数放在一个数组中用于最终查询。


我使用此函数进一步对出现次数进行排序，但大体保持原始 MySQL 排序顺序。


关键
[0] 记录编号
[0] 记录 ID
[1] 源表
[2] 出现次数


  ---------------------------



[0] 

     [0] 24530

[1] 博客
     [2] 1



[1] 

     [0] 24400

[1] 博客
     [2] 1



[2] 

     [0] 24240

[1] 博客
     [2] 4



[3] 

     [0] 243422

[1] 分类信息
     [2] 1



[4] 

     [0] 243100

[1] 分类信息
     [2] 1



运行之后...


<?php 
sort_2d_array($array, 2, "DESC"); 
?> 

我们得到...


[0] 

     [0] 24240

[1] 博客
     [2] 4



[1] 

     [0] 24530

[1] 博客
     [2] 1



[2] 

     [0] 24400

[1] 博客
     [2] 1



[3] 

     [0] 243422

[1] 分类信息
     [2] 1



[4] 

     [0] 243100

[1] 分类信息
     [2] 1



可能对某些人有用...

＋添加注释