Php cerca in un array per parte del valore. PHP: array_search - ricerca rapida di array

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 interrompe l'esecuzione. 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().

(PHP 4 >= 4.0.5, PHP 5)

array_search: cerca un determinato valore in un array e restituisce la chiave corrispondente in caso di successo

Descrizione

Cerca nel pagliaio il valore dell'ago e restituisce la chiave se è presente nell'array, FALSO Altrimenti.

Commento: Se l'ago è una stringa, viene eseguito un confronto con distinzione tra maiuscole e minuscole.

Commento: Fino a PHP 4.2.0, array_search() restituito in caso di esito negativo NULLO invece di FALSO .

Se passi il valore VERO come terzo parametro opzionale per strict , la funzione array_search() controllerà anche il tipo di ago nella matrice del pagliaio.

Se l'ago è presente nel pagliaio più di una volta, verrà restituita la prima chiave trovata. Per restituire le chiavi per tutti i valori trovati, utilizzare la funzione array_keys() con un parametro search_value facoltativo.

Utilizzo la funzione array_search() da molto tempo per cercare valori in un array, poiché ho ripetutamente sentito e letto che funziona notevolmente più velocemente rispetto alla ricerca in un array in un ciclo, ma non l'ho fatto sapere quanto è più veloce. Alla fine sono riuscito a controllarlo e contarlo io stesso.

Ho confrontato la velocità di ricerca in un array utilizzando questa funzione con la normale ricerca in un array nei cicli foreach e while. Su 10-100 elementi dell'array la differenza è impercettibile e il tempo è così breve che può essere trascurato. Ma per gli array di grandi dimensioni la differenza si è rivelata piuttosto significativa. Poiché la dimensione dell'array aumentava di un ordine di grandezza, anche il tempo di ricerca aumentava in modo significativo. Con centomila elementi, la velocità di foreach è scesa a 0,013 secondi, e mentre - a 0,017, mentre anche array_search() ha rallentato, ma è rimasto comunque un ordine di grandezza più veloce - 0,004 secondi. Per uno script di grandi dimensioni che funziona con array di grandi dimensioni, sostituire una ricerca in un ciclo con una ricerca utilizzando array_search() non sarà affatto una "ottimizzazione delle pulci".

A questo proposito, mi sono ricordato di una recente discussione con uno dei miei colleghi di lavoro sulla necessità che un programmatore conosca tutte queste funzioni del linguaggio integrate o se siano sufficienti una “mentalità da programmatore” e una conoscenza generale. Senza entrare in una discussione proprio su questa mentalità, penso che sia comunque necessario conoscere le funzioni, magari non tutta la sintassi nel dettaglio, ma almeno quali funzioni ci sono e cosa possono fare in termini generali.

UPD: serve anche una mentalità da programmatore! E fare attenzione alla memoria non farà male (ispirato da break and range:)

Sotto l'hack c'è il codice dello script utilizzato per calcolare il tempo:

$massa=100000; // numero di valori nell'array in cui effettueremo la ricerca
$ricerca=50000; // cercheremo questo valore nell'array
$primo_risultato=array(); // array di risultati per calcolare il valore medio della prima opzione
$secondo_risultato=array(); // array di risultati per calcolare il valore medio della seconda opzione
$terzo_risultato=array(); // array di risultati per calcolare il valore medio della terza opzione

// crea e riempie l'array
$array_test = intervallo(0, $massa-1); // grazie a SelenIT))

/*
$array_test=array();
per ($i=0; $i<$mass; $i++)
{
$array_test=$i;
}
*/

