Eliminarea din matricea php. Eliminați elementele pare dintr-o matrice

Aceasta sarcina poate fi rezolvată în mai multe moduri.

Metoda 1. Copiați într-o altă matrice, pur și simplu nu chiar elemente.

const N = 20; var a, b: tablou [ 1 .. N ] de întreg ; i, m: octet; începe randomizarea; pentru i: = 1 la N începe a[ i] : = random(40 ) + 10 ; scrie (a[ i] : 3 ) ; Sfârşit ; scrie ; m := 0 ; pentru i: = 1 la N face dacă a[i] mod 2<>0 apoi începe m : = m + 1 ; b[ m] : = a[ i] ; Sfârşit ; pentru i: = 1 la m începeți să scrieți (b[ i] : 3 ) ; Sfârşit ; scrie ; Sfârşit.

Acesta este cel mai simplu mod de a elimina elementele matricei (în în acest caz, numere pare), deoarece nu este nevoie să comprimați matricea originală. În soluția problemei prezentate mai sus, variabila m stochează numărul de elemente impare găsite și, în același timp, la completarea celei de-a doua matrice, este un indice schimbător al elementelor.

Metoda 2. Ștergeți elementele pare din matricea curentă, suprascriindu-le cu cele impare situate în dreapta.

const N = 10; var a: tablou [ 1 .. N ] de întreg ; i, k, m: octet; începe randomizarea; pentru i: = 1 la N începe a[ i] : = random(40 ) + 10 ; scrie (a[ i] : 3 ) sfârşitul ; scrie ; i := 1; m := N; in timp ce eu<= 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 .

Această metodă de rezolvare a problemei este mai complicată. Aici, dacă se întâlnește un element par, atunci întregul rest al matricei este deplasat cu o celulă înainte. În acest caz, elementul par găsit este suprascris. Variabila m este redusă deoarece numărul elementelor matricei devine mai mic.

Această metodă ar trebui considerată cea mai rațională (cu toate acestea, matricele deschise pot să nu fie studiate într-un curs școlar). În versiunile anterioare, matricele nu au fost de fapt reduse; doar o parte din matrice a fost afișată pe ecran. Ar fi posibil să repetați pur și simplu peste matricea originală, să nu faceți nimic cu el și să afișați doar elementele ciudate.

O matrice deschisă vă permite să-i schimbați lungimea. În soluția problemei de mai jos, după ce elementele impare au fost mutate și cele impare au fost „suprascrise”, lungimea matricei este schimbată (folosind procedura setlength). Setează noua lungime a matricei. O caracteristică a tablourilor deschise în Pascal este că indexarea lor începe de la zero.

const N = 10; var a: matrice de numere întregi; i, j, m: octet; începe randomizarea; SetLength(a, N); pentru i : = 0 la N- 1 începe a[ i] : = random(40 ) + 10 ; scrie (a[ i] : 3 ) ; Sfârşit ; scrie ; i := 0 ; // indexul primului element m: = n-1; // ultimul index in timp ce eu<= 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 ) ; // ultimul element are indice m, dar sunt m+1 elemente pentru i: = 0 la m scrieți (a[ i] : 3 ) ; scrie ; Sfârşit.

Un exemplu de execuție a codului de program.

Funcții pentru lucrul cu matrice și operații pe matrice (Partea 2)

Îmbinarea tablourilor

Fuzionarea (concatenarea) matricelor este operația de a crea o matrice formată din elemente ale mai multor alte matrice. Îmbinarea matricelor este o operațiune foarte periculoasă, deoarece rezultatul fuziunii este supus propriei sale logici, uitând despre care puteți pierde date. Îmbinarea matricelor este implementată folosind operatorul " + " sau folosind funcția Îmbinarea se poate face numai folosind funcția array_merge().

Să presupunem că avem două matrice:

$A = matrice("1"=>"Primul", "2"=>"Al doilea");
$B = matrice("3"=>"Al treilea", "4"=>"Al patrulea");

Acum să îmbinăm aceste două matrice într-o singură matrice $C:

Operator " + " nu este comutativă pentru matrice. Aceasta înseamnă că $A + $B nu este egal $B + $A.

Ca rezultat al exemplului considerat, vom primi o matrice $C de urmatoarea forma:

"1" => "Primul", "2" => "Al doilea", "3" => "Al treilea", "4" => "Al patrulea"

Și ca rezultat $B + $A vom obține această matrice:

"3"=>"Al treilea", "4"=>"Al patrulea", "1"=>"Primul", "2"=>"Al doilea"

