Réponses:
Vous pouvez utiliser la fonction d' éclatement comme suit:
$myvalue = 'Test me more';
$arr = explode(' ',trim($myvalue));
echo $arr[0]; // will print Test
explode(' ',trim($myvalue))[0]
list($firstword) = explode(' ', trim($myvalue), 1);
limit
paramètre doit être 2 car il doit inclure le dernier élément qui contient le reste de la chaîne; 1 retournerait simplement la même chaîne. À moins qu'un grand tableau ne soit créé, j'irais avec la version Elliot pour une seule ligne.
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 more
peut ê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 .
strtok
est une fonction étrange et dangereuse qui détient un état global. L'utilisation de cette fonction doit être déconseillée.
Si vous avez PHP 5.3
$myvalue = 'Test me more';
echo strstr($myvalue, ' ', true);
notez que if $myvalue
est une chaîne avec un mot strstr
ne 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.
strstr
soit disponible en PHP car 4.3.0
il ne l'était pas avant 5.3.0
, lorsque le paramètre facultatif before_needle
(que vous utilisez dans cet exemple) a été ajouté. Juste un avis, parce que j'étais confus, pourquoi vous dites que cet exemple a besoin 5.3.0
.
echo $i === false ? $myvalue : substr( $myvalue, 0, $i );
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'
personnellement strsplit
/ explode
/ strtok
ne 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 first
et remaining
clé $return
respectivement tableau. La première vérification strpos( $title," ") !== false
est 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?
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 ( strpos
avec substr
, explode
avec current
, strstr
, explode
avec trim
, str_word_count
et 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 .
s($str)->words()[0]
utile, comme trouvé dans cette bibliothèque autonome .