Vérifier si plusieurs valeurs sont toutes fausses ou toutes vraies

Vous pouvez utiliser in_array

Ex. pour tous les vrais:

if(in_array(false, $array, true) === false){
    return true;
}
else if(in_array(true, $array, true) === false){
    return false;
}
else{
     return 'nothing';
}

On peut utiliser array_product comme démontré à php.net dans un commentaire:

$check[] = boolval(TRUE);
$check[] = boolval(1);
$check[] = boolval(FALSE);
$check[] = boolval(0);

$result = (bool) array_product($check);
// $result is set to FALSE because only two of the four values evaluated to TRUE

une simple boucle fera l'affaire. Notez que si le tableau est vide, les deux conditions sont remplies (toutes fausses et toutes vraies). Vous ne verrez pas cela dans le résultat, à cause de l'autre, mais vous pouvez trouver vous-même comment vous voulez gérer cela.

// Input
$x = array ('a'=>false, 'b'=>false, 'c'=>false);

// Initialization
$anytrue = false;
$alltrue = true;

// Processing
foreach($x as $k=>$v)
{
    $anytrue |= $v;
    $alltrue &= $v;
}

// Display result
if ($alltrue)
  echo 'All elements are true';
elseif (!$anytrue)
  echo 'All elements are false';
else
  echo 'Mixed values';

si vous ne stockez que des booléens, utilisez ceci:

$a = array('a'=> true, 'b'=> true, 'c'=>true);
$af = array_filter($a);
if ($af == $a) {
    echo "all true";
}
if (empty($af)) {
    echo "all false";
}

Note: Si vous avez d'autres valeurs dans le tableau, elles seront converties en booléen selon les règles de conversion horribles de PHP.

Cette question est ancienne, mais peu importe. Je voulais comparer les différentes approches. in_array() la méthode fonctionne le mieux puisqu'elle n'a probablement pas besoin d'itérer à travers l'ensemble du tableau. (Les chances sont faibles, vous n'auriez qu'un booléen unique à la fin, mais même alors il fonctionne bien.)

Une seule approche ne sont pas mentionnés ici array_sum($array), qui renvoie 0 si toutes les valeurs sont false et 1+ s'il y a un true valeur quelque part. Comme le array_filter approche, il ne sera pas vous dire si les deux sont présents, mais elle est utile pour déterminer si quelque chose est true. J'ai également ajouté dans une base foreach vérifier mixte ou vrai/faux, et un in_array qui vérifie juste si quelque chose n'est true (*_bin ci-dessous).