// esegue un ciclo per calcolare i valori medi
per ($d=0; $d<30; $d++) {

//*************** Cerca utilizzando array_search ******************

// Inizia a contare il tempo
$inizio_tempo = microtempo(1);
// ricerca
$key = array_search($search, $test_array, true);
// se trovato
if ($key!==FALSE) // è necessario!== e non!=, perché il numero del primo elemento è 0
{
echo $test_array[$chiave];
}
$fine_tempo = microtempo(1);
// fine del conteggio del tempo

// scrive in un array di valori
$primo_risultato= $fine_ora - $inizio_ora;

//**************** Cerca in un array con un ciclo foreach ******************

// Inizia a contare il tempo
$inizio_tempo = microtempo(1);
// la ricerca stessa
foreach ($test_array come $ta)
{
se ($ta==$cerca)
{
echo $ta;
rottura;
}
}
$fine_tempo = microtempo(1);
// fine del conteggio del tempo

// scrive in un array di valori
$risultato_secondo= $fine_ora - $inizio_ora;

//**************** Cerca in un array con un ciclo while ******************

// Inizia a contare il tempo
$inizio_tempo = microtempo(1);

// determina la lunghezza dell'array
$conteggio=conteggio($array_test);
$j=0;
// la ricerca stessa
mentre ($j<$count)
{
if ($test_array[$j]==$search) // se trovato
{
echo $array_test[$j];
rottura;
}
$j++;
}
$fine_tempo = microtempo(1);
// fine del conteggio del tempo

// scrive in un array di valori
$terzo_risultato= $fine_ora - $inizio_ora;
}

$srednee1=array_sum($primo_risultato)/count($primo_risultato);
$srednee2=array_sum ($second_result)/count($second_result);
$srednee3=array_sum ($terzo_risultato)/count($terzo_risultato);

Printf("primo codice completato in media: %.7f secondi", $srednee1);
printf("secondo codice completato in media in: %.7f secondi", $srednee2);
printf("il terzo codice è stato completato in media in: %.7f secondi", $srednee3);

// risultato:
// primo codice completato in media: 0,0000295 secondi
// secondo codice completato in media: 0,0153386 secondi
// terzo codice completato in media: 0,0226001 secondi

Spesso quando si scrive codice è necessario verificare se un particolare valore di elemento esiste in un array. Oggi esamineremo diverse funzioni con cui puoi farlo.

Il controllo della presenza del valore di un elemento in un array può essere utilizzato per risolvere vari problemi di programmazione.

Possiamo ottenere vari array dal nostro database e verificare la presenza di un valore particolare al suo interno. Il valore desiderato può essere trasmesso anche dall'utente del nostro script quando, ad esempio, sta cercando qualcosa. In base ai risultati di tale ricerca, puoi eseguire determinate azioni. Tutto dipende dall'attività specifica da svolgere, tuttavia gli algoritmi per la ricerca di un valore in un array saranno gli stessi.

Oggi li guarderemo.

Verifica della presenza di un valore in un array. funzione in_array()

Funzione in_array() ci permetterà di verificare la presenza di qualsiasi valore nell'array.

Se il risultato del suo lavoro ha esito positivo e l'elemento desiderato viene trovato nell'array, la funzione restituirà VERO, Questa è la verità."

La funzione accetta 2 parametri obbligatori:<Что ищем>E<Где ищем>.

Può anche richiedere un altro parametro facoltativo:<Тип данных>. Se questo terzo parametro opzionale è impostato su VERO, viene controllato anche il tipo di dati. Cioè, “2” e 2 non saranno la stessa cosa. Nel primo caso è una stringa, nel secondo è un numero. E poi l'intera funzione in_array() non restituirà un valore VERO.

È inoltre necessario ricordare che la funzione esegue confronti con distinzione tra maiuscole e minuscole.

Diamo un'occhiata a come funziona questa funzione utilizzando un semplice esempio.
Abbiamo bisogno di una sorta di array. Utilizzando la funzione, verificheremo la presenza di un valore nell'array e visualizzeremo un messaggio specifico sullo schermo.

Dopo l'esecuzione, la funzione visualizzerà il messaggio “Sì”, poiché nel nostro array è presente l'elemento “Marina”.

Cambia il primo parametro nella funzione in un elemento inesistente e vedrai il messaggio "No".