Această metodă nu funcționează la îmbinarea listelor. Să explicăm Acest lucru De exemplu:

Să presupunem că avem două matrice:

$A = matrice(10,11,12);
$B = matrice(13,14,15);

Ca urmare a comasării listelor $AȘi $B ($A + $B) obținem: 10,11,12. Și acesta nu este deloc rezultatul pe care am vrut să-l obținem... Acest lucru se datorează faptului că la îmbinarea listelor cu aceiași indici, un element din primul tablou rămâne în tabloul rezultat și în același loc. În acest caz, trebuie să folosim funcția

Exemplu de utilizare a funcției numara():

$arr = 5 ;
$arr = 4 ;
$arr = 8 ;
$arr = 3 ;
$arr = 8 ;
ecou "

Numărul de elemente ale matricei: ". count($arr). "

Eliminarea unei matrice și a elementelor sale

Dacă doriți să eliminați întreaga matrice, utilizați funcția unset().

Dacă doriți să eliminați o pereche cheie/valoare, puteți utiliza și funcția unset(). Să dăm exemple concrete:

$arr = array(5 => 1, 12 => 2);

$arr = 56 ; // În acest moment al scriptului este
// echivalent cu $arr = 56;

$arr["x"] = 42; // Acesta adaugă unul nou la matrice
// element cu cheia „x”
Forumul portalului PHP. S.U.

X[3]: =X[4];

X[4]: =X[5];

X[5]: =X[6];

Astfel, toate elementele de la a treia la a cincea trebuie să fie mutate la stânga cu unu - în locul elementului i, trebuie să scrieți (i+1)-lea. Diagrama bloc a algoritmului este prezentată în Fig. 5.25.

Orez. 5.25.

Acum să luăm în considerare o problemă mai generală: trebuie să eliminăm al-lea element dintr-un tablou X format din n elemente. Pentru a face acest lucru, este suficient să scrieți elementul (m+1)-lea în locul elementului cu numărul m, al-lea element (m+2) - în locul elementului (m+1)-lea etc. , al n-lea element - în locul (n–1)-lea. Procesul de eliminare a unui element dintr-o matrice este prezentat în Fig. 5.26.

Algoritmul pentru îndepărtarea unui element cu numărul m dintr-un tablou X de dimensiune n este prezentat în Fig. 5.27.

După îndepărtarea elementului 4 Și de fapt, deplasarea unei părți a matricei cu un element la stânga din matrice, numărul de elemente din matrice se va modifica (scăzut cu unu), iar indicele unor elemente se va modifica. Dacă un element este șters, atunci următorul îi ia locul și nu este nevoie să treceți la el (prin creșterea indexului cu unul). Următorul element în sine s-a mutat la stânga după ce a fost eliminat.

Dacă procesați o matrice în care unele dintre elemente sunt șterse, atunci după ștergerea unui element nu trebuie să treceți la următorul (acest lucru reduce numărul de elemente). Ca exemplu, luați în considerare următoarea problemă.

SARCINA 5.1. Eliminați elementele negative dintr-o matrice.

Algoritmul de rezolvare a problemei este destul de simplu: parcurgem toate elementele matricei, dacă elementul este negativ, atunci îl ștergem prin deplasarea tuturor celor ulterioare câte unul la stânga. Singurul lucru care merită reținut este că, după ștergerea unui element, nu trebuie să treceți la următorul pentru procesarea ulterioară, el însuși se mută la locul celui actual. Diagrama bloc pentru rezolvarea problemei 5.1 este prezentată în Fig. 5.28.

Mai jos este textul programului cu comentarii.

program support_array; var i, n, j: octet; X: tablou [ 1.. 100 ] de real; begin writeln('introduceți dimensiunea matricei'); readln(n); (Intrare matrice.) pentru i:=1 la n începe scrierea (’X[ ’, i, ’ ]= ’); readln(X[i]); Sfârşit; writeln('array X'); pentru i:=1 la n scrieți (x [ i ] : 5: 2, ’ ’); scrie; i: = 1; in timp ce eu<=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.

Rezultatele programului sunt prezentate în Fig. 5.29.

5.9 Inserarea unui element într-o matrice

Să luăm în considerare o sarcină simplă: introduceți numărul b în tabloul X(10) , între al treilea și al patrulea element.