voici donc les points de repère. Chaque cas est itéré 100000 fois avec un tableau de 10, 100 ou 1000 booléens aléatoires; et encore avec 9, 99 et 999 booléens identiques, avec le dernier unique (pour avoir le temps d'itération complet pour in_array). Trois premiers les contrôles testés produisent lestrue/false/both résultat, et les quatre autres de vérifier simplement si un true valeur est présente.

RANDOM BOOLEANS

• in_array: 10 bool = 0.16 sec
• foreach: 10 bool = 0.122 sec
• array_unique: 10 bool = 0.274 sec
• foreach_bin: 10 bool = 0.095 sec
• in_array_bin: 10 bool = 0.073 sec
• array_sum: 10 bool = 0.074 sec
• array_filter: 10 bool = 0.118 sec

• in_array: 100 bool = 0.153 sec
• foreach: 100 bool = 0.122 sec
• array_unique: 100 bool = 2.3451 sec
• foreach_bin: 100 bool = 0.094 sec
• in_array_bin: 100 bool = 0.074 sec
• array_sum: 100 bool = 0.126 sec
• array_filter: 100 bool = 0.228 sec

• in_array: 1000 bool = de 0,154 sec
• foreach: 1000 bool = 0.149 sec
• array_unique: 1000 bool = 32.6659 sec (!!)
• foreach_bin: 1000 bool = 0.075 sec
• in_array_bin: 1000 bool = 0.074 sec
• array_sum: 1000 bool = 0.8771 sec
• array_filter: 1000 bool = 1.4021 sec

LE DERNIER BOOLÉEN DIFFÈRE

• in_array: 10 bool = 0.152 sec
• foreach: 10 bool = 0.342 sec
• array_unique: 10 bool = 0.269 sec
• foreach_bin: 10 bool = 0.074 sec
• in_array_bin: 10 bool = 0.076 sec
• array_sum: 10 bool = 0.074 sec
• array_filter: 10 bool = 0.121 sec

• in_array: 100 bool = 0.159 sec
• foreach: 100 bool = 2.8072 sec
• array_unique: 100 bool = 2.7702 sec
• foreach_bin: 100 bool = 0.074 sec
• in_array_bin: 100 bool = 0.09 sec
• array_sum: 100 bool = 0.118 sec
• array_filter: 100 bool = 0.248 sec

• in_array: 1000 bool = 0.312 sec
• foreach: 1000 bool = 27.5256 sec
• array_unique: 1000 bool = 42.1594 sec
• foreach_bin: 1000 bool = 0.074 sec
• in_array_bin: 1000 bool = 0.24 sec
• array_sum: 1000 bool = 0.555 sec
• array_filter: 1000 bool = 1.3601 sec

Alors, en résumé.array_unique la façon tient clairement la queue, ne l'utilisez pas pour les grands tableaux ou les grands volumes de tableaux! foreach a un léger avantage sur in_array, mais hélas le code n'est pas aussi élégant. array_sum le chemin est le même que les vérifications" si vrai " pour les plus petites (<100) tableau. (J'ai cherché la simplicité dans array_sum($array) > 0.)array_filter traîne un peu en retard in_array et foreach. Lorsque seule la dernière valeur diffère,foreach et array_unique les deux le traînent mal.

Enfin, le foreach fonction pour les bonnes humeurs. Très lisible. La vérité est là!

function foreach_truth_test($array)
{   
    $trues = $falses = false;

    foreach($array as $val) {
        if ($val === true) {
            $trues = true;
        } elseif ($val === false) {
            $falses = true;
        }
        if ($trues === true && $falses === true) {
            return 'both'; // Enough information.
        }
    }

    // Regular Universe
    if ($trues === true && $falses === false) {
        return 'true';
    } // Evil Mirror Universe
    elseif ($trues === false && $falses === true) {
        return 'false';
    } // Intergalactic Void
    else {
        return 'void'; // =^_^=
    }
}

P.S. pourrait utiliser 'null' ci-dessus, mais il lit plus amusant de cette façon. Repère sur les fenêtres de sorte que les lectures microtime sont chunky.

si ce sont tous des éléments de tableau, avec des valeurs true / false, alors utilisez array_flip ():

$new = array_flip($array); if (!isset($array[false]) && isset($array[true])) { ... there's no false values, and at least one true value }

cela pourrait devenir cher pour un grand tableau, donc vous pouvez essayer array_unique() à la place. Vous obtiendriez un tableau avec au plus deux valeurs (une vraie, une fausse).

Ok, donc ça ne marcherait pas. Simple fusil de chasse:

if (in_array($yourarray, false, TRUE)) {
   ... at least one non-true value
}

plus sur vous pouvez avoir une liste de variables (pas seulement un tableau de valeurs) pour vérifier toutes les valeurs par rapport à une certaine valeur.

$var1 = true;
$var2 = true;
$var3 = false;

$isAllVarsTrue = !in_array(false, [$var1, $var2, $var3], true);

var_dump($isAllVarsTrue); //false

utilisez A pour boucle. Si vous voulez vérifier que toutes les variables sont faux, vous pouvez utiliser une boucle for: une fois que vous trouver un vrai élément, vous pouvez briser le cycle, sinon les variables sont toutes fausses. Même méthode que vous pouvez utiliser si vous voulez vérifier que toutes les variables sont vraies.

// set default value
$result = false;

foreach ($array as $key => $value) {
    if ($value === true) {
        $result = true;
        break;
    } 
}

// $result is now true if any value was true, otherwise it's false