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 到数组末尾的所有内容，请对 length 使用 count($input)。

replacement

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

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

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

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

返回值

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

变更日志

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

示例

示例 #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() - 销毁指定的变量

发现问题了吗？

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

＋添加注释

用户贡献的注释 38 条注释

上移

下移

mrsohailkhan at gmail dot com ¶

13 年前

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 ¶

9 年前

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"]);

/*
输出：
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);

?>
数组
(
[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);

?>
数组
(
[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 ¶

19年前

你不能使用 array_splice 插入带有你自定义键的数组。array_splice 始终会使用键“0”插入。


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

[结果]


数组 (
[row1] => 数组 (
[col1] => foobar!
[col2] => foobar!
        )



[row2] => 数组 (
[col1] => foobar!
[col2] => foobar!
        )



[0] => 数组 (
[colX] => foobar2
        )



[row3] => 数组 (
[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 
// [操作] 
 
array_insert ($test_array, 2, array ('rowX' => array ('colX' => 'foobar2'))); 
echo '<pre>'; print_r ($test_array); echo '</pre>'; 
?> 

[结果]


数组 (
[row1] => 数组 (
[col1] => foobar!
[col2] => foobar!
        )



[row2] => 数组 (
[col1] => foobar!
[col2] => foobar!
        )



[rowX] => 数组 (
[colX] => foobar2
        )



[row3] => 数组 (
[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) => $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`替换时，这可能会导致意外行为。”

仅供参考

上移

下移

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 
?> 

请记住，您告诉数组将元素插入到键位置。因此，元素从键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)

上移

下移

seznam.cz 上的 dead dot screamer ¶

15 年前

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


<?php
/**
 * 第一种变体
 *
 * $input 是输入数组
 * $start 是切片起始索引
 * $end 是切片结束索引，如果为 null，则插入 $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]

关于代码没有按预期执行，您提到的这一点很有道理。

但是，您指出的没有检查插入情况的错误并不是 bug。我没有添加处理该情况的代码，因为在这种未排序的关联数组中，添加索引的键或多或少是未定义的。换句话说，如果您的数组是关联数组而不是自动索引数组，那么您很可能非常关心键，并希望显式设置它们。

上移

下移

匿名 ¶

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 ¶

7 年前

对于在字符串而不是数组上运行的类似函数，请参阅 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() 不支持此操作，因为结果数组不是返回值，而是第一个参数，它通过引用进行更改。


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


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

上移

下移

bdjumakov at gmail dot com ¶

18 年前

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

<?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 ¶

16年前

注意：如果替换不是数组，它将被强制转换为数组（即 (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 ¶

22年前

可以使用字符串代替偏移量，例如，如果要删除条目 $myArray['entry']，则可以像这样简单地执行：


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

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

上移

下移

-2

Anonymous ¶

10年前

<?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

[email protected] ¶

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

[email protected] ¶

22年前

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

上移

下移

-3

loushou - [email protected] ¶

16年前

我发布了错误的函数……
这是真正的函数，哈哈

<?php

function q_sort(&$Info, $Index, $Left, $Right)
{
 echo "内存使用量 <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);
}

?>

＋添加注释