Odstraňte sudé prvky z pole. PHP: odeberte prvek z pole

X[3]: =X[4];

X[4]: =X[5];

X[5]: =X[6];

Všechny prvky od třetího do pátého se tedy musí posunout o jeden doleva - místo i-tého prvku je třeba napsat (i+1)-tý. Blokové schéma algoritmu je na obr. 5.25.

Rýže. 5.25.

Nyní se podívejme na obecnější problém: potřebujeme odstranit m-tý prvek z pole X sestávajícího z n prvků. K tomu stačí napsat (m+1)-tý prvek na místo prvku s číslem m, (m+2)-tý prvek - na místo (m+1)-tého prvku atd. , n-tý prvek - na místě (n–1)-tý. Proces odstranění prvku z pole je znázorněn na Obr. 5.26.

Algoritmus pro odstranění prvku s číslem m z pole X o rozměru n je znázorněn na Obr. 5.27.

Po odstranění prvku 4 A ve skutečnosti posunutí části pole o jeden prvek doleva z pole se změní počet prvků v poli (sníží se o jeden) a změní se index některých prvků. Pokud je prvek odstraněn, nahradí jej další a není třeba se k němu přesouvat (zvýšením indexu o jednu). Další prvek se po odstranění sám přesunul doleva.

Pokud zpracováváte pole, ve kterém jsou některé prvky smazány, pak po smazání prvku nemusíte přecházet na další (sníží se tím počet prvků). Jako příklad zvažte následující problém.

ÚKOL 5.1. Odstraňte negativní prvky z pole.

Algoritmus pro řešení problému je poměrně jednoduchý: projdeme všechny prvky pole, pokud je prvek záporný, odstraníme jej posunutím všech následujících o jeden doleva. Jediné, co stojí za zapamatování, je, že po smazání prvku nemusíte pro následné zpracování přejít na další, ten se sám přesune na místo aktuálního. Blokové schéma řešení úlohy 5.1 je na Obr. 5.28.

Níže je text programu s komentáři.

program support_array; var i, n, j: byte; X: pole [ 1.. 100 ] skutečných;<=n) do {Если очередной элемент массива X[i] отрицателен, то} if x [ i ]<0 then begin {удаляем элемент массива с номером i.} for j:= i to n_1 do x [ j ] : = x [ j + 1 ]; {Уменьшаем размер массива.} {Не надо переходить к следующему элементу массива.} n:=n -1; end else {Если элемент не удалялся, то переходим к следующему элементу массива.} i:= i +1; writeln (’Изменённый массив ’); for i:=1 to n do {Вывод преобразованного массива.} write (X[ i ] : 5: 2, ’ ’); writeln; end.

Rýže. 5.28.

Rýže. 5.29.

Uvažujme jednoduchý úkol: vložte číslo b do pole X(10) , mezi třetí a čtvrtý prvek.

K vyřešení tohoto problému je nutné posunout všechny prvky pole, počínaje čtvrtým, doprava o jeden prvek. Potom budete muset zapsat b (X:=b;) do čtvrtého prvku pole. Ale abyste neztratili sousední hodnotu, musíte nejprve posunout desátý prvek doprava, poté devátý, osmý atd. až na čtvrtý. Blokové schéma vkládacího algoritmu je znázorněno na obr. 5.30.

V obecném případě je blokové schéma vkládání čísla b do pole X(N) mezi prvky očíslované m a m+1 na Obr. 5.31.

Níže je uveden fragment programu, který implementuje tento algoritmus 5 Při deklaraci pole musíte poskytnout dostatečnou velikost pro vložení jednoho prvku. .

var i, n,m: byte;

X: pole [ 1.. 100 ] skutečných; b: skutečný; begin writeln ('N= ');

readln(n); for i:=1 to n do begin write (’X[ ’, i, ’ ]= ’); readln(X[i]); konec; writeln('Pole X'); for i:=1 to n do pište (x [ i ] : 5: 2, ’ ’); writeln; writeln('m='); readln(m); writeln('b='); readln(b); pro i:=n až po m+1 do x [ i +1]:=x [ i ]; x:=b; n:=n+1; writeln('Upravené pole'); for i:=1 až n zapište (X[ i ] : 5: 2, ’ ’); writeln; konec. 5.10 Použití rutin pro práci s poli

