¿Cómo obtener la primera palabra de una oración en PHP?

Quiero extraer la primera palabra de una variable de una cadena. Por ejemplo, tome esta entrada:

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

La salida resultante debería ser Test, que es la primera palabra de la entrada. ¿Cómo puedo hacer esto?

Puede usar la función de explosión de la siguiente manera:

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

Hay una función de cadena ( strtok ) que se puede usar para dividir una cadena en cadenas más pequeñas ( tokens ) en función de algunos separadores. Para los propósitos de este hilo, la primera palabra (definida como cualquier cosa antes del primer carácter de espacio) de Test me morepuede obtenerse tokenizando la cadena en el carácter de espacio.

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

Para obtener más detalles y ejemplos, consulte la página del manual de PHP strtok .

Si tienes PHP 5.3

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

Tenga en cuenta que si $myvaluees una cadena con una palabra strstrno devuelve nada en este caso. Una solución podría ser agregar un espacio a la cadena de prueba:

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

Eso siempre devolverá la primera palabra de la cadena, incluso si la cadena tiene solo una palabra

La alternativa es algo como:

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

O usando explotar, que tiene tantas respuestas que lo usaré que no me molestaré en señalar cómo hacerlo.

Podrías hacerlo

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

Aunque es un poco tarde, PHP tiene una mejor solución para esto:

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

Similar a la respuesta aceptada con un paso menos:

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

//$first_word == 'Test'

En caso de que no esté seguro de que la cadena comienza con una palabra ...

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

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

Simplemente use explotar para obtener cada palabra de la entrada y la salida del primer elemento de la matriz resultante.

Usando la función de división también puede obtener la primera palabra de la cadena.

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

strtokes más rápido que extracto preg_*funciona.

$ input = "Pruébame más";
echo preg_replace ("/ \ s. * $ /", "", $ input); // "Prueba"

personalmente strsplit/ explode/ strtokno admite límites de palabras, por lo tanto, para obtener una división más aguda, use la expresión regular con el\w

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

Esto dividiría las palabras con límites hasta un límite 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;

Saludos, Ciul

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

Puede hacerlo usando la función de cadena PHP substr sin convertir la cadena en una matriz.

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

// salida S

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

Función que tokenizará la cadena en dos partes, la primera palabra y la cadena restante.

Valor de retorno: Tendrá firsty remainingtecleará la $returnmatriz respectivamente. la primera verificación strpos( $title," ") !== falsees obligatoria en caso de que la cadena tenga solo una palabra y no tenga espacio.

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]

No funciona en caracteres especiales y dará como resultado un comportamiento incorrecto si se utilizan caracteres especiales. No es compatible con UTF-8.

Para obtener más información, ¿ es seguro PHP str_word_count () multibyte seguro?

Como no puede verificar con strok para mayúsculas o minúsculas, esto funciona perfectamente para verificar la primera palabra.

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

Su pregunta podría reformularse como "reemplace en la cadena el primer espacio y todo lo que sigue por nada". Entonces esto se puede lograr con una expresión regular simple:

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

He agregado una llamada opcional a ltrim () para estar seguro: esta función elimina espacios al comienzo de la cadena.

¡Todas las respuestas aquí están utilizando un enfoque que el procesador necesita para buscar en toda la cadena, incluso si se encuentra la primera palabra! Para cadenas grandes, esto no se recomienda. Este enfoque es óptimo:

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

Si quiere saber qué tan rápido cada una de estas respectivas funciones es, me encontré con algunos crudo evaluación comparativa en PHP 7.3 en los seis más votados respuestas aquí ( strposcon substr, explodecon current, strstr, explodecon trim, str_word_county strtok) con 1.000.000 iteraciones cada uno para comparar sus velocidades.

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

?>

Aquí están los resultados variables de 2 ejecuciones consecutivas:

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

Y los resultados después de invertir el orden de las funciones:

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

Conclusión Resulta que la velocidad entre estas funciones varía ampliamente y no es tan consistente entre las ejecuciones de prueba como cabría esperar. De acuerdo con estas pruebas rápidas y sucias, cualquiera de las seis funciones elegidas realizará el trabajo en un tiempo razonable. Hay perturbaciones que incluyen otros procesos en ejecución que interfieren con los tiempos de ejecución. Así que solo use cualquier función que tenga el sentido más práctico y legible para usted como programador. Para obtener una imagen de programación más amplia, consulte la Programación literaria de Donald Knuth .