Verifica della presenza di un valore in un array. funzione array_search()

C'è un'altra funzione di ricerca array_search(), che, a differenza del precedente, restituirà la chiave dell'elemento trovato. Questo, a sua volta, può essere utile se stiamo lavorando con un array associativo.

La funzione accetta gli stessi parametri della precedente. In questo caso anche il terzo parametro è facoltativo.

Vediamo come può essere utilizzato quando si lavora con un array associativo.

"ottobre","soldi"=>200,"nome"=>"Mila"); $chiave = array_search("Mila",$Mass1); if($tasto) echo $tasto; ?>

In questo caso vedremo sullo schermo il “nome”, cioè la chiave dell'elemento desiderato con il valore “Mila”.

Queste due funzioni sono molto simili e differiscono essenzialmente solo nel valore restituito.

Trovare un valore in un array multidimensionale

Ma cosa succede se lavoriamo con un array multidimensionale? Dopotutto, i suoi elementi saranno altri array.

Qui gli algoritmi di cui abbiamo già parlato non funzioneranno.

In realtà non è così complicato, devi solo complicare un po' l'intero meccanismo e usare un loop, ad esempio, per ciascuno(), che funziona benissimo con gli array.

Diciamo che abbiamo un array multidimensionale. I suoi valori immediati sono altri array che possono contenere il valore desiderato dell'elemento.

Tutto quello che devi fare è scorrere gli elementi dell'array originale per ciascuno(). Ogni elemento di questo array verrà analizzato in una chiave ($key) e un valore ($value).

Il valore sarà ciascuno degli array situati all'interno dell'array multidimensionale principale. Lavoreremo con questi valori, cercando in ogni array interno il valore dell'elemento desiderato.

Se trovato, visualizzeremo un messaggio che informa che tale elemento esiste e, in caso contrario, visualizzeremo un altro messaggio che tale elemento non esiste.

Vediamo tutto questo con il codice di esempio:

"anna","id"=>234); $Massa2 = array("nome"=>"anton","id"=>24); $Massa2 = array("nome"=>"ivan","id"=>007); foreach($Mass2 as $chiave => $valore) ( ​​$nome .= in_array("ivan",$valore); ) if($nome) echo "OK! Elemento qui!"; else echo "Nessun elemento presente!"; ?>

Come puoi vedere, per prima cosa dichiariamo l'array multidimensionale stesso.

Inoltre, qui devi scrivere non solo un segno di uguale, ma “.=".

Questo viene fatto in modo che la variabile $name non venga sovrascritta ad ogni iterazione, ma venga integrata. Dopotutto, se alla prima iterazione viene trovato un elemento e il valore "true" viene scritto nella variabile $name, ma alla seconda iterazione (cioè nel secondo array interno) il valore desiderato dell'elemento non è presente , il valore della variabile $name verrà semplicemente sovrascritto e alla fine semplicemente non otterremo il risultato corretto.

Come hai capito, il risultato di questo codice sarà il messaggio “OK! L'elemento è qui!

Prova a cambiare l'elemento che stai cercando con uno inesistente e vedrai il messaggio "Nessun elemento presente!"

Naturalmente, quando un determinato elemento viene trovato o non trovato, non possiamo limitarci a visualizzare i messaggi, ma eseguire anche altre azioni. Tutto dipende da cosa devi fare. Ad esempio, se il valore desiderato è nell'array, puoi fornire all'utente alcune informazioni specifiche, ecc.

È tutto per oggi! Spero che la lezione sia stata chiara e utile! Prova a scrivere tu stesso un codice simile per comprendere appieno tutto.

E aspetto i tuoi commenti.

Condividi la lezione con i tuoi amici utilizzando i pulsanti social. reti situate sotto. E iscriviti anche agli aggiornamenti del blog. Abbiamo già raccolto un archivio abbastanza buono di materiali utili e verranno solo reintegrati!

Ti auguro una programmazione di successo!

Anna Kotelnikova era con te!