Pentru a rezolva această problemă, trebuie să mutați toate elementele matricei, începând cu al patrulea, la dreapta cu un element. Apoi va trebui să scrieți b (X:=b;) în al patrulea element al matricei. Dar pentru a nu pierde valoarea vecină, trebuie mai întâi să deplasați al zecelea element la dreapta, apoi al nouălea, al optulea etc. până la al patrulea. Diagrama bloc a algoritmului de inserare este prezentată în Fig. 5.30.

În cazul general, schema bloc de inserare a numărului b în tabloul X(N) între elementele numerotate m și m+1 este prezentată în Fig. 5.31.

Mai jos este un fragment de program care implementează acest algoritm 5 Când declarați o matrice, trebuie să furnizați o dimensiune suficientă pentru a insera un element. .

var i, n,m: octet; X: tablou [ 1.. 100 ] de real; b: real; începe scrierea ('N= '); readln(n); pentru i:=1 la n începeți să scrieți (’X[ ’, i, ’ ]= ’); readln(X[i]); Sfârşit; writeln('Matrice X'); pentru i:=1 la n scrieți (x [ i ] : 5: 2, ’ ’); scrie; writeln('m='); readln(m); writeln('b='); readln(b); pentru i:=n până la m+1 do x [ i +1]:=x [ i ]; x :=b; n:=n+1; writeln('Matrice modificată'); pentru i:=1 la n scrieți (X[ i ] : 5: 2, ’ ’); scrie; Sfârşit.

5.10 Utilizarea rutinelor pentru a lucra cu matrice

Să ne uităm la cum puteți trece matrice unei subrutine. După cum știți (vezi capitolul 4), pentru a declara variabile în lista de parametri formali ai unei subrutine, trebuie să specificați numele și tipurile acestora. Cu toate acestea, tipul oricărui parametru din listă poate fi doar un tip standard sau declarat anterior. Prin urmare, pentru a transmite o matrice la o subrutină, trebuie mai întâi să descrii tipul său 6 Tipul de date matrice, declarația matricei vezi secțiunea 2.4.9. Lucrul cu matrice este descris în detaliu în acest capitol. si apoi declara procedura:

tip_matrice = matrice[index_list] de tip;

procedură

nume_procedura(nume_matrice: tip_matrice);

De exemplu:

tip vector=matrice [ 1.. 10 ] de octet; matrice=matrice [ 1.. 3, 1.. 3 ] de real; procedura proc (A: matrice; b: vector; var x: vector);

Este clar că trecerea unui șir de formă la o subrutină

nume_variabilă: şir[lungimea_șirului];

care este de fapt o matrice de 7 Tipul de date „șir”, declarația șirului de caractere vezi clauza 2.4.9, ar trebui efectuată în mod similar:

row_type = şir[lungimea_șirului];

procedură

nume_procedura(nume_șir: tip_șir);

De exemplu:

tip șir_5=șir [ 5 ]; stroka_10=șir [ 1 0 ]; function fun (S t r: stroka_5) : stroka_10;

Matricele pot fi trecute la o subrutină folosind conceptul de matrice deschisă. Matricea deschisă este matricea 8 Tipul de date „matrice”, declarația matricei, accesul la matrice, vezi secțiunea 2.4.9., a cărui descriere indică tipul de elemente din care constă, dar nu definește limitele pentru modificarea indicilor:

public_array_name: matrice de matrice de... tip;

De exemplu:

var array_1: matrice de real; array_2: matrice de matrice de caractere; array_3: matrice de matrice de matrice de octet;

Alocare de memorieși specificarea limitelor indexului

O matrice este una dintre cele mai utile și mai frecvent utilizate structuri de date în orice limbaj de programare. A ști cum să gestionezi matricele și elementele acestora este foarte important și util. În acest articol vom analiza cum puteți elimina elementele individuale ale unei matrice în PHP.

Această sarcină poate fi implementată folosind diferite metode, în funcție de ceea ce știm despre elementul care este eliminat - dacă cheia este cunoscută (numărul sau identificatorul elementului din matrice) sau numai valoarea acestuia.

Eliminarea unui element dintr-o matrice prin cheia sa

Dacă cheia elementului este cunoscută, atunci sarcina este foarte simplă. Funcţie unset() vă permite să ștergeți un element de matrice sau orice variabilă (memoria computerului utilizată pentru variabilă va fi, de asemenea, ștearsă).

De exemplu, avem o matrice:

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

Pentru a elimina un element cu valoarea „3” utilizați codul:

unset($myArr);

Vă rugăm să rețineți că nu valoarea (3) este specificată, ci cheia elementului (2), în acest caz începând cu 0. Deci, dacă trebuie să eliminați primul element al matricei, atunci specificați zero element:

