(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
misto array_search(ago misto, array pagliaio [, bool strict])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 NULL invece di FALSO .
Se passi il valore VERO come terzo parametro opzionale 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.
Esempio 1: esempio di utilizzo array_search()
|
| Attenzione |
Questa funzione può restituire un valore booleano FALSO, un valore non booleano a cui viene eseguito il cast FALSO, ad esempio 0 o "". Per di più informazioni dettagliate vedere la sezione Tipo booleano. Utilizzare l'operatore === per verificare il valore restituito da questa funzione. |
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 di un array utilizzando questa funzione con la consueta ricerca di array in anelli foreach e mentre. 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, forse non tutta la sintassi in 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, cioè “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 semplicemente visualizzare i messaggi, ma eseguire altre azioni. Tutto dipende da cosa devi fare. Ad esempio, se il valore desiderato è nell'array, puoi fornire all'utente alcune informazioni specifiche, ecc.
Per oggi è tutto! 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!
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 array
Il 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 il 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=melanzane
La 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=melanzane
Esistono 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 $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 un semplice compito in PHP "output di un array sulla stampante o sullo schermo" porterà a "bug pazzeschi" e più spesso lo script semplicemente si fermerà.
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.
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à un valore booleano valore FALSO.
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 USA"; ) ?>
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().