Come Verificare se una Stringa Contiene una Parola Specifica in PHP?

Come funziona la funzione strpos()

La funzione strpos() accetta due parametri:

1. $haystack: La stringa in cui cercare.
2. $needle: La sottostringa da cercare.

Restituisce un numero intero che rappresenta l'indice della prima occorrenza dell'ago nel pagliaio, o false se l'ago non viene trovato.

Da notare che strpos() effettua una ricerca sensibile alle maiuscole/minuscole. Ciò significa che considera le lettere maiuscole e minuscole durante la ricerca della sottostringa.

Ecco un esempio di come utilizzare strpos() per verificare se una stringa contiene una parola:

$parola = "volpe";
$miastringa = "La veloce volpe marrone salta sopra il cane pigro";

// Verifica se la stringa contiene la parola
if (strpos($miastringa, $parola) !== false) {
    echo "Parola trovata!";
} else {
    echo "Parola non trovata!";
}

In questo codice:

• Impostiamo la variabile $parola come la sottostringa che vogliamo cercare, che è "volpe".
• Abbiamo anche la variabile $miastringa che contiene la frase in cui vogliamo cercare la parola.
• Usiamo la funzione strpos() per verificare se $miastringa contiene $parola.
  • Se la parola viene trovata, strpos() restituisce l'indice della sua prima occorrenza.
  • Se la parola non viene trovata, strpos() restituisce false.
• La condizione strpos($miastringa, $parola) !== false verifica se il valore restituito non è false.
  • Se la parola viene trovata, la condizione è vera e viene eseguito il codice nel blocco if, stampando "Parola trovata!".
  • Se la parola non viene trovata, viene eseguito il blocco else, stampando "Parola non trovata!".

$email = "utente@esempio.com";
$dominio = "esempio.com";

if (strpos($email, $dominio) !== false) {
    echo "Dominio email valido!";
} else {
    echo "Dominio email non valido!";
}

Differenze tra le funzioni strpos() e stripos()

PHP ha anche la funzione stripos(), che è simile a strpos() ma effettua una ricerca non sensibile alle maiuscole/minuscole. Ciò significa che stripos() non considera le lettere maiuscole e minuscole durante la ricerca della sottostringa.

Useresti strpos() quando hai bisogno di fare una ricerca sensibile alle maiuscole/minuscole e vuoi trovare l'esatta corrispondenza della sottostringa. Useresti stripos() quando il caso della sottostringa non è importante e vuoi trovare la sottostringa indipendentemente dal suo caso.

Ecco un esempio per mostrare la differenza:

$parola = "Volpe";
$miastringa = "La veloce volpe marrone salta sopra il cane pigro";

if (strpos($miastringa, $parola) !== false) {
    echo "Parola trovata usando strpos()!";
} else {
    echo "Parola non trovata usando strpos()!";
}

if (stripos($miastringa, $parola) !== false) {
    echo "Parola trovata usando stripos()!";
} else {
    echo "Parola non trovata usando stripos()!";
}

In questo caso:

• strpos() restituirebbe "Parola non trovata!" perché effettua una ricerca sensibile alle maiuscole/minuscole e la sottostringa "Volpe" (con la "V" maiuscola) non esiste nella stringa.
• stripos() restituirebbe "Parola trovata!" perché effettua una ricerca non sensibile alle maiuscole/minuscole e trova la sottostringa "volpe" (con la "v" minuscola) nella stringa.

Confronto di strpos() con altre funzioni di ricerca nelle stringhe

PHP ha altre funzioni per la ricerca nelle stringhe, come strstr(), stristr(), strrchr() e strpbrk(). Ecco un confronto di queste funzioni:

$miastringa = "La veloce volpe marrone salta sopra il cane pigro";

// Uso di strpos()
$posizione = strpos($miastringa, "volpe");
echo "Posizione di 'volpe' usando strpos(): " . $posizione . "\n";

// Uso di strstr()
$sottostringa = strstr($miastringa, "marrone");
echo "Sottostringa da 'marrone' usando strstr(): " . $sottostringa . "\n";