Podívejme se, jak můžete předat pole podprogramu. Jak víte (viz kapitola 4), abyste mohli deklarovat proměnné v seznamu formálních parametrů podprogramu, musíte zadat jejich názvy a typy. Typ libovolného parametru v seznamu však může být pouze standardní nebo dříve deklarovaný typ. Proto, abyste mohli předat pole podprogramu, musíte nejprve popsat jeho typ 6 Datový typ pole, deklarace pole viz sekce 2.4.9. Práce s poli je podrobně popsána v této kapitole. a poté deklarujte postup: typ_pole = pole

[index_list]

z

typ;

postup

název_procedury (název_pole: typ_pole);

Například: typ vector=array [ 1.. 10 ] bajtu; matice=pole [ 1.. 3, 1.. 3 ] reálného; procedura proc (A: matice; b: vektor; var x: vektor); Je jasné, že předání řetězce formuláře do podprogramu

název_proměnné: řetězec[délka_řetězce];

což je ve skutečnosti pole 7 typ vector=array [ 1.. 10 ] bajtu; matice=pole [ 1.. 3, 1.. 3 ] reálného; procedura proc (A: matice; b: vektor; var x: vektor); Je jasné, že předání řetězce formuláře do podprogramu

[index_list]

Datový typ "string", deklarace řetězce viz článek 2.4.9

typ;

, by mělo být provedeno podobně:

Pole lze předat podprogramu pomocí konceptu otevřeného pole. Otevřené pole je pole 8 Datový typ "pole", deklarace pole, přístup k poli, viz část 2.4.9., jehož popis uvádí typ prvků, ze kterých se skládá, ale nedefinuje hranice pro změnu indexů:

public_array_name: řada pole... pole

typ;

var pole_1: pole skutečných; pole_2: pole pole znaků; pole_3: pole pole pole bajtů;

Alokace paměti a určení hranic indexu

35 odpovědí

Existují různé způsoby, jak odstranit prvek pole, přičemž některé jsou pro některé konkrétní úkoly užitečnější než jiné.

Odeberte jeden prvek pole

Pokud chcete odstranit pouze jeden prvek z pole, můžete použít \unset() nebo alternativně \array_splice() .

Také pokud máte hodnotu a neznáte klíč k odstranění prvku, můžete klíč získat pomocí \array_search().

metoda \unset().

Vezměte prosím na vědomí, že když použijete \unset(), klíče pole se nezmění/přeindexují. Pokud chcete reindexovat klíče, můžete použít \array_values() po \unset(), které převede všechny klíče na číselné číslované klíče počínaje 0.

$pole = pole(0, 1, 2, 3); unset($array); $pole = pole_values($pole); var_dump($array); /* pole(3) ( => int(0) => int(1) => int(3) ) */

// Naše počáteční pole $arr = array("modrá", "zelená", "červená", "žlutá", "zelená", "oranžová", "žlutá", "indigo", "červená");

print_r($arr);

// Odstraňte prvky, jejichž hodnoty jsou žluté nebo červené $arr = array_diff($arr, array("yellow", "red"));

print_r($arr);

Toto je výstup z kódu výše:

Pole ( => modrá => zelená => červená => žlutá => zelená => oranžová => žlutá => indigová => červená) Pole ( => modrá => zelená => zelená => oranžová => indigová)

Nyní array_values() přeindexuje číselné pole, ale odstraní z pole všechny klíčové řetězce a nahradí je čísly. Pokud potřebujete uložit názvy klíčů (řetězce) nebo reindexovat pole, pokud jsou všechny klíče číselné, použijte array_merge():

$my_array = array_diff($my_array, array("Value_to_remove"));

typ;

$my_array = array("Andy", "Bertha", "Charles", "Diana"); echo sizeof($my_array) . "\n"; $my_array = array_diff($my_array, array("Charles")); echo sizeof($my_array);

Zobrazí se následující:

V tomto příkladu je prvek s hodnotou "Charles" odstraněn, jak lze ověřit pomocí volání sizeof(), které hlásí velikost 4 pro původní pole a 3 po odstranění.

Zničte jeden prvek pole

unset()

$pole1 = pole("A", "B", "C", "D", "E"); unset($array1); // Smazání známé hodnoty indexu(2) z pole var_dump($array1);

Výstupem bude:

Array(4) ( => string(1) "A" => string(1) "B" => string(1) "D" => string(1) "E" )

