obtenir la première lettre de chaque mot

La meilleure façon d'y parvenir est d'utiliser des expressions régulières.

Permet de décomposer ce que vous voulez d'une manière logique: Vous voulez que chaque caractère de la chaîne est au début d'un mot. La meilleure façon d'identifier ces caractères est de rechercher ceux qui sont précédés d'un espace blanc.

Nous commençons donc par un lookbehind pour ce caractère d'espace, suivi de n'importe quel caractère:

/(?<=\s)./

Cela trouvera n'importe quel caractère précédé d'un espace. Mais - la premier caractère dans la chaîne est un caractère dans la chaîne est celui que vous voulez extraire. Et parce que c'est le premier caractère de la chaîne, il ne peut pas être précédé d'un espace. Nous voulons donc faire correspondre tout ce qui est précédé d'un espace ou le premier caractère de la chaîne, nous ajoutons donc une assertion début du sujet :

/(?<=\s|^)./

Maintenant, nous nous rapprochons. Mais que faire si la chaîne contient des blocs de plusieurs espaces? Que faire s'il contient un espace suivi d'un caractère de ponctuation? Nous vous ne voulez probablement pas faire correspondre l'un de ceux-ci, dans fat, nous voulons probablement juste faire correspondre les lettres. Nous pouvons le faire avec une classe de caractères [a-zA-Z]. Et nous pouvons rendre l'expression insensible à la casse en utilisant le i modificateur .

Donc nous nous retrouvons avec:

/(?<=\s|^)[a-z]/i