// Uso di stristr()
$sottostringa = stristr($miastringa, "SALTA");
echo "Sottostringa da 'SALTA' usando stristr(): " . $sottostringa . "\n";

// Uso di strrchr()
$sottostringa = strrchr($miastringa, "o");
echo "Sottostringa dall'ultima 'o' usando strrchr(): " . $sottostringa . "\n";

// Uso di strpbrk()
$sottostringa = strpbrk($miastringa, "aeiou");
echo "Sottostringa dalla prima vocale usando strpbrk(): " . $sottostringa . "\n";

Posizione di 'volpe' usando strpos(): 10
Sottostringa da 'marrone' usando strstr(): marrone salta sopra il cane pigro
Sottostringa da 'SALTA' usando stristr(): salta sopra il cane pigro
Sottostringa dall'ultima 'o' usando strrchr(): o
Sottostringa dalla prima vocale usando strpbrk(): a veloce volpe marrone salta sopra il cane pigro

Funzione str_contains()

La funzione str_contains() è una novità di PHP 8 che consente di verificare se una stringa contiene una sottostringa. Restituisce un valore booleano che indica se la sottostringa è stata trovata all'interno della stringa.

Questa funzione fornisce un modo più semplice per eseguire questo compito comune rispetto all'uso di strpos() o stripos(), che richiedono ulteriori controlli sul valore restituito.

Sintassi e utilizzo di str_contains()

La funzione str_contains() ha questa sintassi:

str_contains(string $haystack, string $needle): bool

• $haystack: La stringa in cui cercare.
• $needle: La sottostringa da cercare.

La funzione restituisce true se $needle viene trovato all'interno di $haystack, e false in caso contrario.

Ecco un esempio di come usare str_contains() per verificare se una stringa contiene una parola specifica:

$testo = "La veloce volpe marrone salta sopra il cane pigro";
$parola = "volpe";

if (str_contains($testo, $parola)) {
    echo "La parola '$parola' è presente nel testo.";
} else {
    echo "La parola '$parola' non è presente nel testo.";
}

In questo esempio, str_contains() verifica se la stringa $testo contiene la parola $parola. Poiché la parola "volpe" è presente nel testo, la funzione restituisce true e viene stampato il messaggio "La parola 'volpe' è presente nel testo.".

Vantaggi dell'uso di str_contains() rispetto ad altri metodi

L'uso di str_contains() presenta vantaggi rispetto ad altri metodi come strpos() e stripos():

1. Migliore leggibilità: Il nome della funzione str_contains() indica chiaramente il suo scopo, rendendo il codice più leggibile. Elimina la necessità di ulteriori controlli sul valore restituito, poiché restituisce un booleano.

2. Semplicità: Con str_contains(), puoi verificare se una stringa contiene una sottostringa con una sola chiamata di funzione. Non è necessario confrontare il valore restituito con false o 0, come richiesto con strpos() e stripos().

3. Migliori prestazioni: La funzione str_contains() è ottimizzata per le prestazioni ed è più veloce rispetto all'uso di strpos() o stripos() nella maggior parte dei casi. Evita di restituire laposizione della sottostringa, che non è necessaria quando si vuole solo sapere se la sottostringa esiste.

Utilizzo di preg_match() per verificare se una stringa contiene una parola

La funzione preg_match() in PHP permette di verificare se una stringa corrisponde a un pattern di espressione regolare. Puoi usarla per controllare se una stringa contiene una parola specifica.

La funzione preg_match() ha questa sintassi:

preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false

• $pattern: Il pattern dell'espressione regolare da confrontare.
• $subject: La stringa in cui cercare.
• $matches: (Opzionale) Un array da riempire con i risultati della ricerca.
• $flags: (Opzionale) Flag per modificare il comportamento della ricerca.
• $offset: (Opzionale) L'offset nella stringa da cui iniziare la ricerca.

La funzione restituisce il numero di corrispondenze trovate (0 o 1), o false in caso di errore.

Ecco un esempio di utilizzo di preg_match() per verificare se una stringa contiene una parola:

$testo = "La veloce volpe marrone salta sopra il cane pigro";
$parola = "volpe";
$pattern = "/\b$parola\b/";

