web-dev-qa-db-de.com

Überprüfen Sie, ob mehrere Werte alle falsch oder alle wahr sind

Wie kann ich überprüfen, ob 20 Variablen alle wahr sind oder ob 20 Variablen alle falsch sind?

wenn möglich ohne wirklich lange zu verwenden, wenn ...

die Variablen sind tatsächlich Array-Elemente:

array ('a' => wahr, 'b' => wahr ...)

um es klarer zu machen:

  • wenn das Array sowohl wahre als auch falsche Werte enthält, wird nichts zurückgegeben
  • wenn das Array nur wahre Werte enthält, wird true zurückgegeben
  • wenn das Array nur falsche Werte enthält, wird false zurückgegeben :)
19
sandy
if(count(array_unique($your_array)) === 1)  
  return current($your_array);

else return;
48
barfoon

Du könntest in_array verwenden

Ex. für alle wahr:

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

Man kann array_product verwenden, wie in php.net in einem Kommentar gezeigt :

$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
10
lumbric

Eine einfache Schleife reicht aus. Beachten Sie, dass beide Bedingungen erfüllt sind, wenn das Array leer ist (alle falsch und alle wahr). Sie werden dies aufgrund des Anderen nicht im Ergebnis sehen, aber Sie können selbst herausfinden, wie Sie damit umgehen möchten.

// 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';
4
GolezTrol

Diese Frage ist uralt, aber egal. Ich wollte die verschiedenen Ansätze vergleichen. Die Methode in_array() bietet die beste Leistung, da sie wahrscheinlich nicht das gesamte Array durchlaufen muss. (Die Wahrscheinlichkeit ist gering, dass Sie am Ende nur einen einzigen Booleschen Wert haben, aber selbst dann ist die Leistung gut.)

Ein hier nicht erwähnter Ansatz ist array_sum($array), der 0 zurückgibt, wenn alle Werte false sind, und 1+, wenn irgendwo ein Wert für true vorhanden ist. Wie beim array_filter-Ansatz wird nicht angezeigt, ob beide vorhanden sind, aber es ist hilfreich, um herauszufinden, ob etwas true ist. Ich habe auch eine grundlegende foreach-Prüfung für gemischt oder alle wahr/falsch und einen in_array hinzugefügt, der nur prüft, ob etwas true ist (als *_bin unten).

Hier sind die Benchmarks. Jeder Fall wird 100000-mal mit einem Array von 10, 100 oder 1000 zufälligen Booleschen Werten iteriert. und wieder mit 9, 99 und 999 identischen Booleschen Werten, wobei der letzte eindeutig ist (um die volle Iterationszeit für in_array zu haben). Die ersten drei getesteten Prüfungen ergeben das angeforderte Ergebnis true/false/both und die restlichen vier prüfen einfach, ob ein Wert für true vorhanden ist.


ZUFÄLLIGE BÜCHER

  • in_array : 10 bools = 0,16 sek
  • foreach : 10 bools = 0,122 sek
  • array_unique : 10 bools = 0,274 sek
  • foreach_bin : 10 bools = 0,095 sek
  • in_array_bin : 10 bools = 0,073 sek
  • array_sum : 10 bools = 0,074 sek
  • array_filter : 10 bools = 0,118 sek

  • in_array : 100 bools = 0,153 sek
  • foreach : 100 bools = 0,122 sek
  • array_unique : 100 bools = 2,3451 sec
  • foreach_bin : 100 bools = 0,094 sek
  • in_array_bin : 100 bools = 0,074 sek
  • array_sum : 100 bools = 0,126 sek
  • array_filter : 100 bools = 0,228 sek

  • in_array : 1000 bools = 0,154 sek
  • foreach : 1000 bools = 0,149 sek
  • array_unique : 1000 bools = 32.6659 sec (!!)
  • foreach_bin : 1000 bools = 0,075 sek
  • in_array_bin : 1000 bools = 0,074 sek
  • array_sum : 1000 bools = 0,8771 sec
  • array_filter : 1000 bools = 1.4021 sec

LAST BOOLEAN DIFFERS

  • in_array : 10 bools = 0,152 sek
  • foreach : 10 bools = 0,342 sek
  • array_unique : 10 bools = 0,269 sec
  • foreach_bin : 10 bools = 0,074 sek
  • in_array_bin : 10 bools = 0,076 sek
  • array_sum : 10 bools = 0,074 sek
  • array_filter : 10 bools = 0,121 sek

  • in_array : 100 bools = 0,159 sek
  • foreach : 100 bools = 2,8072 sec
  • array_unique : 100 bools = 2,7702 sec
  • foreach_bin : 100 bools = 0,074 sek
  • in_array_bin : 100 bools = 0,09 sek
  • array_sum : 100 bools = 0,118 sek
  • array_filter : 100 bools = 0,248 sek

  • in_array : 1000 bools = 0,312 sek
  • foreach : 1000 bools = 27,5256 sec
  • array_unique : 1000 bools = 42,1594 sec
  • foreach_bin : 1000 bools = 0,074 sek
  • in_array_bin : 1000 bools = 0,24 sek
  • array_sum : 1000 bools = 0,555 sek
  • array_filter : 1000 bools = 1,3601 sek

Dann zusammenfassend. Der array_unique Weg hält eindeutig den Schwanz, nicht für große Arrays oder große Mengen von Arrays verwenden! Der foreach hat einen kleinen Vorteil gegenüber in_array, aber leider ist der Code nicht ganz so elegant. Der array_sum-Weg ist mit den "if true" -Überprüfungen für kleinere (<100) Arrays identisch. (Ich verstehe die Einfachheit in array_sum($array) > 0.) Der array_filter-Weg hinkt etwas hinter in_array und foreach zurück. Wenn sich nur der letzte Wert unterscheidet, ziehen foreach und array_unique beide den Wert in die falsche Richtung.

Schließlich die Funktion foreach für gute Laune. Sehr gut lesbar. Die Wahrheit ist da draußen!


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. Könnte 'null' oben verwenden, aber es liest sich auf diese Weise spaßiger. Benchmarking unter Windows, damit die Mikrotimewerte uneinheitlich sind.

3
Markus AO

Wenn Sie nur Boolesche Werte speichern, verwenden Sie Folgendes:

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

Hinweis: Wenn Sie andere Werte im Array haben, werden diese gemäß den fürchterlichen Konvertierungsregeln von PHP in boolesche Werte konvertiert.

3
Karoly Horvath

Außerdem können Sie eine Liste mit Variablen (nicht nur ein Array von Werten) erstellen, um alle Werte mit einem bestimmten Wert zu vergleichen.

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

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

var_dump($isAllVarsTrue); //false
2

Wenn es sich um Array-Elemente mit True/False-Werten handelt, verwenden Sie array_flip ():

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

Dies kann für ein großes Array teuer werden. Versuchen Sie es stattdessen mit array_unique(). Sie würden ein Array mit höchstens zwei Werten erhalten (einer wahr, einer falsch).


Ok, das würde nicht funktionieren. Einfacher Shotgun-Ansatz:

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

Verwenden Sie eine for-Schleife. Wenn Sie überprüfen möchten, ob alle Variablen falsch sind, können Sie eine for-Schleife verwenden: Wenn Sie ein wahres Element gefunden haben, können Sie den Zyklus unterbrechen, andernfalls sind alle Variablen falsch. Dieselbe Methode, die Sie verwenden können, wenn Sie überprüfen möchten, ob alle Variablen wahr sind.

1
Manlio
// 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
0
geekuality