Come ottenere la prima parola di una frase in PHP?

Voglio estrarre la prima parola di una variabile da una stringa. Ad esempio, prendi questo input:

<?php $myvalue = 'Test me more'; ?>

L'output risultante dovrebbe essere Test, che è la prima parola dell'input. Come posso fare questo?

Puoi usare la funzione esplodi come segue:

$myvalue = 'Test me more';
$arr = explode(' ',trim($myvalue));
echo $arr[0]; // will print Test

Esiste una funzione di stringa ( strtok ) che può essere utilizzata per dividere una stringa in stringhe ( token ) più piccole in base ad alcuni separatori. Ai fini di questo thread, la prima parola (definita come qualsiasi cosa prima del primo carattere spazio) di Test me morepuò essere ottenuta tokenizzando la stringa sul carattere spazio.

<?php
$value = "Test me more";
echo strtok($value, " "); // Test
?>

Per maggiori dettagli ed esempi, consultare la pagina di manuale di strtok PHP .

Se hai PHP 5.3

$myvalue = 'Test me more';
echo strstr($myvalue, ' ', true);

nota che if $myvalueè una stringa con una parola strstrnon restituisce nulla in questo caso. Una soluzione potrebbe essere quella di aggiungere uno spazio alla stringa di test:

echo strstr( $myvalue . ' ', ' ', true );

Ciò restituirà sempre la prima parola della stringa, anche se la stringa contiene solo una parola

L'alternativa è qualcosa del tipo:

$i = strpos($myvalue, ' ');
echo $i !== false ? $myvalue : substr( $myvalue, 0, $i );

O usando esplodi, che ha così tante risposte che lo usano, non mi preoccuperò di sottolineare come farlo.

Si potrebbe fare

echo current(explode(' ',$myvalue));

Anche se è un po 'tardi, ma PHP ha una soluzione migliore per questo:

$words=str_word_count($myvalue, 1);
echo $words[0];

Simile alla risposta accettata con un passaggio in meno:

$my_value = 'Test me more';
$first_word = explode(' ',trim($my_value))[0];

//$first_word == 'Test'

Nel caso in cui non sei sicuro che la stringa inizi con una parola ...

$input = ' Test me more ';
echo preg_replace('/(\s*)([^\s]*)(.*)/', '$2', $input); //Test

<?php
  $value = "Hello world";
  $tokens = explode(" ", $value);
  echo $tokens[0];
?>

Basta usare esplodi per ottenere ogni parola dell'input e produrre il primo elemento dell'array risultante.

Usando la funzione split puoi anche ottenere la prima parola dalla stringa.

<?php
$myvalue ="Test me more";
$result=split(" ",$myvalue);
echo $result[0];
?>

strtokè più veloce di extracto preg_*funzioni.

$ input = "Mettimi alla prova";
echo preg_replace ("/ \ s. * $ /", "", $ input); // "Test"

personalmente strsplit/ explode/ strtoknon supporta i limiti di parole, quindi per ottenere una divisione più accurata usa un'espressione regolare con il\w

preg_split('/[\s]+/',$string,1);

Ciò dividerebbe le parole con i limiti ad un limite di 1.

$string = ' Test me more ';
preg_match('/\b\w+\b/i', $string, $result); // Test
echo $result;

/* You could use [a-zA-Z]+ instead of \w+ if wanted only alphabetical chars. */
$string = ' Test me more ';
preg_match('/\b[a-zA-Z]+\b/i', $string, $result); // Test
echo $result;

Saluti, Ciul

public function getStringFirstAlphabet($string){
    $data='';
    $string=explode(' ', $string);
    $i=0;
    foreach ($string as $key => $value) {
        $data.=$value[$i];
    }
    return $data;
}

Puoi farlo usando il substr della funzione stringa PHP senza convocare la stringa nell'array.

 $string = 'some text here';
 $stringLength= strlen($string);
 echo ucfirst(substr($string,-$stringLength-1, 1));

// output S

$str='<?php $myvalue = Test me more; ?>';
$s = preg_split("/= *(.[^ ]*?) /", $str,-1,PREG_SPLIT_DELIM_CAPTURE);
print $s[1];

Funzione che tokenizzerà la stringa in due parti, la prima parola e la stringa rimanente.

Valore restituito: avrà rispettivamente firste remainingdigitare l' $returnarray. il primo controllo strpos( $title," ") !== falseè obbligatorio nel caso in cui la stringa contenga solo una parola e non vi sia spazio.

function getStringFirstWord( $title ){

    $return = [];

    if( strpos( $title," ") !== false ) {

        $firstWord = strstr($title," ",true);
        $remainingTitle = substr(strstr($title," "), 1);

        if( !empty( $firstWord ) ) {
            $return['first'] = $firstWord;
        }
        if( !empty( $remainingTitle ) ) {
            $return['remaining'] = $remainingTitle;
        }
    }
    else {
        $return['first'] = $title;
    }

    return $return;
}