Pokud potřebujete pole přeindexovat:

$pole1 = pole_values($pole1); var_dump($pole1);

Výstup pak bude:

Array(4) ( => string(1) "A" => string(1) "B" => string(1) "D" => string(1) "E" )

Odstraňte prvek z konce pole- vrátí hodnotu odstraňovaného prvku

smíšené pole_pop(pole &$pole)

$stack = array("pomeranč", "banán", "jablko", "malina"); $posledni_ovoce = array_pop($stack); print_r($stack); print_r("Posledni ovoce:".$posledni_ovoce); // Poslední prvek pole

Bude existovat cesta ven

Array ( => pomeranč => banán => jablko) Poslední ovoce: malina

Odstraňte první prvek (červený) z pole, - vrátí hodnotu odstraňovaného prvku

smíšený array_shift (pole & $array)

$color = array("a" => "červená", "b" => "zelená" , "c" => "modrá"); $first_color = array_shift($color); print_r($barva); print_r("Prvni barva: ".$first_color);

Výstupem bude:

Pole ([b] => zelená [c] => modrá) První barva: červená

unset() zničí zadané proměnné.

Chování unset() uvnitř funkce se může lišit v závislosti na typu proměnné, kterou se pokoušíte zničit.

Pokud je globalizovaná proměnná unset() uvnitř funkce, bude zničena pouze lokální proměnná. Proměnná ve volajícím prostředí si zachová stejnou hodnotu, jakou měla před voláním unset().

Odpověď na výše uvedený kód bude bar.

Chcete-li zrušit nastavení () globální proměnné uvnitř funkce:

Pro použití asociativních polí odstaveno :

$arr = pole("a" => 1, "b" => 2, "c" => 3); unset($arr["b"]); // VÝSLEDEK: array("a" => 1, "c" => 3)

Numerická pole

Pro numerická pole použijte pole_splice :

$arr = pole(1, 2, 3); array_splice($arr, 1, 1); // VÝSLEDEK: pole(0 => 1, 1 => 3)

Poznámka

Pokud potřebujete odstranit více hodnot v poli a položky v tomto poli jsou objekty nebo strukturovaná data, je to vaše nejlepší volba. Záznamy, které vrátí hodnotu true z funkce zpětného volání, budou uloženy.

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

Pokud potřebujete odstranit více prvků z asociativního pole, můžete použít array_diff_key() (zde se používá pole_flip()):

$my_array = array("key1" => "value 1", "key2" => "value 2", "key3" => "value 3", "key4" => "value 4", "key5" => "hodnota 5"); $to_remove = array("klíč2", "klíč4"); $result = array_diff_key($my_array, array_flip($to_remove)); print_r($vysledek);

Pole ( => hodnota 1 => hodnota 3 => hodnota 5)

Řekněme, že máte následující pole:

Pole ( => 193 => 5)

Chcete-li odebrat úložiště, spusťte:

Unset($attributes["úložiště"]); $attributes = array_filter($atributes);

A obdržíte:

Pole ( => 193)

Chtěl bych jen říci, že jsem měl určitý objekt, který měl proměnné atributy (v podstatě zobrazoval tabulku a já jsem měnil sloupce v tabulce, takže atributy v objektu odrážejícím tabulku se také mohly změnit):

