Comment obtenir le premier mot d'une phrase en PHP?

Je veux extraire le premier mot d'une variable d'une chaîne. Par exemple, prenez cette entrée:

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

La sortie résultante doit être Test, qui est le premier mot de l'entrée. Comment puis-je faire ceci?

Vous pouvez utiliser la fonction d' éclatement comme suit:

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

Il existe une fonction de chaîne ( strtok ) qui peut être utilisée pour diviser une chaîne en chaînes plus petites ( jetons ) en fonction de certains séparateurs. Pour les besoins de ce fil, le premier mot (défini comme tout avant le premier caractère d'espace) de Test me morepeut être obtenu en marquant la chaîne sur le caractère d'espace.

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

Pour plus de détails et d'exemples, consultez la page de manuel PHP strtok .

Si vous avez PHP 5.3

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

notez que if $myvalueest une chaîne avec un mot strstrne renvoie rien dans ce cas. Une solution pourrait être d'ajouter un espace à la chaîne de test:

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

Cela renverra toujours le premier mot de la chaîne, même si la chaîne ne contient qu'un seul mot

L'alternative est quelque chose comme:

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

Ou en utilisant exploser, qui a tellement de réponses que je ne prendrai pas la peine de montrer comment le faire.

Vous pourriez faire

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

Même s'il est peu tard, PHP a une meilleure solution pour cela:

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

Similaire à la réponse acceptée avec une étape en moins:

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

//$first_word == 'Test'

Juste au cas où vous n'êtes pas sûr que la chaîne commence par un mot ...

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

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

Utilisez simplement exploser pour obtenir chaque mot de l'entrée et sortir le premier élément du tableau résultant.

En utilisant la fonction de fractionnement, vous pouvez également obtenir le premier mot de la chaîne.

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

strtokest plus rapide que extractou preg_*fonctionne.

$ input = "Testez-moi davantage";
echo preg_replace ("/ \ s. * $ /", "", $ entrée); // "Test"

personnellement strsplit/ explode/ strtokne prend pas en charge les limites de mots, donc pour obtenir un partage plus précis, utilisez une expression régulière avec\w

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

Cela diviserait les mots avec des limites jusqu'à une limite de 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;

Cordialement, Ciul

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

Vous pouvez le faire en utilisant la fonction de chaîne PHP substr sans convertir la chaîne en tableau.

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

//les sorties

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

Fonction qui segmentera la chaîne en deux parties, le premier mot et la chaîne restante.

Valeur de retour: Il aura firstet remainingclé $returnrespectivement tableau. La première vérification strpos( $title," ") !== falseest obligatoire dans le cas où la chaîne ne contient qu'un seul mot et pas d'espace.

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]

Ne fonctionne pas sur les caractères spéciaux et entraînera un comportement incorrect si des caractères spéciaux sont utilisés. Ce n'est pas compatible UTF-8.

Pour plus d'informations, vérifiez si PHP str_word_count () est sécurisé sur plusieurs octets?

Puisque vous ne pouvez pas vérifier avec le trait pour les majuscules ou les minuscules, cela fonctionne parfaitement pour vérifier le premier mot.

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

Votre question pourrait être reformulée comme "remplacer dans la chaîne le premier espace et tout ce qui suit par rien". Cela peut donc être réalisé avec une simple expression régulière:

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

J'ai ajouté un appel optionnel à ltrim () pour être sûr: cette fonction supprime les espaces au début de la chaîne.

Toutes les réponses ici utilisent une approche selon laquelle le processeur doit rechercher toute la chaîne même si le premier mot est trouvé! Pour les grosses cordes, ce n'est pas recommandé. Cette approche est optimale:

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

Si vous voulez savoir à quelle vitesse chacune de ces fonctions est, j'ai couru une analyse comparative brut en PHP 7.3 sur les six réponses les plus voté ici ( strposavec substr, explodeavec current, strstr, explodeavec trim, str_word_countet strtok) avec 1.000.000 itérations chacun pour comparer leurs vitesses.

<?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>';

?>

Voici les différents résultats de 2 exécutions consécutives:

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

Et les résultats après avoir inversé l'ordre des fonctions:

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

Conclusion Il s'avère que la vitesse entre ces fonctions varie considérablement et n'est pas aussi cohérente entre les exécutions de test que vous pourriez vous y attendre. Selon ces tests rapides et sales, n'importe laquelle des six fonctions choisies fera le travail dans un laps de temps raisonnable. Il y a des perturbations, y compris d'autres processus en cours d'exécution qui interfèrent avec les temps d'exécution. Alors utilisez simplement la fonction qui vous convient le mieux en tant que programmeur. Pour une vue d'ensemble de la programmation, voir Literate Programming de Donald Knuth .