if (preg_match($pattern, $testo)) {
    echo "La parola '$parola' è presente nella stringa.";
} else {
    echo "La parola '$parola' non è presente nella stringa.";
}

In questo codice:

• La variabile $testo contiene la stringa in cui cercare.
• La variabile $parola contiene la parola da cercare.
• La variabile $pattern contiene il pattern dell'espressione regolare. Usa l'ancora \b per far corrispondere i confini delle parole, assicurandosi che vengano trovate solo parole intere (quindi "volpe" non corrisponderà a "volpetta").
• preg_match() verifica se il $pattern corrisponde al $testo.
  • Se viene trovata una corrispondenza, restituisce 1 e viene stampato il messaggio "parola trovata".
  • Se non viene trovata alcuna corrispondenza, restituisce 0 e viene stampato il messaggio "parola non trovata".

Puoi anche usare il parametro $matches per ottenere il testo corrispondente:

if (preg_match($pattern, $testo, $matches)) {
    echo "Testo corrispondente: " . $matches[0];
}

Questo stamperebbe: "Testo corrispondente: volpe".

Vantaggi e svantaggi dell'uso delle espressioni regolari

Le espressioni regolari hanno vantaggi e svantaggi quando si verifica se una stringa contiene una parola.

Vantaggi

• Flessibilità: Le regex possono far corrispondere pattern complessi, non solo parole specifiche. Puoi usare classi di caratteri, ancore, quantificatori e altro per definire pattern precisi.
• Potenza: Con le regex, puoi fare più che semplicemente verificare se una stringa contiene una parola. Puoi ottenere parti della stringa, sostituire testo, dividere la stringa e altro ancora.

Svantaggi

• Complessità: La sintassi delle regex può essere difficile da leggere e scrivere, specialmente per pattern complessi. Questo può rendere il codice più difficile da capire e mantenere.
• Prestazioni: Per ricerche di testo semplici, l'uso di regex potrebbe essere più lento rispetto all'uso di funzioni per stringhe come strpos() o str_contains(). Le regex devono compilare il pattern e poi cercare nella stringa, il che richiede tempo.

Utilizzo della funzione strstr()

La funzione strstr() in PHP è un altro modo per verificare se una stringa contiene una parola specifica. Cerca la prima occorrenza di una sottostringa in una stringa e restituisce il resto della stringa da quel punto in poi.

La sintassi di strstr() è la seguente:

strstr(string $haystack, string $needle, bool $before_needle = false): string|false

• $haystack: La stringa in cui cercare.
• $needle: La sottostringa da cercare.
• $before_needle: (Opzionale) Se impostato a true, la funzione restituisce la parte della stringa prima della prima occorrenza della sottostringa. Il valore predefinito è false.

Ecco un esempio di utilizzo di strstr() per verificare se una stringa contiene una parola:

$testo = "La veloce volpe marrone salta sopra il cane pigro";
$parola = "volpe";

if (strstr($testo, $parola)) {
    echo "La parola '$parola' è presente nella stringa.";
} else {
    echo "La parola '$parola' non è presente nella stringa.";
}

In questo esempio, strstr() cerca la parola "volpe" nella stringa $testo. Se la parola viene trovata, la funzione restituisce la sottostringa dalla prima occorrenza di "volpe" fino alla fine della stringa. La condizione if (strstr($testo, $parola)) verifica se il valore restituito è truthy (non false), indicando che la parola è stata trovata.

$prodotti = [
    "Apple iPhone 12 Pro Max - 128GB - Blu Pacifico",
    "Samsung Galaxy S21 Ultra 5G - 256GB - Nero Fantasma",
    "Google Pixel 5 - 128GB - Nero"
];

$parolaChiave = "iPhone";

foreach ($prodotti as $prodotto) {
    if (strstr($prodotto, $parolaChiave)) {
        echo "Il prodotto '$prodotto' contiene la parola chiave '$parolaChiave'.
";
    }
}

Il prodotto 'Apple iPhone 12 Pro Max - 128GB - Blu Pacifico' contiene la parola chiave 'iPhone'.