unset($myArr);

De asemenea, merită luat în considerare faptul că, după cele două ștergeri, matricea conține acum trei elemente:

Matrice
=> 2
=> 4
=> 5
)

Toate cheile elementelor rămase sunt păstrate. În consecință, dacă acum trebuie să ștergeți primul element, atunci va trebui să specificați unul ca cheie. Prin urmare, și pentru că nu știm întotdeauna numărul elementului din matrice, ci doar valorile acestuia, această opțiune poate să nu fie potrivită.

Eliminarea unui element de matrice după valoarea sa

Dacă cheia unui element nu este cunoscută, dar se cunoaște doar valoarea matricei, atunci va trebui să parcurgeți toate elementele matricei și să îl ștergeți pe cel pe care îl căutați. De exemplu, ștergem un element cu valoarea „3”:

$myArr = matrice(1,2,3,4,5);
foreach ($myArr ca $key => $element)(
dacă ($articol == 3)(
unset($myArr[$key]);
}
}

* Vă rugăm să rețineți că condiția verifică valoarea matricei disponibilă în bucla în variabila $item, iar la ștergere, este indicată cheia elementului (variabila $key).

Acest algoritm este potrivit și dacă trebuie să ștergeți un grup de elemente simultan. La urma urmei, aici există o condiție care determină ce elemente să șteargă.

Eliminarea elementelor de matrice care se intersectează

Una dintre caracteristicile convenabile ale PHP este capacitatea de a obține o serie de elemente care nu se intersectează cu elementele altor matrice. Pentru a face acest lucru, utilizați funcția array_diff(). Ia matrice ca parametri, returnând o nouă matrice. De exemplu, există o matrice inițială $myArr din care avem nevoie doar de elemente care nu sunt incluse în tabloul $myArr2:

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

Prin aplicarea funcției array_diff(), obținem o nouă matrice care conține doar elementele necesare:

$resArr = array_diff($myArr, myArr2);

Ca rezultat, $resArr va conține:

Matrice
=> 1
=> 2
=> 5
)

* Merită să acordați atenție faptului că cheile sunt salvate la crearea unei noi matrice. În plus, merită să știți că selecția vine doar din prima matrice. Deci, dacă există alte elemente unice în $myArr2, de exemplu „6” sau „7”, atunci acest lucru nu va afecta în niciun fel rezultatul - nu vor fi adăugate la noua matrice.

35 de răspunsuri

Există diferite moduri de a elimina un element de matrice, unele fiind mai utile pentru anumite sarcini specifice decât altele.

Eliminați un element de matrice

Dacă doriți să eliminați doar un element dintr-o matrice, puteți utiliza \unset() sau, alternativ, \array_splice() .

De asemenea, dacă aveți o valoare și nu cunoașteți cheia pentru a elimina elementul, puteți utiliza \array_search() pentru a obține cheia.

metoda \unset().

Vă rugăm să rețineți că atunci când utilizați \unset() cheile matricei nu vor fi modificate/reindexate. Dacă doriți să reindexați cheile, puteți utiliza \array_values() după \unset() care convertește toate cheile în chei numerice, începând de la 0.

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

// Matricea noastră inițială $arr = array(„albastru”, „verde”, „roșu”, „galben”, „verde”, „portocaliu”, „galben”, „indigo”, „roșu”); print_r($arr); // Eliminați elementele ale căror valori sunt galbene sau roșii $arr = array_diff($arr, array("galben", "roșu")); print_r($arr);

Aceasta este rezultatul din codul de mai sus:

Matrice ( => albastru => verde => roșu => galben => verde => portocaliu => galben => indigo => roșu) Matrice ( => albastru => verde => verde => portocaliu => indigo)

Acum array_values() va reindexa matricea numerică, dar va elimina toate șirurile de chei din matrice și le va înlocui cu numere. Dacă trebuie să stocați nume de chei (șiruri) sau să reindexați matricea dacă toate cheile sunt numerice, utilizați array_merge():

$arr = array_merge(array_diff($arr, array("galben", "rosu"))); print_r($arr);

Matrice ( => albastru => verde => verde => portocaliu => indigo)

Dacă aveți o matrice indexată numerică în care toate valorile sunt unice (sau nu sunt unice, dar doriți să eliminați toate instanțele unei anumite valori), puteți utiliza pur și simplu array_diff() pentru a elimina elementul corespunzător, de exemplu

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

De exemplu:

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

Se afișează următoarele:

