php - print - get tag name wordpress

Compruebe si los valores múltiples son todos falsos o verdaderos

Question

¿Cómo puedo verificar si 20 variables son verdaderas o si 20 variables son todas falsas?

Si es posible sin usar un muy largo si ...

las variables son en realidad elementos de matriz:

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

Para que quede más claro:

• Si la matriz tiene valores verdaderos y falsos, no se devuelve nada.
• si la matriz solo tiene valores verdaderos devuelve verdadero
• si la matriz solo tiene valores falsos, devuelve falso :)

Answer 1

Además, puede tener una lista o variables (no solo una matriz de valores) para verificar todos los valores con respecto a un valor determinado.

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

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

var_dump($isAllVarsTrue); //false

Answer 2

Esta pregunta es antigua, pero no importa. Quería comparar los diferentes enfoques. El método in_array() funciona mejor ya que probablemente no necesita recorrer toda la matriz. (Las probabilidades son bajas, solo tendrías un único booleano al final, pero incluso así funciona bien).

Un enfoque que no se menciona aquí es array_sum($array) , que devuelve 0 si todos los valores son false , y 1+ si hay un valor true alguna parte. Al igual que el enfoque array_filter , no le dirá si ambos están presentes, pero es útil para averiguar si algo es true . También agregué en una verificación básica de foreach para mezclar o todo verdadero / falso, y un in_array que solo verifica si algo es true (como *_bin abajo).

Así que aquí están los puntos de referencia. Cada caso se itera 100000 veces con una matriz de 10, 100 o 1000 booleanos aleatorios; y nuevamente con 9, 99 y 999 booleanos idénticos, con el último único (para tener un tiempo de iteración completo para in_array ). Las primeras tres verificaciones probadas producen el resultado true/false/both solicitados, y las cuatro restantes simplemente verifican si hay un valor true presente.

LIBROS ALEMANES

• in_array : 10 bools = 0.16 seg.
• Foreach: 10 bools = 0.122 seg.
• array_unique : 10 bools = 0.274 seg.
• foreach_bin : 10 bools = 0.095 seg.
• in_array_bin : 10 bools = 0.073 seg.
• array_sum : 10 bools = 0.074 sec
• array_filter : 10 bools = 0.118 seg.

• in_array : 100 bools = 0.153 seg.
• Foreach: 100 bools = 0.122 seg.
• array_unique : 100 bools = 2.3451 seg.
• foreach_bin : 100 bools = 0.094 seg.
• in_array_bin : 100 bools = 0.074 seg.
• array_sum : 100 bools = 0.126 seg.
• array_filter : 100 bools = 0.228 seg.

• in_array : 1000 bools = 0.154 seg.
• Foreach: 1000 bools = 0.149 seg.
• array_unique : 1000 bools = 32.6659 sec (!!)
• foreach_bin : 1000 bools = 0.075 seg.
• in_array_bin : 1000 bools = 0.074 seg.
• array_sum : 1000 bools = 0.8771 seg.
• array_filter : 1000 bools = 1.4021 seg.

LAS ÚLTIMAS DIFERENCIAS DE BOOLEAN

• in_array : 10 bools = 0.152 seg.
• Foreach: 10 bools = 0.342 seg.
• array_unique : 10 bools = 0.269 seg.
• foreach_bin : 10 bools = 0.074 seg.
• in_array_bin : 10 bools = 0.076 seg.
• array_sum : 10 bools = 0.074 sec
• array_filter : 10 bools = 0.121 seg.

• in_array : 100 bools = 0.159 seg.
• Foreach: 100 bools = 2.8072 seg.
• array_unique : 100 bools = 2.7702 seg.
• foreach_bin : 100 bools = 0.074 seg.
• in_array_bin : 100 bools = 0.09 seg.
• array_sum : 100 bools = 0.118 seg.
• array_filter : 100 bools = 0.248 seg.

• in_array : 1000 bools = 0.312 seg.
• Foreach: 1000 bools = 27.5256 seg.
• array_unique : 1000 bools = 42.1594 seg.
• foreach_bin : 1000 bools = 0.074 seg.
• in_array_bin : 1000 bools = 0.24 seg.
• array_sum : 1000 bools = 0.555 seg.
• array_filter : 1000 bools = 1.3601 seg.

Luego, en resumen. La forma array_unique claramente sostiene la cola, ¡no la use para arreglos grandes o grandes volúmenes de arreglos! La forma de foreach tiene una ligera ventaja sobre in_array , pero in_array el código no es tan elegante. La forma array_sum está a la par con las comprobaciones "if true" para matrices más pequeñas (<100). (Me gusta la simplicidad en array_sum($array) > 0 ). La forma de array_filter retrasa un poco detrás de in_array y foreach . Cuando solo el último valor difiere, foreach y array_unique arrastran mal.

Finalmente, la función foreach para buenos humores. Muy legible ¡La verdad está ahí fuera!

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''; // =^_^=
    }
}

PS Podría usar ''null'' arriba, pero se lee más divertido de esta manera. Comparado en Windows, por lo que las lecturas de microtiempo son grandes.

Answer 3

Podrías usar in_array

Ex. para todos verdad

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

Answer 4

Si solo almacena booleanos, use esto:

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

Nota: si tiene otros valores en la matriz, se convertirán a booleanos de acuerdo con las horribles reglas de conversión de PHP.

Answer 5

Si todos son elementos de matriz, con valores verdaderos / falsos, entonces use array_flip ():

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

Esto puede resultar caro para una gran variedad, por lo que es posible que desee probar array_unique() lugar. Obtendría una matriz con al menos dos valores (uno verdadero, uno falso).

Ok, eso no funcionaría. Enfoque de escopeta simple:

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

Answer 6

Un simple bucle servirá. Tenga en cuenta que si la matriz está vacía, se cumplen ambas condiciones (todas falsas y todas verdaderas). No verás esto en el resultado, por lo demás, pero puedes descubrir por ti mismo cómo quieres manejar esto.

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

Answer 7

Uno puede usar array_product como se demuestra en php.net en un comentario :

$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

Answer 8

Utilice un bucle for. Si desea verificar que todas las variables son falsas, puede usar un bucle for: una vez que encuentre un elemento verdadero, puede romper el ciclo, de lo contrario las variables son todas falsas. El mismo método que puede usar si desea verificar que todas las variables son verdaderas.

Answer 9

// 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

Answer 10

if(count(array_unique($your_array)) === 1)  
  return current($your_array);

else return;