Salut a tous,
je viens de créer un Spinner de contenu, j'ai presque fini mais j'ai un soucis:
J'ai créer une boucle while infinie qui se charge de mettre dans un tableau les différents résultats de retour...
Comme vous le savez, il faut bien stopper cette boucle a un moment ou un autre, pour ce faire, j'ai décider de compter le nombre de possibilités de text différents qu'il est possible de créer puis quand le tableau atteint ce nombre, la boucle retourne les résultats. De cette façon j'obtiens toutes les possibilités et surtout sans doublons...
Voici la fonction qui compte:

<?php

/**
 * Compte le nombre maximum de spuns en sortie
 * 
 * @param string $aSpinner => Contenu a spinner
 * @return int => Produit des champs du tableau $total
 */
function resultatPossible($aSpinner) {
    $retour = [];
    preg_match_all("#\[(.*?)\]#", $aSpinner, $retour);
    foreach ($retour[0] AS $id => $resultat) {
        $spin = explode('|', $retour[1][$id]);
        $total[] = count($spin);
        unset($resultat);
    }
    return (int) array_product($total);
}

// Doit afficher 8 car 4*2=8
$aSpinner = 'Salut, j\'aime le [HTML|CSS|SCSS|JS] mais aussi le [PHP|l\'AJAX]';
echo 'Vous avez ' . resultatPossible($aSpinner) . ' resultats possibles !';
?>

Ce qui me gène la c'est la variable $resultat, je ne suis pas réellement sur qu'elle me serve, pour cause et que je fait un unset() ?
Ma question, est: comment simplifier, je suis un peut perdu
Merci d'avance !

Euh... Pourquoi ne s'occuper que du second élément retourné ?
J'ai l'impression que ta fonction ne fait pas ce qu'elle est censé faire, je me trompe ?
Stockes les retours puis utilises array_unique pour supprimer les doublons.
Ensuite avec sizeof ou count tu as à la taille de ton tableau.

En fait la fonction que je montre ne sert qu'a compter le nombre de possibilités...
Pour le reste des explications, ce sont d'autre fonctions, j'obtiens bien le résultat que je cherche pour le moment.

Donc le principe est de prendre un texte et de calculer le nombre de possibilités en comptant les différents blocs [] et leurs contenu puis de les multiplier ensemble, de cette façon, j'obtiens le nombre de possibilités d'avoir un texte chaque fois différent.
J'ai un while qui a chaque tous met dans un tableau le résultat obtenu si le texte ni est pas déjà, puis je retourne la tableau quand le nombre d'éléments qu'il contient est égale au nombre de possibilités...

La maintenant, j'obtiens exactement ce que je veux mais je me rend bien compte que c'est pas bien fait...

Euh... Pourquoi ne s'occuper que du second élément retourné ?

Bien en fait c'est une modif d'une autre fonction pour la quel les 2 résultats sont presque identique mais c'est le 2eme qu'il faut utiliser.

J'ai l'impression que ta fonction ne fait pas ce qu'elle est censé faire, je me trompe ?

Si si ca fonctionne...

Stockes les retours puis utilises array_unique pour supprimer les doublons.
Ensuite avec sizeof ou count tu as à la taille de ton tableau.

La ou j'en suis, j'ai besoin d'avoir le nombre avant car c'est lui qui définit quand stopper la boucle qui remplis le tableau, While dans ce cas est infinie

Je ne comprends pas ton histoire de boucle infinie, un tableau n'est jamais infini.
Mea culpa par contre pour mon histoire d'index, j'avais oublié le format retourné par preg_match_all.

Du coup au plus simple :

<?php
$aSpinner = 'Salut, j\'aime le [HTML|CSS|SCSS|JS] mais aussi le [PHP|l\'AJAX] mais surtout la [nourriture|boisson]';
echo $aSpinner;
$retour = array();
preg_match_all("#\[(.*?)\]#", $aSpinner, $retour);
$mots = array();
$tmp = array();
$total = 1;
foreach($retour[1] as $chaine)
{
	$tmp = explode('|', $chaine);
	$total = $total * count($tmp);
	$mots = array_merge($mots, $tmp);
}
var_dump($total);
var_dump($mots);

Salut, j'aime le [HTML|CSS|SCSS|JS] mais aussi le [PHP|l'AJAX] mais surtout la [nourriture|boisson]

int 16

array (size=8)
0 => string 'HTML' (length=4)
1 => string 'CSS' (length=3)
2 => string 'SCSS' (length=4)
3 => string 'JS' (length=2)
4 => string 'PHP' (length=3)
5 => string 'l'AJAX' (length=6)
6 => string 'nourriture' (length=10)
7 => string 'boisson' (length=7)

Pour la boucle infinie, elle est dans cette fonction:

/**
 * Spin = Element contenu entre les [...] ex: [spin-1|spin-2|spin-3]
 * Spun = Text reçu en sortie une fois modifier par la fonction
 *
 * @param type aSpinner => Contenu a spinner
 * @param type $max => Nombre de résultats voulu en sortie
 * @param type $nbTest => Nombre de test vide avant l'arret de la boucle
 * @return type
 */
function spinner($aSpinner, $nbTotal, $max = null) {
    $spuns = [];
    $test = 0;
    while (1) {
        $spun = prepareSpuns($aSpinner);
        if (!in_array($spun, $spuns)) {
            $spuns[] = $spun;
        } else {
            $test = count($spuns); // Nombre de test en cours
            if ($test === $nbTotal) {
                // $test atteint le nombre de test max $nbTest, on retourne $spuns
                return $spuns;
            }
        }
        // Si on définit un nombre maximum de résultats en sortie
        if (!is_null($max) && count($spuns) === $max) {
            return $spuns;
        }
    }
}

La boucle While est a 1 et continuera de tourner jusqu’à ce que le nombre de résultats contenu dans $spun[] ait atteint le nombre de possibilités...
C'est très certainement pas la meilleur solution mais justement, je travaille dessus et cherche d'autres solutions.
Dans ce cas je ne peut pas donner de limit a While car a chaque fois qu'un résultat n'est pas mis dans le tableau, je perd un tours et il manquera forcement des résultats...

Si non, c'est résolu, la solution que tu m'a donner ressemble parfaitement a l'idée que j'en avais mais impossible