În acest exemplu, elementul cu valoarea „Charles” este eliminat, așa cum se poate verifica folosind apeluri la sizeof(), care raportează o dimensiune de 4 pentru matricea originală și 3 după eliminare.

Distrugeți un element dintr-o matrice

unset()

$matrice1 = matrice ("A", "B", "C", "D", "E"); unset($array1); // Ștergeți valoarea cunoscută a indexului(2) din matrice var_dump($array1);

Ieșirea va fi:

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

Dacă trebuie să reindexați matricea:

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

Atunci rezultatul va fi:

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

Eliminați elementul de la sfârșitul matricei- returnează valoarea elementului care este eliminat

mixed array_pop(array &$array)

$stack = array("portocaliu", "banana", "mar", "zmeura"); $last_fruit = array_pop($stiva); print_r($stiva); print_r("Ultimul fruct:".$ultimul_fruct); // Ultimul element al tabloului

Va exista o cale de ieșire

Array ( => portocala => banana => mar) Ultimul fruct: zmeura

Scoateți primul element (roșu) din matrice, - returnează valoarea elementului care este eliminat

mixed array_shift (matrice &$array)

$culoare = matrice("a" => "rosu", "b" => "verde" , "c" => "albastru"); $prima_culoare = array_shift($culoare); print_r($culoare); print_r("Prima culoare: ".$prima_culoare);

Ieșirea va fi:

Matrice ([b] => verde [c] => albastru) Prima culoare: roșu

unset() distruge variabilele specificate.

Comportamentul unset() în interiorul unei funcții poate varia în funcție de tipul de variabilă pe care încercați să o distrugeți.

Dacă o variabilă globalizată este unset() în interiorul unei funcții, numai variabila locală este distrusă. Variabila din mediul apelant va păstra aceeași valoare pe care o avea înainte ca unset() să fie apelat.

Răspunsul codului de mai sus va fi bar.

Pentru a unset() o variabilă globală în interiorul unei funcții:

Pentru utilizarea tablourilor asociative neasezat :

$arr = array("a" => 1, "b" => 2, "c" => 3); unset($arr["b"]); // REZULTAT: matrice("a" => 1, "c" => 3)

Matrice numerice

Pentru matrice numerice utilizați array_splice :

$arr = array(1, 2, 3); array_splice($arr, 1, 1); // REZULTAT: matrice (0 => 1, 1 => 3)

Notă

Dacă trebuie să eliminați mai multe valori dintr-o matrice, iar intrările din acea matrice sunt obiecte sau date structurate, aceasta este cea mai bună alegere. Acele intrări care returnează adevărat din funcția de apel invers vor fi salvate.

$matrice = [["x"=>1,"y"=>2,"z"=>3], ["x"=>2,"y"=>4,"z"=>6], ["x"=>3,"y"=>6,"z"=>9] ]; $rezultate = array_filter($array, function($valoare) ( ​​return $valoare["x"] > 2; )); //=> [["x"=>3,"y"=>6,z=>"9"]]

Dacă trebuie să eliminați mai multe elemente dintr-o matrice asociativă, puteți utiliza array_diff_key() (array_flip() este folosit aici):

$my_array = array("key1" => "valoarea 1", "key2" => "valoarea 2", "key3" => "valoarea 3", "key4" => "valoarea 4", "key5" => „valoarea 5”,); $to_remove = array("key2", "key4"); $rezultat = cheie_diff_matrice($matrice_mea, inversare_matrice($de_eliminare)); print_r($rezultat);

Matrice ( => valoarea 1 => valoarea 3 => valoarea 5)

Să presupunem că aveți următoarea matrice:

Matrice ( => 193 => 5)

Pentru a elimina rularea de stocare:

Unset($atribute[„stocare”]); $atribute = array_filter($atribute);

Și vei obține:

Matrice ( => 193)

Aș dori doar să spun că am avut un anumit obiect care avea atribute variabile (practic afișa un tabel și schimbam coloanele din tabel, astfel încât atributele din obiectul care reflectă tabelul s-ar putea schimba și ele):

