obtenir la première lettre de chaque mot
Comment pourrais-je obtenir la première lettre de chaque mot pour une chaîne donnée?
$string = "Community College District";
$result = "CCD";
J'ai trouvé la méthode javascript, mais je ne savais pas comment le convertir en php.
explode() sur les espaces, utilisez la notation [] pour accéder aux chaînes résultantes sous forme de tableaux:
$words = explode(" ", "Community College District");
$acronym = "";
foreach ($words as $w) {
$acronym .= $w[0];
}
Si vous vous attendez à ce que plusieurs espaces séparent des mots, passez à preg_split()
$words = preg_split("/\s+/", "Community College District");
Ou si des caractères autres que des espaces délimitent des mots (-,_) par exemple, utilisez également preg_split():
// Delimit by multiple spaces, hyphen, underscore, comma
$words = preg_split("/[\s,_-]+/", "Community College District");
Le meilleur moyen d'y parvenir est d'utiliser des expressions régulières.
Décomposons ce que vous voulez de manière logique: vous voulez que chaque caractère de la chaîne soit au début d'un mot. Le meilleur moyen d'identifier ces caractères est de rechercher ceux précédés d'un espace.
Nous commençons donc par un lookbehind pour ce caractère espace, suivi de tout caractère:
/(?<=\s)./
Ceci trouvera n'importe quel caractère précédé d'un espace. Mais - le premier caractère de la chaîne est un caractère de la chaîne que vous souhaitez extraire. Et comme il s'agit du 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 du premier caractère de la chaîne. Nous ajoutons donc un assertion de début de sujet :
/(?<=\s|^)./
Maintenant nous nous rapprochons. Mais que se passe-t-il si la chaîne contient des blocs de plusieurs espaces? Que se passe-t-il s'il contient un espace suivi d'un caractère de ponctuation? Nous ne voulons probablement pas assortir aucun de ceux, en gros nous voulons probablement juste assortir des lettres. Nous pouvons le faire avec un classe de caractères[a-zA-Z]. Et nous pouvons rendre l'expression insensible à la casse en utilisant imodificateur .
Donc on se retrouve avec:
/(?<=\s|^)[a-z]/i
Mais comment utilisons-nous cela en PHP? Eh bien, nous voulons faire correspondre toutes les occurrences de l'expression régulière dans la chaîne afin que nous utilisions (vous l'avez deviné) preg_match_all() :
$string = "Progress in Veterinary Science";
$expr = '/(?<=\s|^)[a-z]/i';
preg_match_all($expr, $string, $matches);
Nous avons maintenant tous les personnages que nous voulions extraire. Pour construire la chaîne de résultat que vous affichez, nous devons les réunir à nouveau }:
$result = implode('', $matches[0]);
... et nous devons nous assurer qu'ils sont tous en majuscules :
$result = strtoupper($result);
Et c'est vraiment tout ce qu'il y a à faire.
_ { Ça fonctionne
En supposant que les mots soient tous séparés par des espaces, voici 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 sur une ligne et fonctionnant correctement avec des caractères multi-octets (c’est-à-dire qui crée des abréviations ou des initiales dans 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 obligé, 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.
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 économe 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 permettant uniquement d'utiliser 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);
Comme ça
preg_match_all('#(?<=\s|\b)\pL#u', $String, $Result);
echo '<pre>' . print_r($Result, 1) . '</pre>';
$temp = explode(' ', $string);
$result = '';
foreach($temp as $t)
$result .= $t[0];
$str = 'I am a String!';
echo implode('', array_map(function($v) { return $v[0]; }, explode(' ', $str)));
// would output IaaS
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 concocté.
/**
* 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;
}
Voici une fonction qui vous donne les initiales d'un nom et si les initiales sont composées d'une lettre, elles renverront les deux 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);
}
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 de saisie, 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);
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);
Essaye ça-
$strs=explode(" ",$string);
foreach($strs as $str)
echo $str[0];
<?php $arr = explode(" ",$String);
foreach($arr as $s)
{
echo substr($s,0,1);
}
?>
j'éclate d'abord chaîne par espaces puis je sous-trait d'abord char.
Dans le cas où vous le feriez sur de grandes chaînes (ou même directement depuis un fichier) explode() n’est pas la meilleure façon de le faire. Imaginez combien de mémoire sera gaspillée si vous devez scinder la chaîne de 2 Mo en mémoire.
Avec un peu plus de code et (en supposant que PHP >= 5.0), vous pouvez facilement implémenter la classe Iterator class de PHP qui fera exactement cela. Ce sera proche du générateur en python et du récit long, 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 une 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";
}
Voulez-vous obtenir le résultat attendu:
Progress
in
Veterinary
Science
And
make
it
more
interesting
With
new
line
Ainsi, vous pouvez 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 scinder la 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 de fichiers, etc.
Pourquoi ne pas utiliser la fonction str_Word_count pour cela?
- obtenir chaque mot comme une ligne dans un tableau
réduit ce tableau à la première lettre
$ acronym = array_reduce ( str_Word_count ("District universitaire communautaire", 1), function ($ res, $ w) { return $ res. .);
Cette réponse https://stackoverflow.com/a/33080232/1046909 mais avec une prise en charge de chaînes multi-octets:
if (!function_exists('str_acronym')) {
function str_acronym(string $str, int $min = -1, string $prefix = null): string
{
if (mb_strlen($str) <= $min) {
return $str;
};
$words = explode(' ', $str);
$acronym = strval($prefix);
foreach ($words as $Word) {
if ($Word = trim($Word)) {
$acronym .= mb_strtoupper(mb_substr($Word, 0, 1));
}
}
return $acronym;
}
}
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
}
J'aime Reg Expression par rapport à toute autre méthode d'extraction de chaîne, mais si vous n'êtes pas familier avec Reg Ex, entendez 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;
De toute évidence, le code ci-dessus ne fonctionnera que sur un nom contenant deux mots.
Essaye ça
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');