Divisione della stringa in un array con explode()

Un altro approccio per verificare se una stringa contiene una parola specifica è quello di dividere la stringa in un array di parole usando la funzione explode() e poi verificare se la parola esiste nell'array.

La funzione explode() divide una stringa in un array in base a un delimitatore specificato. Ecco la sintassi:

explode(string $separator, string $string, int $limit = PHP_INT_MAX): array

• $separator: Il delimitatore usato per dividere la stringa.
• $string: La stringa da dividere.
• $limit: (Opzionale) Il numero massimo di elementi da restituire nell'array. Il valore predefinito è PHP_INT_MAX.

Ecco un esempio di utilizzo di explode() per verificare se una stringa contiene una parola:

$testo = "La veloce volpe marrone salta sopra il cane pigro";
$parola = "volpe";

$arrayParole = explode(" ", $testo);

if (in_array($parola, $arrayParole)) {
    echo "La parola '$parola' è presente nella stringa.";
} else {
    echo "La parola '$parola' non è presente nella stringa.";
}

In questo codice, explode(" ", $testo) divide la stringa $testo in un array di parole usando lo spazio come delimitatore. L'array risultante $arrayParole contiene ogni parola della stringa come elemento separato.

La funzione in_array() viene poi usata per verificare se la parola $parola esiste nell'$arrayParole. Se la parola viene trovata, la funzione restituisce true e viene stampato il messaggio corrispondente.

$inputUtente = "mela, samsung, google";
$paroleChiave = explode(", ", $inputUtente);

// Cerca prodotti che contengono una qualsiasi delle parole chiave
$prodotti = [
    "Apple iPhone 12 Pro Max - 128GB - Blu Pacifico",
    "Samsung Galaxy S21 Ultra 5G - 256GB - Nero Fantasma",
    "Google Pixel 5 - 128GB - Nero"
];

foreach ($prodotti as $prodotto) {
    foreach ($paroleChiave as $parolaChiave) {
        if (strstr($prodotto, $parolaChiave)) {
            echo "Il prodotto '$prodotto' corrisponde alla parola chiave '$parolaChiave'.
";
        }
    }
}

Il prodotto 'Apple iPhone 12 Pro Max - 128GB - Blu Pacifico' corrisponde alla parola chiave 'mela'.
Il prodotto 'Samsung Galaxy S21 Ultra 5G - 256GB - Nero Fantasma' corrisponde alla parola chiave 'samsung'.
Il prodotto 'Google Pixel 5 - 128GB - Nero' corrisponde alla parola chiave 'google'.

Confronto della stringa con la parola usando operatori identici

Puoi anche verificare se una stringa contiene una parola specifica confrontando direttamente la stringa con la parola usando l'operatore identico ===.

Ecco un esempio:

$testo = "volpe";
$parola = "volpe";

if ($testo === $parola) {
    echo "La stringa è identica alla parola '$parola'.";
} else {
    echo "La stringa non è identica alla parola '$parola'.";
}

In questo caso, la stringa $testo viene confrontata direttamente con la parola $parola usando l'operatore ===. Se la stringa e la parola sono identiche, la condizione if ($testo === $parola) restituisce true e viene stampato il messaggio corrispondente.

Tuttavia, questo metodo ha delle limitazioni:

• Funziona solo se la stringa corrisponde esattamente alla parola. Se la stringa contiene caratteri aggiuntivi o la parola è una sottostringa della stringa, il confronto restituirà false.
• È sensibile alle maiuscole/minuscole. Se la stringa e la parola hanno casi diversi, il confronto restituirà false.

Pertanto, questo metodo è adatto solo quando si vuole verificare se una stringa è identica a una parola specifica, piuttosto che verificare se la stringa contiene la parola come sottostringa.

$categorie = ["Elettronica", "Abbigliamento", "Casa"];
$categoriaProdotto = "Elettronica";

if (in_array($categoriaProdotto, $categorie, true)) {
    echo "La categoria del prodotto '$categoriaProdotto' è valida.";
} else {
    echo "La categoria del prodotto '$categoriaProdotto' non è valida.";
}