$ first_word = str_word_count (1) [0]

Non funziona su caratteri speciali e comporterà un comportamento errato se vengono utilizzati caratteri speciali. Non è compatibile con UTF-8.

Per ulteriori informazioni, controllare PHP str_word_count () multibyte è sicuro?

Dal momento che non è possibile verificare con tratto per maiuscolo o minuscolo, questo funziona perfettamente per il controllo della prima parola.

if (strtolower(strtok($text, " ")) == strtolower($firstword)){ .. }

La tua domanda potrebbe essere riformulata come "sostituisci nella stringa il primo spazio e tutto ciò che segue da niente". Quindi questo può essere ottenuto con una semplice espressione regolare:

$firstWord = preg_replace("/\s.*/", '', ltrim($myvalue));

Ho aggiunto una chiamata opzionale a ltrim () per sicurezza: questa funzione rimuove gli spazi all'inizio della stringa.

Tutte le risposte qui stanno usando un approccio che il processore deve cercare in tutta la stringa anche se viene trovata la prima parola! Per stringhe grandi, questo non è raccomandato. Questo approccio è ottimale:

function getFirstWord($string) {
    $result = "";
    foreach($string as $char) {
        if($char == " " && strlen($result)) {
            break;
        }
        $result .= $char;
    }
    return $result;
}

Se vuoi sapere quanto è veloce ciascuna di queste rispettive funzioni, ho eseguito alcuni benchmark grezzi in PHP 7.3 sulle sei risposte più votate qui ( strposcon substr,explode con current, strstr, explodecon trim, str_word_counte strtok) con 1.000.000 iterazioni ciascuno per confrontare le loro velocità.

<?php

$strTest = 'This is a string to test fetching first word of a string methods.';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    $p = strpos($strTest, ' ');
    $p !== false ? $strTest : substr( $strTest, 0, $p );
}
$after = microtime(true);
echo 'strpos/ substr: '.($after-$before)/$i . ' seconds<br>';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    strstr($strTest, ' ', true);
}
$after = microtime(true);
echo 'strstr: '.($after-$before)/$i . ' seconds<br>';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    current(explode(' ',$strTest));
}
$after = microtime(true);
echo 'explode/ current: '.($after-$before)/$i . ' seconds<br>';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    $arr = explode(' ',trim($strTest));
    $arr[0];
}
$after = microtime(true);
echo 'explode/ trim: '.($after-$before)/$i . ' seconds<br>';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    str_word_count($strTest, 1);
}
$after = microtime(true);
echo 'str_word_count: '.($after-$before)/$i . ' seconds<br>';

$before = microtime(true);
for ($i=0 ; $i<1000000 ; $i++) {
    strtok($value, ' ');
}
$after = microtime(true);
echo 'strtok: '.($after-$before)/$i . ' seconds<br>';

?>

Ecco i risultati variabili da 2 esecuzioni consecutive:

strpos/ substr: 6.0736894607544E-8 seconds
strstr: 5.0434112548828E-8 seconds
explode/ current: 3.5163116455078E-7 seconds
explode/ trim: 3.8683795928955E-7 seconds
str_word_count: 4.6665270328522E-6 seconds
strtok: 4.9849510192871E-7 seconds

strpos/ substr: 5.7171106338501E-8 seconds
strstr: 4.7624826431274E-8 seconds
explode/ current: 3.3753299713135E-7 seconds
explode/ trim: 4.2293286323547E-7 seconds
str_word_count: 3.7025549411774E-6 seconds
strtok: 1.2249300479889E-6 seconds

E i risultati dopo aver invertito l'ordine delle funzioni:

strtok: 4.2612719535828E-7 seconds
str_word_count: 4.1899878978729E-6 seconds
explode/ trim: 9.3175292015076E-7 seconds
explode/ current: 7.0811605453491E-7 seconds
strstr: 1.0137891769409E-7 seconds
strpos/ substr: 1.0082197189331E-7 seconds

Conclusione Si scopre che la velocità tra queste funzioni varia ampiamente e non è coerente tra le esecuzioni di test come ci si potrebbe aspettare. In base a questi test rapidi e sporchi, una delle sei funzioni scelte eseguirà il lavoro in un ragionevole lasso di tempo. Vi sono perturbazioni, inclusi altri processi in esecuzione, che interferiscono con i tempi di esecuzione. Quindi basta usare qualunque funzione abbia il senso più pratico e leggibile per te come programmatore. Per un quadro di programmazione più ampio, vedere la Programmazione letteraria di Donald Knuth .