array_splice

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

array_splice — 移除陣列的一部分並以其他內容取代

說明

array_splice(
    陣列 &$array,
    整數 $offset,
    ?整數 $length = null,
    混合類型 (mixed) $replacement = []
): 陣列 (array)

從 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` 現在可以為 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 年前

當嘗試將關聯式陣列拼接(splice)到另一個陣列時，`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',
);

// 將 lemon 和 lime 替換為 apple
array_splice_assoc($fruit, 'lemon', 'grape', array('apple' => 'red'));

// 將 cherry 替換為 strawberry
array_splice_assoc($fruit, 'cherry', 1, array('strawberry' => 'red'));
?>

備註：我尚未測試負的偏移量和長度。

向上

向下

StanE ¶

9 年前

array_splice() 不會保留數字鍵。由「weikard at gmx dot de」發布的函數也不會這樣做，因為 array_merge() 也不會保留數字鍵。

請改用以下函數

<?php
函式 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

// 更多資訊請參考 danielecentamore dot com

// $input (陣列) - 包含元素的陣列
// $index (整數) - 您需要移動的元素的索引

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 的值為 array("red", "blue", "green", "yellow")

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

?>

向上

向下

charette dot s at gmail ¶

14 年前

如果想附加 null 值，請將它們包在一個陣列中

<?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 
函式 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
函式 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);
/**
 * 陣列(1) {
 * [1]=>
 * 字串(1) "a"
 * }
 * 陣列(2) {
 * [2]=>
 * 字串(1) "b"
 * [26]=>
 * 字串(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 作為替換時，這可能會導致非預期的行為。」

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
/**
 * first variation
 *
 * $input is input array
 * $start is index of slice begin
 * $end is index of slice end, if this is null, $replacement will be inserted (in the same way as original array_Slice())
 *indexes of $replacement are preserved in both examples
 */
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);
 // if $end not found, exit
 if($end===false)
 return false;
 // if $end is before $start, exit
 if($end<$start)
 return false;
 // index to length
 $end-=$start-1;
 }

 // optional arguments
 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;
}

/**
 * second variation
 *
 * $input is input array
 * $start is index of slice begin
 * $length is length of slice, what will be replaced, if is zero, $replacement will be inserted (in the same way as original 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;

 // optional arguments
 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 年前

致 kokos@lac.lviv.ua

關於程式碼沒有按照您的預期運作，您說得對。

然而，沒有檢查您所指出的插入情況並不是一個錯誤。我沒有添加程式碼來處理這種情況，因為在無序的關聯式陣列中，這種新增索引的鍵值大致上是未定義的。換句話說，如果您的陣列是關聯式的而不是自動索引的，您很可能很在意您的鍵值，並希望明確地設定它們。

向上

向下

匿名 ¶

22 年前

請注意，array_splice() 的第二個參數是偏移量 (OFFSET) 而不是索引 (INDEX)。


假設您想要
$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」。我不確定這算不算是一個 bug，或者只是 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 
類別 A() 
{ 
 私有 $a; 
 私有 $b; 
 公開 函式 __construct() 
 { 
 $this->a = "foo"; 
 $this->b = "bar"; 
 } 
} 
 
$array = 陣列(); 
array_splice($array, 0, 0, new A()); 
print_r($array); 
?> 

輸出：


陣列：陣列
{

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



解決方案：強制將物件轉換為陣列。


<?php 
array_splice($array, 0, 0, 陣列(new 物件())); 
?> 

來源：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

匿名 ¶

10 年前

<?php
函式 array_slice2( $array, $offset, $length = 0 )
{
 若( $offset < 0 )
 $offset = sizeof( $array ) + $offset;

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

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

 回傳 $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 "記憶體使用量 <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);
}

?>

＋新增註釋