Como obter a primeira palavra de uma frase em PHP?

Eu quero extrair a primeira palavra de uma variável de uma seqüência de caracteres. Por exemplo, considere esta entrada:

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

A saída resultante deve ser Test, que é a primeira palavra da entrada. Como posso fazer isso?

Você pode usar a função explodir da seguinte maneira:

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

Existe uma função de string ( strtok ) que pode ser usada para dividir uma string em strings menores ( tokens ) com base em alguns separadores. Para os fins deste encadeamento, a primeira palavra (definida como qualquer coisa antes do primeiro caractere de espaço) de Test me morepode ser obtida ao tokenizar a sequência no caractere de espaço.

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

Para mais detalhes e exemplos, consulte a página de manual do strtok PHP .

Se você tem PHP 5.3

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

observe que if $myvalueé uma string com uma palavra strstrnão retorna nada neste caso. Uma solução poderia ser acrescentar um espaço à cadeia de teste:

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

Isso sempre retornará a primeira palavra da string, mesmo se a string tiver apenas uma palavra

A alternativa é algo como:

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

Ou usando o explodir, que tem tantas respostas, não vou me incomodar em mostrar como fazê-lo.

Você poderia fazer

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

Mesmo que seja um pouco tarde, mas o PHP tem uma solução melhor para isso:

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

Semelhante à resposta aceita com menos uma etapa:

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

//$first_word == 'Test'

Apenas no caso de você não ter certeza de que a sequência começa com uma palavra ...

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

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

Basta usar explodir para obter todas as palavras da entrada e gerar o primeiro elemento da matriz resultante.

Usando a função split, você também pode obter a primeira palavra da string.

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

strtoké mais rápido que extractou preg_*funciona.

$ input = "Teste-me mais";
echo preg_replace ("/ \ s. * $ /", "", $ input); // "Teste"

pessoalmente strsplit/ explode/ strtoknão suporta limites de palavras, portanto, para obter uma divisão mais precisa, use expressão regular com o\w

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

Isso dividiria as palavras com limites para um 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;

Atenciosamente, Ciul

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

Você pode fazer isso usando a função de string PHP substr sem convocar a string na matriz.

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

// saída S

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

Função que tokenizará a string em duas partes, primeira palavra e string restante.

Valor de retorno: Ele terá firste remainingdigitará a $returnmatriz, respectivamente. a primeira verificação strpos( $title," ") !== falseé obrigatória no caso em que a string tenha apenas uma palavra e não haja espaço nela.

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]

Não funciona com caracteres especiais e resultará em comportamento incorreto se forem usados ​​caracteres especiais. Não é compatível com UTF-8.

Para mais informações, verifique se o PHP str_word_count () multibyte é seguro?

Como você não pode verificar com strok maiúsculas ou minúsculas, isso funciona perfeitamente para verificar a primeira palavra.

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

Sua pergunta pode ser reformulada como "substitua na cadeia o primeiro espaço e tudo o que segue por nada". Portanto, isso pode ser alcançado com uma simples expressão regular:

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

Eu adicionei uma chamada opcional para ltrim () para ser seguro: essa função remove espaços no início da string.

Todas as respostas aqui estão usando uma abordagem que o processador precisa pesquisar em toda a string, mesmo que a primeira palavra seja encontrada! Para cordas grandes, isso não é recomendado. Essa abordagem é ideal:

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

Se você quiser saber o quão rápido cada uma dessas respectivas funções é, eu corri alguns bruto de benchmarking em PHP 7.3 em seis mais votado respostas aqui ( strposcom substr, explodecom current, strstr, explodecom trim, str_word_counte strtok) com 1.000.000 iterações cada para comparar suas 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>';

?>

Aqui estão os resultados variáveis ​​de duas execuções 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

E os resultados depois de inverter a ordem das funções:

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

Conclusão Acontece que a velocidade entre essas funções varia muito e não é tão consistente entre as execuções de teste quanto você poderia esperar. De acordo com esses testes rápidos e sujos, qualquer uma das seis funções escolhidas realizará o trabalho em um período de tempo razoável. Existem perturbações, incluindo outros processos em execução, que estão interferindo nos tempos de execução. Portanto, basta usar qualquer função que faça o sentido mais prático e legível para você como programador. Para uma visão geral da programação, consulte Programação alfabética de Donald Knuth .