Mais comment l'utilisons-nous réellement en PHP? Eh bien, nous voulons faire correspondre toutes les occurrences de l'expression régulière dans la chaîne, donc nous utilisons (vous l'avez deviné) preg_match_all():

$string = "Progress in Veterinary Science";

$expr = '/(?<=\s|^)[a-z]/i';
preg_match_all($expr, $string, $matches);

Maintenant, nous avons tous les personnages que nous voulions extraire. Pour construire la chaîne de résultat que vous montrez, nous devons les joindre à nouveau :

$result = implode('', $matches[0]);

...et nous devons nous assurer qu'ils sont tous les cas supérieur:

$result = strtoupper($result);

Et c'est vraiment tout ce qu'il y a à faire.

Voir travail

En supposant que les mots sont tous divisés par des espaces, c'est une solution appropriée:

$string = "Progress in Veterinary Science";

function initials($str) {
    $ret = '';
    foreach (explode(' ', $str) as $word)
        $ret .= strtoupper($word[0]);
    return $ret;
}

echo initials($string); // would output "PIVS"

la réponse de Michael Berkowski (et d'autres), simplifiée en une ligne et fonctionnant correctement sur des caractères multi-octets (c'est-à-dire en faisant une abréviation / initiales à partir d'une chaîne non latine):

foreach(explode(' ', $words) as $word) $acronym .= mb_substr($word, 0, 1, 'utf-8');

Utiliser mb_substr($word, 0, 1, 'utf-8'), au lieu de $word[0] semble être indispensable, si vous travaillez sur des chaînes et des caractères multi-octets non latins, c'est-à-dire lorsque vous utilisez des chaînes codées UTF-8.

$temp = explode(' ', $string);
$result = '';
foreach($temp as $t)
    $result .= $t[0];

Comme ceci

preg_match_all('#(?<=\s|\b)\pL#u', $String, $Result);
echo '<pre>' . print_r($Result, 1) . '</pre>';

Il y a beaucoup de réponses explode. Je pense que l'utilisation de la fonction strtok est une solution beaucoup plus élégante et efficace en mémoire:

function createAcronym($string) {
    $output = null;
    $token  = strtok($string, ' ');
    while ($token !== false) {
        $output .= $token[0];
        $token = strtok(' ');
    }
    return $output;
}
$string = 'Progress in Veterinary Science';
echo createAcronym($string, false);

Voici une fonction plus robuste et utile, qui prend en charge les caractères UTF8 et l'option d'utiliser uniquement les mots en majuscules:

function createAcronym($string, $onlyCapitals = false) {
    $output = null;
    $token  = strtok($string, ' ');
    while ($token !== false) {
        $character = mb_substr($token, 0, 1);
        if ($onlyCapitals and mb_strtoupper($character) !== $character) {
            $token = strtok(' ');
            continue;
        }
        $output .= $character;
        $token = strtok(' ');
    }
    return $output;
}
$string = 'Leiðari í Kliniskum Útbúgvingum';
echo createAcronym($string);

$str = 'I am a String!';
echo implode('', array_map(function($v) { return $v[0]; }, explode(' ', $str)));

// would output IaaS

Comme expliqué par d'autres, la manière classique consiste à itérer sur chaque mot de votre chaîne initiale, à réduire le mot à sa première lettre et à combiner ces premières lettres ensemble.

Voici une méthode d'aide combinant les différentes étapes.

/**
 * @return string
 */
function getInitials($string = null) {
    return array_reduce(
        explode(' ', $string),
        function ($initials, $word) {
            return sprintf('%s%s', $initials, substr($word, 0, 1));
        },
        ''
    );
}

NB: cela renverra une chaîne vide au cas où la chaîne donnée serait vide.

getInitials('Community College District')

Chaîne ' CCD '(Longueur=3)

getInitials()

Chaîne " (Longueur = 0)

getInitials('Lorem ipsum dolor sic amet')

Chaîne ' Lidsa '(longueur=5)

Bien sûr, vous pouvez ajouter des filtres à la fonction de rappel de array_reduce(), tels que strtoupper() Si vous préférez uniquement les initiales en majuscules par exemple.

function acronym( $string = '' ) {
    $words = explode(' ', $string);
    if ( ! $words ) {
        return false;
    }
    $result = '';
    foreach ( $words as $word ) $result .= $word[0];
    return strtoupper( $result );
}

Quelque chose que j'ai préparé.

/**
 * Return the first letter of each word in uppercase - if it's too long.
 *
 * @param string $str
 * @param int $max
 * @param string $acronym
 * @return string
 */
function str_acronym($str, $max = 12, $acronym = '')
{
    if (strlen($str) <= $max) return $str;

    $words = explode(' ', $str);

    foreach ($words as $word)
    {
        $acronym .= strtoupper(substr($word, 0, 1));
    }

    return $acronym;
}

Je pense que vous devez exploser et les rejoindre à nouveau .....

<?php
$string  = "Progress in Veterinary Science";
$pieces = explode(" ", $string);
$str="";
foreach($pieces as $piece)
{
    $str.=$piece[0];
}    
echo $str; /// it will result into  "PiVS"
?>

En utilisant la Fondation Prateeks, voici un exemple simple avec des explications

//  initialize variables
$string = 'Capitalize Each First Word In A String';
$myCapitalizedString = '';

//  here's the code
$strs=explode(" ",$string);    
foreach($strs as $str) {
  $myCapitalizedString .= $str[0]; 
}

//  output
echo $myCapitalizedString;  // prints 'CEFWIAS'

S'il y a plus d'espaces entre deux lettres dans la chaîne d'entrée, essayez ceci.

function first_letter($str)
{
    $arr2 = array_filter(array_map('trim',explode(' ', $str)));
    $result='';
    foreach($arr2 as $v)
    {
        $result.=$v[0];
    }
    return $result;
}

$str="    Let's   try   with    more   spaces       for  fun .   ";

echo first_letter($str);

Demo1

Alternative du même code

function first_letter($str)
{
    return implode('', array_map(function($v) { return $v[0]; },array_filter(array_map('trim',explode(' ', $str)))));;
}

$str="    Let's   try   with    more   spaces       for  fun .   ";

echo first_letter($str);

Demo2

Voici une fonction qui vous obtient les initiales d'un nom et si les initiales sont seulement 1 lettre alors il retourne les 2 premières lettres du prénom.

function getNameInitials($name) {

    preg_match_all('#(?<=\s|\b)\pL#u', $name, $res);
    $initials = implode('', $res[0]);

    if (strlen($initials) < 2) {
        $initials = strtoupper(substr($name, 0, 2));
    }

    return strtoupper($initials);
}

Essayez ceci -

$strs=explode(" ",$string);

foreach($strs as $str)
  echo $str[0];

Quelque chose comme ça devrait faire l'affaire:

$string = 'Some words in a string';
$words = explode(' ', $string); // array of word
foreach($words as $word){
    echo $word[0]; // first letter
}

Pour le cas où vous le ferez sur de grandes chaînes (ou même directement à partir du fichier) explode() ce n'est pas la meilleure façon de le faire. Imaginez combien de mémoire sera gaspillée si vous devez diviser la chaîne 2MB en mémoire.

Avec un peu plus de codage et (en supposant que PHP >= 5.0) Vous pouvez facilement implémenter PHP Iterator classe qui fera exactement cela. Ce sera proche de generator en python et longue histoire courte, voici le code:

/**
 * Class for CONTINOUS reading of words from string.
*/
class WordsIterator implements Iterator {
    private $pos = 0;
    private $str = '';
    private $index = 0;
    private $current = null;

    // Regexp explained:
    // ([^\\w]*?) - Eat everything non-word before actual word characters
    //              Mostly used only if string beings with non-word char
    // ([\\w]+)   - Word
    // ([^\\w]+?|$) - Trailing thrash
    private $re = '~([^\\w]*?)([\\w]+)([^\\w]+?|$)~imsS';

    // Primary initialize string
    public function __construct($str) {
        $this->str = $str;
    }

    // Restart indexing
    function rewind() {
        $this->pos = 0;
        $this->index = 0;
        $this->current = null;
    }

    // Fetches current word
    function current() {
        return $this->current;
    }

    // Return id of word you are currently at (you can use offset too)
    function key() {
        return $this->index;
    }

    // Here's where the magic is done
    function next() {
        if( $this->pos < 0){
            return;
        }

        $match = array();
        ++$this->index;

        // If we can't find any another piece that matches... Set pos to -1
        // and stop function
        if( !preg_match( $this->re, $this->str, $match, 0, $this->pos)){
            $this->current = null;
            $this->pos = -1;
            return;
        }

        // Skip what we have read now
        $this->current = $match[2];
        $this->pos += strlen( $match[1]) + strlen( $match[2]) + strlen($match[3]);

        // We're trying to iterate past string
        if( $this->pos >= strlen($this->str)){
            $this->pos = -1;
        }

    }

    // Okay, we're done? :)
    function valid() {
        return ($this->pos > -1);
    }
}

Et si vous l'utilisez sur un chaîne un peu plus difficile:

$a = new WordsIterator("Progress in Veterinary Science. And, make it !more! interesting!\nWith new line.");
foreach( $a as $i){
    echo $i;
    echo "\n";
}

Obtiendrez-vous le résultat attendu:

Progress
in
Veterinary
Science
And
make
it
more
interesting
With
new
line

Vous pouvez donc facilement utiliser $i[0] pour récupérer la première lettre.Vous pouvez probablement voir que c'est une solution plus efficace que de diviser une chaîne entière en mémoire (Utilisez toujours le moins de mémoire possible). Vous pouvez également facilement modifier cette solution pour travailler avec la lecture continue des fichiers, etc.

<?php $arr = explode(" ",$String);

foreach($arr as $s)
{
   echo substr($s,0,1);
}

?>

Tout d'abord, j'explose la chaîne par des espaces puis je substr premier char.

Http://php.net/substr

Http://php.net/explode

Essayez Ceci

function initials($string) {
        if(!(empty($string))) {
            if(strpos($string, " ")) {
                $string = explode(" ", $string);
                $count = count($string);
                $new_string = '';
                for($i = 0; $i < $count; $i++) {
                $first_letter = substr(ucwords($string[$i]), 0, 1);
                $new_string .= $first_letter;
            }
            return $new_string;
            } else {
                $first_letter = substr(ucwords($string), 0, 1);
                $string = $first_letter;
                return $string;
            }
        } else {
            return "empty string!";
        }
    }
    echo initials('Thomas Edison');

J'aime Reg Expression sur toute autre méthode d'extraction de chaîne, mais si vous n'êtes pas familier avec Reg Ex alors hear est une méthode utilisant la fonction explode() PHP:

$string = "David Beckham";
$string_split = explode(" ", $string);
$inititals = $string_split[0][0] . $string_split[1][0];
echo $inititals;

Évidemment, le code ci-dessus ne fonctionnera que sur un nom contenant deux mots.