Class obj ( protected $fields = array("field1","field2"); protected $field1 = array(); protected $field2 = array(); protected loadfields()() // Toto načte $field1 a $ pole2 s řádky dat pro sloupec, který popisují chráněnou funkci clearFields($num)( foreach($fields as $field) ( unset($this->$field[$num]); // Toto nefungovalo na řádku níže working unset($this->($field)[$num] // Nejprve musíte vyřešit $pole pomocí () ) ));

Celý účel $fields byl jednoduchý, takže když se změní, nemusím hledat nikam v kódu, stačí se podívat na začátek třídy a změnit seznam atributů a obsah pole $pole odrážet nové atributy.

Postupujte podle výchozích funkcí

$Array = array("test1","test2","test3","test3"); unset($Array);

$Array = array("test1","test2","test3","test3"); array_pop($Array);

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

$Array = array("test1","test2","test3","test3"); array_shift($Array);

I když zde bylo unset() několikrát zmíněno, stále stojí za zmínku, že unset() přijímá více proměnných, což usnadňuje odstranění více nesousedících prvků z pole jednou operací:

// Vymazání více nesouvislých prvků z pole $array = [ "foo", "bar", "baz", "quz" ]; unset($pole, $pole); print_r($pole); // Výstup: ["foo", "bar" ]

unset() dynamicky

unset() nepřijímá pole klíčů k odstranění, takže níže uvedený kód selže (ačkoli by bylo o něco jednodušší použít unset() dynamicky).

$pole = rozsah(0.5); $odstranit = ; $array = unset($remove); // FAILS: "neočekávané "nenastaveno"" print_r($array);

Místo toho lze unset() použít dynamicky ve smyčce foreach:

$pole = rozsah(0.5); $odstranit = ; foreach ($remove as $k=>$v) ( unset($array[$v]); ) print_r($array); // Výstup: [ 0, 3, 4, 5 ]

Odstraňte klíče pole zkopírováním pole

Existuje také další praxe, která dosud nebyla zmíněna. Někdy je nejjednodušší způsob, jak se zbavit určitých klíčů pole, jednoduše zkopírovat $array1 do $array2.

$pole1 = rozsah(1,10); foreach ($array1 jako $v) ( // Odebere všechna sudá celá čísla z pole if($v % 2) ( $array2 = $v; ) ) print_r($array2); // Výstup: [ 1, 3, 5, 7, 9 ];

Stejná praxe samozřejmě platí pro textové řetězce:

$array1 = [ "foo", "_bar", "baz" ]; foreach ($array1 jako $v) ( // Odstraňte všechny řetězce začínající podtržítkem if(strpos($v,"_")===false) ( $array2 = $v; ) ) print_r($array2); // Výstup: ["foo", "baz" ]

Řešení:

1. Chcete-li odstranit jeden prvek, použijte unset() :

unset($array); unset($array["foo"]);

1. Chcete-li odstranit více nesousedících prvků, použijte také unset() :

unset($pole, $pole); unset($array["foo"], $array["bar"]);

1. Chcete-li odstranit více sousedních prvků, použijte array_splice() :

array_splice($pole, $posun, $délka);

Další vysvětlení:

$array = $array["foo"] = "";

Kromě syntaxe existuje logický rozdíl mezi použitím unset() a přiřazením prvku. První říká, že Toto již neexistuje, a druhé říká, že Toto stále existuje, ale jeho hodnota je prázdný řetězec.

Pokud se zabýváte čísly, je lepší zvolit 0. Pokud tedy společnost zastaví výrobu řetězového kola Model XL1000, aktualizuje své zásoby:

Unset($products["XL1000"]);

Pokud však byla dočasně mimo řetězová kola XL1000, ale měla být přijata nová dávka z továrny koncem tohoto týdne, je to lepší:

$products["XL1000"] = 0;

$animals = array_values($animals);

Odebrat prvek pole na základě klíče:

Použijte funkci odstavení, jak je uvedeno níže:

$a = array("salam", "10", 1); unset($a); print_r($a); /* Výstup: Array ( => salám => 1) */

Odebrat prvek pole na základě hodnoty:

$a = pole("salam", "10", 1); $key = array_search(10, $a); if($key !== false) ( unset($a[ $key ]); ) print_r($a); /* Výstup: Array ( => salám => 1) */

Vytvořte své pole v proměnné $array a pak tam, kde jsem dal "prvek, který chcete odstranit", vložte něco jako: "a". A pokud jich chcete smazat několik, pak: „a“, „b“.

Pole je jednou z nejužitečnějších a nejčastěji používaných datových struktur v jakémkoli programovacím jazyce. Vědět, jak spravovat pole a jejich prvky, je velmi důležité a užitečné. V tomto článku se podíváme na to, jak můžete odstranit jednotlivé prvky pole v PHP.

Tento úkol lze implementovat různými metodami v závislosti na tom, co víme o odstraňovaném prvku – zda ​​je znám klíč (číslo nebo identifikátor prvku v poli) nebo pouze jeho hodnota.

Odstranění prvku v poli pomocí jeho klíče

Pokud je klíč prvku znám, pak je úkol velmi jednoduchý. Funkce unset() umožňuje smazat prvek pole nebo jakoukoli proměnnou (vymaže se také paměť počítače použitá pro proměnnou).

Máme například pole:

$myArr = pole(1,2,3,4,5);

Pro odstranění prvku s hodnotou "3" použijte kód:

unset($myArr);

Upozorňujeme, že není určena hodnota (3), ale klíč prvku (2), v tomto případě začínající 0. Pokud tedy potřebujete odstranit první prvek pole, zadejte nulu živel:

unset($myArr);

Za zmínku také stojí, že po našich dvou smazáních pole nyní obsahuje tři prvky:

Pole
=> 2
=> 4
=> 5
)

Všechny klíče zbývajících prvků jsou zachovány. Pokud tedy nyní potřebujete odstranit první prvek, budete muset jeden určit jako klíč. Proto a také proto, že ne vždy známe číslo prvku v poli, ale pouze jeho hodnoty, nemusí být tato volba vhodná.

Odebrání prvku pole podle jeho hodnoty

Pokud není znám klíč prvku, ale je známa pouze hodnota pole, budete muset projít všechny prvky pole a odstranit ten, který hledáte. Například odstraníme prvek s hodnotou "3":

$myArr = pole(1,2,3,4,5);
foreach ($myArr jako $key => $item)(
if ($item == 3)(
unset($myArr[$key]);
}
}

* Upozorňujeme, že podmínka kontroluje hodnotu pole dostupnou v cyklu v proměnné $item a při mazání je uveden klíč prvku (proměnná $key).

Tento algoritmus je také vhodný, pokud potřebujete odstranit skupinu prvků najednou. Koneckonců je zde podmínka, která určuje, které prvky se mají smazat.

Odstranění protínajících se prvků pole

Jednou z výhod PHP je možnost získat pole prvků, které se nekříží s prvky jiných polí. K tomu použijte funkci pole_diff(). Bere pole jako parametry a vrací nové pole. Například existuje počáteční pole $myArr, ze kterého potřebujeme pouze prvky, které nejsou zahrnuty v poli $myArr2:

$myArr = pole(1,2,3,4,5);
$myArr2 = pole(3,4);

Aplikací funkce array_diff(), získáme nové pole obsahující pouze nezbytné prvky:

$resArr = array_diff($myArr, myArr2);

V důsledku toho bude $resArr obsahovat:

Pole
=> 1
=> 2
=> 5
)

* Stojí za to věnovat pozornost skutečnosti, že klíče jsou uloženy při vytváření nového pole. Kromě toho stojí za to vědět, že výběr pochází pouze z prvního pole. Pokud jsou tedy v $myArr2 další jedinečné prvky, například „6“ nebo „7“, pak to žádným způsobem neovlivní výsledek – nebudou přidány do nového pole.

Tento problém lze vyřešit několika způsoby.

Metoda 1. Zkopírujte pouze liché prvky do jiného pole.

konst N = 20;<>var a, b: pole [ 1 .. N ] celého čísla ;

i, m: byte;

začít randomizovat; for i: = 1 až N do begin a[ i] : = random(40) + 10 ;

napsat (a[ i] : 3 );<= m do if a[ i] mod 2 = 0 then begin m : = m- 1 ; for k: = i to m do a[ k] : = a[ k+ 1 ] ; end else i : = i+ 1 ; for i: = 1 to m do write (a[ i] : 3 ) ; writeln ; end .

konec ;

Tato metoda by měla být považována za nejracionálnější (otevřená pole však nelze studovat ve školním kurzu). V předchozích verzích nebyla pole ve skutečnosti zmenšena, na obrazovce byla zobrazena pouze část pole. Bylo by možné jednoduše iterovat původní pole, nic s ním nedělat a zobrazit pouze liché prvky.

Otevřené pole umožňuje změnit jeho délku. V řešení níže uvedeného problému se po posunutí lichých prvků a „přepsání lichých“ změní délka pole (pomocí procedury setlength). Nastaví novou délku pole. Rysem otevřených polí v Pascalu je, že jejich indexování začíná od nuly.

konst N = 10; var a: pole integer ; i, j, m: byte; začít randomizovat; SetLength(a, N) ;<= m do if a[ i] mod 2 = 0 then begin for j : = i to m- 1 do a[ j] : = a[ j+ 1 ] ; m : = m - 1 end else i : = i + 1 ; SetLength(a, m+ 1 ) ; pro i: = 0 až N-1 do begin a[i]: = náhodný(40) + 10; napsat (a[ i] : 3 );

konec ;