Clasa obj (protejat $câmpuri = matrice("câmp1","câmp2"); protejat $câmp1 = matrice(); protejat $câmp2 = matrice(); câmpuri de încărcare protejate()() // Aceasta va încărca $câmpul1 și $ field2 cu rânduri de date pentru coloana pe care o descriu funcția protejată clearFields($num)( foreach($fields as $field) ( unset($this->$field[$num]); // Acest lucru nu a funcționat pe linia de mai jos a lucrat nesetat($this->($field)[$num]); // Mai întâi trebuie să rezolvați $field folosind () ) ) )

Întregul scop al $fields a fost simplu, așa că nu trebuie să caut nicăieri în cod când se schimbă, mă uit doar la începutul clasei și schimb lista de atribute și conținutul matricei $câmpuri pentru a reflecta noi atribute.

Urmați funcțiile implicite

$Matrice = matrice("test1","test2","test3","test3"); unset($Matrice);

$Matrice = matrice("test1","test2","test3","test3"); array_pop($Matrice);

$Matrice = matrice("test1","test2","test3","test3"); array_splice($Matrice,1,2);

$Matrice = matrice("test1","test2","test3","test3"); array_shift($Matrice);

Deși unset() a fost menționat de câteva ori aici, merită menționat faptul că unset() acceptă mai multe variabile, ceea ce face ușoară eliminarea mai multor elemente neadiacente dintr-o matrice într-o singură operațiune:

// Sterge elemente multiple, necontigue dintr-o matrice $array = [ "foo", "bar", "baz", "quz" ]; unset($array, $array); print_r($array); // Ieșire: ["foo", "bar" ]

unset() dinamic

unset() nu acceptă o serie de chei de eliminat, așa că codul de mai jos va eșua (deși ar fi puțin mai ușor să utilizați unset() în mod dinamic).

$matrice = interval(0,5); $eliminare = ; $matrice = unset($eliminare); // FAILS: "neașteptat "unset"" print_r($array);

În schimb, unset() poate fi folosit dinamic într-o buclă foreach:

$matrice = interval(0,5); $eliminare = ; foreach ($elimină ca $k=>$v) ( unset($array[$v]); ) print_r($array); // Ieșire: [ 0, 3, 4, 5 ]

Eliminați cheile matricei prin copierea matricei

Există și o altă practică care nu a fost încă menționată. Uneori, cel mai simplu mod de a scăpa de anumite chei de matrice este să copiați pur și simplu $array1 în $array2.

$matrice1 = interval(1,10); foreach ($array1 ca $v) ( // Eliminați toate numerele întregi pare din tablou if($v % 2) ( $array2 = $v; ) ) print_r($array2); // Ieșire: [ 1, 3, 5, 7, 9 ];

Evident, aceeași practică se aplică șirurilor de text:

$array1 = [ "foo", "_bar", "baz" ]; foreach ($array1 ca $v) ( // Eliminați toate șirurile care încep cu liniuță de subliniere if(strpos($v,"_")===false) ( $array2 = $v; ) ) print_r($array2); // Ieșire: ["foo", "baz" ]

Solutii:

1. Pentru a elimina un singur element, utilizați unset():

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

1. Pentru a elimina mai multe elemente neadiacente, utilizați și unset() :

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

1. Pentru a elimina mai multe elemente adiacente, utilizați array_splice() :

array_splice($array, $offset, $lungime);

Explicații suplimentare:

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

Pe lângă sintaxă, există o diferență logică între utilizarea unset() și alocarea unui element. Primul spune că Acest lucru nu mai există, iar al doilea spune că Acest lucru încă există, dar valoarea lui este șirul gol.

Dacă aveți de-a face cu numere, este mai bine să alegeți 0. Deci, dacă compania oprește producția de pinion model XL1000, își va actualiza inventarul:

Dezactivat($produse["XL1000"]);

Cu toate acestea, dacă nu mai avea temporar pinioanele XL1000, dar era programat să primească un nou lot din fabrică mai târziu în această săptămână, acesta este mai bine:

$produse["XL1000"] = 0; $animale = array_values($animale);

Eliminați elementul de matrice pe baza cheii:

Utilizați funcția de dezactivare așa cum se arată mai jos:

$a = array("salam", "10", 1); unset($a); print_r($a); /* Ieșire: Array ( => salam => 1) */

Eliminați elementul de matrice pe baza valorii:

Utilizați funcția array_search pentru a obține cheia elementului și utilizați metoda de mai sus pentru a elimina un element de matrice, așa cum se arată mai jos:

$a = array("salam", "10", 1); $key = array_search(10, $a); if($key !== false) ( unset($a[ $key ]); ) print_r($a); /* Ieșire: Array ( => salam => 1) */

Creați-vă matricea în variabila $array și apoi unde am pus „elementul pe care doriți să îl eliminați” puneți ceva de genul: „a”. Și dacă doriți să ștergeți mai multe, atunci: „a”, „b”.