Una delle operazioni principali quando si lavora con gli array è la ricerca di un valore specifico. La funzione PHP array_search() è progettata per questo. È in grado di elaborare sia raccolte unidimensionali che associative, restituendo la chiave del valore cercato se viene trovato nell'array.
Sintassi
La descrizione formalizzata della funzione array_search() in PHP è la seguente:
Array_search misto (valore misto, array $collection [, bool strict])
Parametri di input:
- $collection - l'array in cui verrà eseguita la ricerca;
- valore: il valore desiderato di qualsiasi tipo;
- strict è un flag booleano opzionale che imposta un meccanismo di confronto rigoroso in base al tipo.
Meccanismo di funzionamento
La funzione PHP array_search() confronta il valore uno per uno con tutti i valori nell'array di raccolta. Per impostazione predefinita, il confronto viene eseguito indipendentemente dal tipo degli operandi. Questa impostazione può essere modificata impostando il flag strict su TRUE. I confronti tra stringhe fanno distinzione tra maiuscole e minuscole.
Se viene trovata una corrispondenza, viene restituita la chiave corrispondente all'elemento trovato e la funzione smette di funzionare. Pertanto, non può essere utilizzato per rilevare più occorrenze del valore desiderato in una matrice.
Se non viene trovata alcuna corrispondenza, la funzione restituirà il valore booleano FALSE.
Dovresti controllare il risultato restituito utilizzando l'operatore di uguaglianza rigorosa (===). Ciò è importante perché la funzione potrebbe restituire un valore che viene convertito in FALSE, ad esempio 0 o una stringa vuota.
Esempi di utilizzo
Esempio 1. Quando si passa un array multidimensionale alla funzione PHP array_search(), il risultato del lavoro sarà la chiave dell'elemento cercato.
"inverno", "stagione2" => "primavera", "stagione3" => "estate", "stagione4" => "autunno"); $risultato1 = array_search("inverno", $array); $risultato2 = array_search("estate", $array); $risultato3 = array_search("aprile", $array); ?>
In questo esempio, $result1 sarà impostato su "season1", $result2 sarà impostato su "season3" e $result3 sarà impostato sul valore booleano FALSE perché la stringa "april" non viene visualizzata nell'array di origine.
Esempio 2. La funzione PHP array_search() può anche elaborare un array unidimensionale, considerando le sue chiavi come i seguenti indici numerici.
La variabile $result verrà impostata su 1, in base all'indice dell'elemento "hunter" nell'$array.
Esempio 3. Possibile errore durante l'analisi del risultato.
"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $risultato = array_search("Washington", $presidenti); if (!$risultato) ( echo "G. Washington non fu il primo presidente degli Stati Uniti"; ) ?>
Quindi, senza controllare il risultato con rigorosa uguaglianza, puoi ricevere un messaggio inaspettato che George Washington non è stato il primo presidente degli Stati Uniti.
Esempio 4: viene restituita solo la chiave della prima corrispondenza trovata.
Anche se il valore che stai cercando ricorre tre volte nell'array, la funzione restituirà solo il primo risultato trovato - 0. Per trovare più corrispondenze, si consiglia di utilizzare la funzione PHP array_keys().
dal multidimensionale (18)
Ho modificato uno degli esempi seguenti per descrivere la funzione array_search. La funzione searchItemsByKey restituisce tutti i valori per $key da un array multidimensionale (N livelli). Forse questo sarebbe utile a qualcuno. Esempio:
$arr = array("XXX"=>array("YYY"=> array("AAA"=> array("chiaveN" =>"valore1")), "ZZZ"=> array("BBB"=> array ("chiaveN" => "valore2")) //.....)); $risultato = searchItemsByKey($arr,"keyN"); stampa "
"; stampa_r($risultato); stampa ""; // Array OUTPUT ( => valore1 => valore2)Codice funzione:
Funzione searchItemsByKey($array, $key) ( $risultati = array(); if (is_array($array)) ( if (isset($array[$key]) && key($array)==$key) $risultati = $array[$chiave]; foreach ($array come $sub_array) $risultati = array_merge($risultati, searchItemsByKey($sub_array, $chiave));
Ho un array in cui voglio cercare l'uid e ottenere la chiave dell'array.
Esempi
Supponiamo di avere il seguente array bidimensionale:
$userdb = array(array("uid" => "100", "nome" => "Sandra Shush", "pic_square" => "urlof100"), array("uid" => "5465", "nome" => "Stefanie Mcmohn", "pic_square" => "urlof100"), array("uid" => "40489", "name" => "Michael", "pic_square" => "urlof40489"));
La chiamata a search_by_uid(100) (l'uid del primo utente) dovrebbe restituire 0.
La chiamata alla funzione search_by_uid(40489) dovrebbe restituire 2 .
Ho provato a creare loop, ma ho bisogno di un'esecuzione più rapida del codice.
Basandosi sull'eccellente risposta di Jakub, ecco una ricerca più generalizzata che ti consentirà di specificare la chiave (non solo per l'uid):
Funzione searcharray($valore, $chiave, $array) ( foreach ($array as $k => $val) ( if ($val[$chiave] == $valore) ( return $k; ) ) return null )
Utilizzo: $risultati = searcharray("searchvalue", searchkey, $array);
Funzione searchForId($id, $array) ( foreach ($array as $key => $val) ( if ($val["uid"] === $id) ( return $key; ) ) return null; )
Funzionerà. Dovresti chiamarlo così:
$id = searchForId("100", $userdb);
È importante sapere che se usi === i tipi di operatori confrontati devono essere esattamente gli stessi, in questo esempio devi cercare string o semplicemente usare == invece di === .
In base alla risposta angora. Nelle versioni successive di PHP (>= 5.5.0) puoi utilizzare un one-liner.
$chiave = array_search("100", array_column($userdb, "uid"));
Anche se questa è una vecchia domanda e esiste una risposta accettata, ho pensato di suggerire una modifica alla risposta accettata. Quindi, prima di tutto, sono d'accordo che la risposta accettata qui sia corretta.
Funzione searchArrayKeyVal($sKey, $id, $array) ( foreach ($array as $key => $val) ( if ($val[$sKey] == $id) ( return $key; ) ) return false; )
Invece, sostituisci il "uid" preimpostato con un parametro nella funzione, quindi ora chiamare il codice seguente significa che puoi utilizzare una funzione per più tipi di array. Piccolo cambiamento, ma è un po' diverso.
// Dati dell'array degli utenti $userdb = array (array ("uid" => "100","name" => "Sandra Shush","url" => "urlof100"), array ("uid" => " 5465","name" => "Stefanie Mcmohn","url" => "urlof100"), array ("uid" => "40489","name" => "Michael","url" => "urlof40489 "),);); // Ottieni la chiave dell'array $arrayKey = searchArrayKeyVal("uid", "100", $userdb); if ($arrayKey!==false) ( echo "Risultato della ricerca: ", $userdb[$arrayKey]["nome"]; ) else ( echo "Impossibile trovare il risultato della ricerca"; )
If(! function_exists("arraySearchMulti"))( function arraySearchMulti($search,$key,$array,$returnKey=false) ( foreach ($array as $k => $val) ( if (isset($val[$ key])) ( if ((string)$val[$key] == (string)$search) ( return ($returnKey ? $k: $val); ) )else( return (is_array($val) ? arraySearchMulti ($ricerca,$chiave,$val,$chiaveritorno) : null);
puoi usare questa funzione; https://github.com/serhatozles/ArrayAdvancedSearch
="2""; $Array = array("a" => array("d" => "2"), array("a" => "Mondo di esempio","b" => "2"), array("c" => "3"), array("d" => "4"),); $Risultato = ArraySearch($Array,$query,1);
"; print_r($Risultato); echo ""; // Risultato: // Array // (// => Array // (// [a] => Esempio Mondo // [b] => 2 //) // //)Se la domanda, ad es.
$a = [ [ "_id" => "5a96933414d48831a41901f2", "discount_amount" => 3.29, "discount_id" => "5a92656a14d488570c2c44a2", ], [ "_id" => "5a9790fd14d48879cf16a9e8", "dis count_amount" => 4,53, " discount_id" => "5a9265b914d488548513b122", ], [ "_id" => "5a98083614d488191304b6c3", "discount_amount" => 15.24, "discount_id" => "5a92806a14d48858ff5c2ec3", ], [ "_id" > "5a 982a4914d48824721eafe3", "importo_sconto " => 45,74, "discount_id" => "5a928ce414d488609e73b443", ], [ "_id" => "5a982a4914d48824721eafe55", "discount_amount" => 10,26, "discount_id" => "5a928ce414d488609e73b4 43", ],];
Funzione searchForId($id, $array) ( $did=0; $dia=0; foreach ($array as $key => $val) ( if ($val["discount_id"] === $id) ( $ dia +=$val["importo_sconto"]; $fatto++; ) if($dia != "") ( echo $dia; var_dump($fatto); ) return null); print_r(searchForId("5a928ce414d488609e73b443",$a));
Prova anche questo
Funzione search_in_array($srchvalue, $array) ( if (is_array($array) && count($array) > 0) ( $foundkey = array_search($srchvalue, $array); if ($foundkey === FALSE) ( foreach ($array come $chiave => $valore) ( if (is_array($valore) && count($valore) > 0) ( $foundkey = search_in_array($srchvalue, $value); if ($foundkey != FALSE ) restituisce $chiavetrovata; ) ) altrimenti restituisce $chiavetrovata;
$a = ["x" => ["eee", "ccc"], "b" => ["zzz"]]; $trovato = nullo; $cerca = "eee"; array_walk($a, funzione ($k, $v) usa ($ricerca, &$trovato) ( if (in_array($ricerca, $k)) ($trovato = $v; ))); var_dump($trovato);
Ecco una frase per la stessa cosa,
$pic_square = $userdb["pic_square"];
Ecco il mio esempio e tieni presente che questa è la mia prima risposta. Ho eliminato l'array param perché avevo solo bisogno di cercare un array specifico, ma potevi aggiungerne facilmente uno. Volevo essenzialmente cercare qualcosa di più del semplice uid.
Inoltre, nella mia situazione, potrebbero esserci più chiavi da restituire come risultato della ricerca di altri campi che potrebbero non essere univoci.
/** * @param array multidimensionale * @param valore stringa da cercare, ad esempio un nome di campo specifico come name_first * @param chiave associativa della stringa in cui trovarlo, ad esempio field_name * * @return chiavi dell'array.
*/ function search_revisions($dataArray, $search_value, $key_to_search) ( // Questa funzione cercherà nelle revisioni un determinato valore // correlato alla chiave associativa che stai cercando. $keys = array(); foreach ($dataArray as $chiave => $valore_cur) ( if ($valore_cur[$chiave_da_ricercare] == $valore_ricerca) ( $chiavi = $chiave; ) ) return $chiavi;
Successivamente ho finito per scrivere questo per permettermi di ricercare una chiave valoriale e associativa diversa. Quindi il mio primo esempio ti consente di cercare un valore in qualsiasi chiave associativa specifica e restituire tutte le corrispondenze. Questo secondo esempio mostra dove si trova il valore ("Taylor") in una chiave di associazione specifica (first_name). E
un altro valore (true) si trova in un'altra chiave associativa (usata) e restituisce tutte le corrispondenze (chiavi in cui vengono utilizzate le persone chiamate "Taylor" AND).
/** * @param array multidimensionale * @param string $search_value Il valore da cercare, ad esempio un "Taylor" specifico * @param string $key_to_search La chiave associativa in cui trovarlo, ad esempio first_name * @param string $other_matching_key L'associativo chiave da trovare nelle corrispondenze per impiegato * @param string $other_matching_value Il valore da trovare nella chiave associativa corrispondente, ovvero true * * @return chiavi dell'array, ovvero tutte le persone con il nome "Taylor" che sono impiegate.
$data = array(array("cust_group" => 6, "prezzo" => 13.21, "price_qty" => 5), array("cust_group" => 8, "prezzo" => 15.25, "price_qty" => 4), array("cust_group" => 8, "prezzo" => 12.75, "price_qty" => 10)); $findKey = search_revisions($data,"8", "custom_group", "10", "price_qty"); print_r($trovaChiave);
Risultato
Matrice ( => 2)
/** * cerca un array semplice e multidimensionale * @param type $needle * @param type $haystack * @return boolean */ public static function in_array_multi($needle, $haystack)( $needle = trim($needle ); if(!is_array($pagliaio)) return False; foreach($pagliaio as $chiave=>$valore)( if(is_array($valore))( if(self::in_array_multi($ago, $valore)) return True; else self::in_array_multi($needle, $value) else if(trim($value) === trim($needle))(//correzione visibilità// error_log("$value === $ visibilità dell'ago impostazione su 1 nascosto"); return True; ) ) return False; )
Se stai utilizzando (PHP 5>=5.5.0) non è necessario scrivere la tua funzione per questo, scrivi semplicemente questa riga e il gioco è fatto.
Se vuoi un solo risultato:
$chiave = array_search(40489, array_column($userdb, "uid"));
Per risultati multipli
$chiavi = array_keys(array_column($userdb, "uid"), 40489);
Se disponi di un array associativo come indicato nei commenti, puoi farlo con:
$chiavi = array_keys(array_combine(array_keys($userdb), array_column($userdb, "uid")),40489);
Se stai utilizzando PHP<5.5.0, вы можете использовать этот backport , спасибо ramsey!
Aggiornamento. Sto facendo alcuni semplici test e il modulo dei risultati multipli sembra essere il più veloce, addirittura più veloce della funzione personalizzata di Jakub!
Nelle versioni successive di PHP (>=5.5.0) puoi utilizzare questa riga:
$chiave = array_search("100", array_column($userdb, "uid"));
Espandendo la funzione creata da @mayhem, questo esempio sarebbe più una ricerca "sfocata" se volessi solo trovare una corrispondenza con parte di ( grande parte) stringhe di ricerca:
Funzione searchArrayKeyVal($sKey, $id, $array) ( foreach ($array as $key => $val) ( if (strpos(strtolower($val[$sKey]), strtolower(trim($id))) ! == false) ( return $chiave; ) ) return false )
Ad esempio, il valore nell'array è Benvenuto a New York! e ti serve solo la prima copia di "New York!"
Ho dovuto usare la funzione un, che trova tutti gli elementi nell'array. Quindi ho modificato la funzione svolta da Jakub Truneček come segue:
Funzione search_in_array_r($needle, $array) ( $found = array(); foreach ($array as $key => $val) ( if ($val == $needle) ( array_push($found, $val); ) ) if (count($trovato) != 0) restituisce $trovato altrimenti restituisce null;
$ricerca1 = "dimostrazione"; $ricerca2 = "bob"; $arr = array("0" => "ciao","1" => "test","2" => "giovanni","3" => array("0" => "martin", "1 " => "bob"),"4" => "demo"); foreach ($arr as $value) ( if (is_array($value)) ( if (in_array($search2, $value)) ( echo "con successo"; //esegui il tuo codice) ) else ( if ($value == $ricerca1) ( echo "successo"; ) ) )
Se possibile, inserire i tipi di parametri. Ma funziona solo con tipi semplici come int, bool e float.
$unsafe_variable = $_POST["user_id"]; $variabile_sicura = (int)$variabile_unsafe; mysqli_query($conn, "INSERISCI I VALORI della tabella (colonna) ("" . $safe_variable . "")");
La programmazione riguarda la sintassi e la semantica. Il primo è determinato dalle regole del linguaggio, il secondo dall'esperienza dello sviluppatore. Per quanto riguarda gli array, lo sviluppatore può caricare specificatamente la sintassi con la semantica. Questo non è ancora un oggetto, ma non è più un array nel senso tradizionale. PHP ti dà la possibilità di creare array di variabili di vario tipo, inclusi se stessi. Un elemento dell'array può essere una funzione, ovvero la capacità di caricare l'array con un algoritmo reale, un significato reale.
La sintassi è stabile, ma cambia da versione a versione e potrebbe non essere sempre compatibile anche dal basso verso l'alto. La portabilità dei programmi è un risultato ben dimenticato del secolo scorso. La semantica si sta evolvendo e può sempre essere applicata non solo in qualsiasi versione di qualsiasi lingua; È diventata una tradizione utilizzare costruzioni sintattiche per esprimere ciò che non era nemmeno previsto dalle regole della lingua. Questo può essere compreso più facilmente usando l'esempio degli array.
Costruzione di array
L'array in PHP ha una sintassi e funzionalità convenienti. Questo può essere descritto in anticipo, ma spesso è conveniente creare array al volo secondo necessità.
pubblico $aNone = array(); // l'array è descritto e non contiene nulla
public $aFact = array("avocado", "pesca", "ciliegia"); // questo array ha tre elementi
Creazione di un array durante il controllo di una condizione:
$cSrcLine = "linea dati analizzata";
per ($i=0; $i<13; $i++) {
if (checkFunc($cSrcLine, $cUserLine) (
$aRisultato = "Sì"; // aggiunge all'array PHP
$aRisultato = "No";
Come risultato dell'esecuzione di questo esempio, verrà creato un array di 13 elementi, i cui valori saranno solo le stringhe “Sì” o “No”. Gli elementi riceveranno indici da 0 a 12. Lo stesso effetto può essere ottenuto scrivendo prima il “futuro” array PHP in una stringa:
$cFutureArray = "";
per ($i=0; $i<13; $i++) {
$cUserLine = inputUserLine(); // inserisci qualcosa
if ($i > 0) ( $cFutureArray .= "|"; )
if (checkFunc($cSrcLine, $cUserLine) ( $cFutureArray .= "Sì";
) altro ( $cFutureArray .= "No"; )
$aRisultato = esplode("|", $cFutureArray);
Array multidimensionali
Molti sistemi di gestione dei contenuti (CMS) utilizzano gli array in grande stile. Da un lato questa è una buona pratica, dall’altro ne rende difficile l’utilizzo. Anche se l'autore comprende la dottrina dell'“array PHP all'interno di un array”, non dovrebbe abusarne: non solo lo sviluppatore dovrà abituarsi alla complessa notazione. Spesso, dopo un po', il creatore stesso ricorderà a lungo ciò che ha scritto all'inizio:
"view_manager" => array(41, "template_path_stack" => array(__DIR__ . "/../view",),
"router" => array("percorsi" => array("saluta" => array(
"tipo" => "Zend\Mvc\Router\Http\Literal",
"opzioni" => array("route" => "/sayhello", "defaults" => array(
"controller" => "Helloworld\Controller\Index", "azione" => "indice",))))),
"controller" => array("invokables" => array(
"Helloworld\Controller\Index" => "Helloworld\Controller\IndexController"))
Questo è un esempio della pratica "array PHP all'interno di un array" di ZF 2. All'inizio non è molto stimolante, ma funziona e probabilmente rende questo framework di successo (esempio da ZendSkeletonApplication/module/Helloworld/config/module.config.php) .
Un array è un costrutto di dati importante durante la progettazione e lo sviluppo. La sua versione multidimensionale un tempo era popolare, ma col tempo è rimasta la necessità di array di massimo due o tre dimensioni. Così è più semplice e chiaro, e dal punto di vista professionale, quando qualcosa comincia a moltiplicarsi, vuol dire che c’è qualcosa che non va nell’enunciato del problema o nel codice.
Semplice, accessibile e comprensibile
Quando si crea un array all'interno di un array in PHP, è meglio limitarsi a due o tre livelli. Nonostante la stabilità e l'affidabilità di PHP, commette errori durante l'elaborazione delle strutture sintattiche. Puoi sopportare questo se disponi di un buon editor di codice e ti abitui a contare accuratamente parentesi e virgole. Tuttavia, PHP non controlla i tipi di dati (questo è il karma della programmazione moderna) e consente allo sviluppatore di praticare errori semantici.
La regola per controllare i tipi di variabili o le proprie idee per trasformare la semantica in sintassi è spesso un lusso insostenibile. Questa è una perdita di velocità dello script, leggibilità del codice, ... perché la semplicità nella codifica è sempre essenziale.
PHP ha una caratteristica negativa significativa: quando sorgono incertezze, lo script semplicemente si blocca. Non tutti i debugger sono in grado di gestire circostanze impreviste e molto dipende dall'esperienza e dall'intuito dello sviluppatore. Quanto più semplice è l'algoritmo, tanto più accessibili sono le informazioni, tanto maggiori sono le possibilità di individuare un errore o di prevenirlo del tutto.
È caratteristico che quando apparvero i primi array, furono proposte varianti di dati sotto forma di strutture: un goffo tentativo di creare qualcosa da diversi tipi di dati. Il primo è sopravvissuto e ha acquisito una nuova sintassi efficace, mentre il secondo è diventato storia.
Array semplici e associativi
La notazione per un array bidimensionale è un'altra coppia di parentesi "[" e "]", ad esempio: $aSrcData significa accedere a un elemento dell'array incluso nell'array $aSrcData. Non è necessario dichiarare i dati in anticipo in PHP. Qualsiasi informazione dichiarata può sempre essere verificata per l'esistenza.
È molto efficace creare qualcosa solo quando è necessario, nella forma in cui era richiesto, e distruggerlo quando la sua necessità è scomparsa. Utilizzando nomi significativi come chiavi (indici), puoi ottenere costrutti leggibili che siano significativi nel contesto della posizione corrente nell'algoritmo:
$aAnketa["nome"] = "Ivanov";
$aAnketa["età"] = 42;
$aAnketa["lavoro"] = "Direttore";
$aAnketa["attivo"] = vero;
$aTabella = $aAnketa;$aAnketa["nome"] = "Petrov";
$aAnketa["età"] = 34;
$aAnketa["lavoro"] = "Direttore";
$aAnketa["attivo"] = vero;
$aTabella = $aAnketa;$aAnketa["nome"] = "Afanasyev";
$aAnketa["età"] = 28;
$aAnketa["lavoro"] = "Lavoratore";
$aAnketa["attivo"] = falso;
$aTabella = $aAnketa;$sUno .= implodere ("; ", $aTable) . "
"; // secondo array PHP in una stringa
$sUno .= $aTabella["lavoro"]; // accede a un elemento del secondo arrayIl risultato di questo esempio (il primo array è normale, le chiavi al suo interno iniziano da 0, il secondo array è associativo, ha quattro chiavi: "nome", "età", "lavoro", "attivo"):
$sUno = "Petrov; 34; Direttore; 1
Manager";Questo semplice esempio mostra come applicare un questionario creato a tutti i dipendenti. Puoi creare un array di dipendenti con indici per numero di personale e, se hai bisogno di un dipendente specifico, selezionarlo per numero di personale.
Se l'organizzazione ha divisioni, o ci sono lavoratori stagionali, o è necessario identificare separatamente i pensionati che lavorano, ... il design "PHP array in a array" è molto conveniente, ma non bisogna mai lasciarsi trasportare dalle dimensioni. Due o tre dimensioni sono il limite per una soluzione efficace.
Tasti per lavorare con gli array
Se prima era importante come era organizzato tutto, negli ultimi anni le tradizioni dell'era binaria, quando il programmatore voleva sapere come venivano memorizzati esattamente gli elementi di un array e voleva avere accesso diretto ad essi, sono state completamente dimenticate. Sono apparse molte codifiche di caratteri che occupano più di un byte in memoria. La parola "bit" ora può essere trovata solo nelle operazioni di ricerca di bit, ma la ricerca in un array PHP è un argomento separato. L'accesso agli elementi può essere semplice e associativo. Nel primo caso, gli elementi dell'array (aventi uno qualsiasi dei tipi disponibili in PHP) sono numerati 0, 1, 2, ... Nel secondo caso, il programmatore specifica il proprio indice, spesso chiamato "chiave", per accedere al valore desiderato.
$aLinea["frutta"] = "arancia"; // qui chiave array PHP = "frutto"
oppure (affinché tutto sia corretto, rispettando la codifica e il codice della pagina):
$aLinea = iconv("UTF-8", "CP1251", "arancione");
Quando si aggiunge un nuovo valore all'array $aLine:
$aLinea = iconv("UTF-8", "CP1251", "pesca");
$aLinea = iconv("UTF-8", "CP1251", "cetriolo");
$aLinea = iconv("UTF-8", "CP1251", "melanzana");come risultato dell'esecuzione del ciclo:
foreach ($aLine as $ck => $cv) (
$cUno.= $ck. "=" . $cv. "
";
}sarà ricevuto:
frutta=arancia
0=pesca
verdura=cetriolo
1=melanzaneLa chiave PHP dell'array quando si aggiungono gli elementi "pesca" e "melanzana" è formata in sequenza da 0 e quando si specifica il suo valore sarà uguale a questo valore.
Rimozione di elementi da un array
Il modo più semplice è durante la sua elaborazione. In questo caso, ad esempio, come risultato dell'esecuzione di un ciclo, l'array originale viene scansionato e ne viene formato uno nuovo, in cui semplicemente non vengono scritti gli elementi non necessari.
Potrebbe essere più semplice. Se applichiamo l'ultimo esempio:
unset($aLinea); // rimuove l'elemento dell'array PHP
quindi il risultato sarà:
frutta=arancia
verdura=cetriolo
1=melanzaneEsistono molte opzioni per manipolare gli elementi dell'array. Ad esempio, utilizzando le funzioni: implode() ed exploit(), puoi scrivere un array PHP in una stringa con un delimitatore e analizzarlo nuovamente in un altro array utilizzando un delimitatore diverso.
Per eliminare semplicemente un intero array in PHP, basta scrivere: unset($aLine);
Questo è abbastanza.
Cerca in un array
PHP contiene funzioni speciali di ricerca e in_array(), ma prima di decidere di utilizzarle, dovresti considerare di eseguire tu stesso le ricerche negli array PHP.
Ogni progetto ha array costruiti specifici, soprattutto quando parte della semantica viene trasferita alla sintassi ed è rappresentata da un insieme di chiavi significative molto specifiche. Ciò consente di eseguire le proprie funzioni di ricerca, che possono anche essere etichettate in modo significativo.
In PHP è possibile chiamare funzioni il cui nome viene determinato durante l'esecuzione del programma. Un esempio molto pratico della libreria PHPWord, che permette di leggere e creare documenti MS Word:
$elementi = array("Testo", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Tabella", "Immagine", "Oggetto", "Nota a piè di pagina",
"Nota di chiusura", "CheckBox", "TextBox", "Campo", "Linea");$funzioni = array();
per ($i = 0; $i< count($elements); $i++) {
$funzioni[$i] = "aggiungi" . $elementi[$i];
}Di conseguenza, l'array $functions riceverà i valori dell'array $elements, ovvero i nomi delle funzioni reali che funzionano con elementi del documento reale.
Chiamando la funzione $functions su $elements, puoi ottenere una ricerca perfetta e risultati rapidi.
Ordinamento degli articoli
Il compito di ordinare i dati è importante e PHP offre diverse funzioni per questo: sort(), rsort(), asort(), ksort(), ... Elementi ascendenti e discendenti, le seconde due funzioni memorizzano le relazioni tra chiavi e valori . A volte ha senso mescolare i valori dell'array in modo casuale: shuffle().
Quando si utilizzano le funzioni PHP per l'ordinamento, non bisogna dimenticare che gli elementi possono non solo avere tipi diversi, ma anche contenuti non del tutto naturali. Prima di tutto, devi fare molta attenzione all'ordinamento delle stringhe contenenti lettere russe, all'ordinamento delle date e ai numeri scritti in diversi formati.
Il modo migliore per scrivere tu stesso una soluzione ideale, almeno nella fase di test dello script, è l'ordinamento manuale. Aiuterà ad anticipare situazioni impreviste.
Array di stringhe
Grazie alle funzioni implode() ed esplode(), un array può essere facilmente trasformato in una stringa e restituito. Ciò consente di archiviare i dati in una rappresentazione compatta ed espanderli in uno stato conveniente secondo necessità.
Un array convertito in una stringa apre nuove possibilità. Ad esempio, il compito di cercare parole chiave in un testo richiede che ciò che si trova non venga aggiunto nuovamente.
$cSrcLine = "Testo Testo ListItemRun TextBox ListItem TextBox Casella di controllo CheckBox TextBox Footnote";
$aSrc = esplode(" ", $cSrcLine);
$cDstLine = "";per ($i=0; $i< count($aSrc); $i++) {
$cTrova = "[" . $aSrc[$i] . "]";
if (! is_integer(strpos($cDstLine, $cFind))) (
$cDstLine .= $cTrova;
}
}
$aDst = esplode("][", $cDstLine);$cUno = implodere("; ", $aDst);
Di conseguenza, la variabile $cOne riceverà solo i valori della stringa sorgente che compaiono una volta lì: "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Footnote".
La lingua russa nelle chiavi e nei significati
Non è consigliabile utilizzare nulla relativo alle codifiche nazionali nelle strutture sintattiche. Il russo, come tutte le altre lingue i cui caratteri si estendono oltre la a-z, non creerà problemi, trovandosi nell'area dati, ma non nella sintassi del codice. A volte anche una semplice attività in PHP "output di un array su una stampante o su uno schermo" porterà a "bug pazzeschi" e più spesso interromperà semplicemente lo script.
PHP è un linguaggio leale e tollerante nei confronti delle codifiche nazionali, ma ci sono molte situazioni in cui la quantità di lavoro completata deve essere rifatta solo perché un valore chiave appare nel posto giusto e al momento giusto, cosa che non è possibile fare. riconoscere.
Sintassi PHP e ambiente linguistico
Va ricordato che la sintassi PHP è una cosa, ma i costrutti di questa sintassi “si occupano” di altre applicazioni, del sistema operativo e delle opzioni hardware. Le opzioni sono tante, non è mai possibile prevedere tutto.
La regola "c'è solo codice nel codice, ma ci sono tutti i tipi di informazioni in ingresso, all'interno e in uscita" aiuterà a evitare sorprese impreviste. Un valore PHP in un array può essere "russo", ma la sua chiave deve essere sintatticamente corretta non solo dal punto di vista della lingua specificata, ma anche dal punto di vista del suo ambiente operativo.
La ricerca di un valore in un array è richiesta in quasi tutte le applicazioni e script PHP che funzionano con i dati, per i quali esistono molti metodi e funzioni speciali. A seconda dell'attività e del tipo di ricerca, è necessario utilizzare determinati strumenti, tenendo conto delle loro caratteristiche, velocità di esecuzione e facilità d'uso. Successivamente, conosceremo le funzioni PHP per la ricerca di elementi in un array, le possibili costruzioni e metodi e scopriremo anche quale metodo è il più veloce.
Funzioni per la ricerca in un array:
array_search- utilizzato per cercare un valore in un array. In caso di successo restituisce la chiave del valore cercato; se non viene trovato nulla restituisce FALSE. Prima di PHP 4.2.0, array_search() restituiva NULL anziché FALSE in caso di errore.La sintassi della funzione mixed array_search (mixed need, array haystack [, bool strict]).
foreach (espressione_array come $valore)
dichiarazione
foreach (espressione_array come $chiave => $valore)
dichiarazioneUn esempio di utilizzo di una funzione con il costrutto foreach per cercare un elemento di un array, restituendo TRUE in caso di successo
Sintassi di costruzione
mentre (espress.)
dichiarazioneRestituisce la chiave di un elemento dell'array in caso di successo
Dalla tabella delle misure si vede che la funzione array_search, mostra i risultati migliori sia durante la ricerca in array piccoli che grandi. Allo stesso tempo, il tempo di ricerca utilizzando i loop aumenta in modo significativo a seconda della dimensione dell'array.
