Cómo evitar isset () y empty ()

Tengo varias aplicaciones antiguas que arrojan muchos mensajes "xyz no está definido" y "desplazamiento indefinido" cuando se ejecutan en el nivel de error E_NOTICE, porque la existencia de variables no se comprueba explícitamente con isset()y consorts.

Estoy considerando trabajar a través de ellos para hacerlos compatibles con E_NOTICE, ya que los avisos sobre variables faltantes o compensaciones pueden salvar vidas, puede haber algunas mejoras menores en el rendimiento y, en general, es la forma más limpia.

Sin embargo, no me gusta lo que cientos de infligir isset() empty()y array_key_exists()S todavía a mi código. Se hincha, se vuelve menos legible, sin ganar nada en términos de valor o significado.

¿Cómo puedo estructurar mi código sin un exceso de comprobaciones de variables, y al mismo tiempo ser compatible con E_NOTICE?

Para aquellos interesados, he ampliado este tema en un pequeño artículo, que proporciona la siguiente información en una forma algo mejor estructurada: La guía definitiva para isset And empty de PHP

En mi humilde opinión, deberías pensar no solo en hacer que la aplicación sea "compatible con E_NOTICE", sino en reestructurar todo. Tener cientos de puntos en su código que regularmente intentan usar variables inexistentes suena como un programa bastante mal estructurado. Intentar acceder a variables inexistentes nunca debería suceder, otros lenguajes se resisten a esto en tiempo de compilación. El hecho de que PHP te permita hacerlo no significa que debas hacerlo.

Estas advertencias están ahí para ayudarlo , no para molestarlo. Si recibe una advertencia "¡Está intentando trabajar con algo que no existe!" , tu reacción debería ser "Vaya, mi error, déjame arreglar eso lo antes posible". ¿De qué otra manera va a diferenciar entre "variables que funcionan bien sin definir" y código honestamente incorrecto que puede conducir a errores graves ? Esta es también la razón por la que siempre, siempre , desarrolla con informes de errores en 11 y sigue trabajando en su código hasta que noNOTICE se emite un . La desactivación de los informes de errores es solo para entornos de producción, para evitar la fuga de información y proporcionar una mejor experiencia de usuario incluso frente a códigos defectuosos.

Elaborar:

Siempre necesitará isseto emptyen algún lugar de su código, la única forma de reducir su ocurrencia es inicializar sus variables correctamente. Dependiendo de la situación, hay diferentes formas de hacerlo:

Argumentos de la función:

function foo ($bar, $baz = null) { ... }

No hay necesidad de comprobar si $baro $bazse establece dentro de la función, ya que acaba de establecer ellos, todo lo que necesita es preocuparse por si sus evalúa el valor de trueu false(o cualquier otra cosa).

Variables regulares en cualquier lugar:

$foo = null;
$bar = $baz = 'default value';

Inicialice sus variables en la parte superior de un bloque de código en el que las va a usar. Esto resuelve el !issetproblema, asegura que sus variables siempre tengan un valor predeterminado conocido, le da al lector una idea de en qué funcionará el siguiente código y, por lo tanto, también sirve como una especie de auto-documentación.

Matrices:

$defaults = array('foo' => false, 'bar' => true, 'baz' => 'default value');
$values = array_merge($defaults, $incoming_array);

Lo mismo que antes, está inicializando la matriz con valores predeterminados y sobrescribiéndolos con valores reales.

En los casos restantes, digamos una plantilla en la que está generando valores que pueden o no ser establecidos por un controlador, solo tendrá que verificar:

<table>
    <?php if (!empty($foo) && is_array($foo)) : ?>
        <?php foreach ($foo as $bar) : ?>
            <tr>...</tr>
        <?php endforeach; ?>
    <?php else : ?>
        <tr><td>No Foo!</td></tr>
    <?php endif; ?>
</table>

Si lo usa regularmente array_key_exists, debe evaluar para qué lo está usando. La única vez que marca la diferencia es aquí:

$array = array('key' => null);
isset($array['key']); // false
array_key_exists('key', $array); // true

Sin embargo, como se indicó anteriormente, si está inicializando correctamente sus variables, no necesita verificar si la clave existe o no, porque sabe que existe. Si usted está recibiendo la matriz de una fuente externa, el valor más probable es que no sea nullpero '', 0, '0', falseo algo parecido, es decir, un valor que se puede evaluar con isseto empty, dependiendo de su intención. Si establece regularmente una clave de matriz en nully quiere que no signifique nada false, es decir, si en el ejemplo anterior los resultados diferentes de issety array_key_existshacen una diferencia en la lógica de su programa, debe preguntarse por qué. La mera existencia de una variable no debería ser importante, solo su valor debería ser de importancia. Si la clave es una bandera true/ false, utilicetrueo falsenonull. La única excepción a esto serían las bibliotecas de terceros que quieran nullsignificar algo, pero como nulles tan difícil de detectar en PHP, todavía tengo que encontrar una biblioteca que haga esto.

Solo escribe una función para eso. Algo como:

function get_string($array, $index, $default = null) {
    if (isset($array[$index]) && strlen($value = trim($array[$index])) > 0) {
        return get_magic_quotes_gpc() ? stripslashes($value) : $value;
    } else {
        return $default;
    }
}

que puedes usar como

$username = get_string($_POST, 'username');

Haga lo mismo para cosas triviales como get_number(), get_boolean(), get_array()y así sucesivamente.

Creo que una de las mejores formas de lidiar con este problema es accediendo a los valores de las matrices GET y POST (COOKIE, SESSION, etc.) a través de una clase.

Cree una clase para cada una de esas matrices y declare __gety __setmétodos ( sobrecarga ). __getacepta un argumento que será el nombre de un valor. Este método debe verificar este valor en la matriz global correspondiente, ya sea usando isset()o empty()y devolver el valor si existe o null(o algún otro valor predeterminado) de lo contrario.

Después de eso, puede acceder con confianza a los valores de la matriz de esta manera: $POST->usernamey realizar cualquier validación si es necesario sin usar ninguna isset()s o empty()s. Si usernameno existe en la matriz global correspondiente null, se devolverá, por lo que no se generarán advertencias ni avisos.

No me importa usar el array_key_exists() función. De hecho, prefiero utilizar esta función específica en lugar de depender de hackers funciones que pueden cambiar su comportamiento en el futuro como emptyyisset (strikedthrough Para evitar susceptibilidades ).

Sin embargo, utilizo una función simple que es útil en esto y en algunas otras situaciones al tratar con índices de matriz :

function Value($array, $key, $default = false)
{
    if (is_array($array) === true)
    {
        settype($key, 'array');

        foreach ($key as $value)
        {
            if (array_key_exists($value, $array) === false)
            {
                return $default;
            }

            $array = $array[$value];
        }

        return $array;
    }

    return $default;
}

Digamos que tiene las siguientes matrices:

$arr1 = array
(
    'xyz' => 'value'
);

$arr2 = array
(
    'x' => array
    (
        'y' => array
        (
            'z' => 'value',
        ),
    ),
);

¿Cómo se obtiene el "valor" de las matrices? Sencillo:

Value($arr1, 'xyz', 'returns this if the index does not exist');
Value($arr2, array('x', 'y', 'z'), 'returns this if the index does not exist');

Ya tenemos cubiertas uni y matrices multidimensionales, ¿qué más podemos hacer?

Tome el siguiente fragmento de código, por ejemplo:

$url = '/programming/1960509';
$domain = parse_url($url);

if (is_array($domain) === true)
{
    if (array_key_exists('host', $domain) === true)
    {
        $domain = $domain['host'];
    }

    else
    {
        $domain = 'N/A';
    }
}
else
{
    $domain = 'N/A';
}

Bastante aburrido, ¿no? Aquí hay otro enfoque que usa la Value()función:

$url = '/programming/1960509';
$domain = Value(parse_url($url), 'host', 'N/A');

Como ejemplo adicional, tome la RealIP()función para una prueba:

$ip = Value($_SERVER, 'HTTP_CLIENT_IP', Value($_SERVER, 'HTTP_X_FORWARDED_FOR', Value($_SERVER, 'REMOTE_ADDR')));

Limpio, ¿eh? ;)

Estoy aqui contigo. Pero los diseñadores de PHP han cometido errores mucho más graves que ese. Aparte de definir una función personalizada para cualquier lectura de valor, no hay forma de evitarlo.

Yo uso estas funciones

function load(&$var) { return isset($var) ? $var : null; }
function POST($var) { return isset($_POST[$var]) ? $_POST[$var] : null; }

Ejemplos

$y = load($x); // null, no notice

// this attitude is both readable and comfortable
if($login=POST("login") and $pass=POST("pass")) { // really =, not ==
  // executes only if both login and pass were in POST
  // stored in $login and $pass variables
  $authorized = $login=="root" && md5($pass)=="f65b2a087755c68586568531ad8288b4";
}

Bienvenido al operador de fusión nula (PHP> = 7.0.1):

$field = $_GET['field'] ?? null;

PHP dice:

El operador coalescente nulo (??) se ha agregado como azúcar sintáctico para el caso común de necesitar usar un ternario junto con isset (). Devuelve su primer operando si existe y no es NULL; de lo contrario, devuelve su segundo operando.

Crea una función que regrese falsesi no se establece y, si se especifica, falsesi está vacía. Si es válido, devuelve la variable. Puede agregar más opciones como se ve en el siguiente código:

<?php
function isset_globals($method, $name, $option = "") {
    if (isset($method[$name])) {    // Check if such a variable
        if ($option === "empty" && empty($method[$name])) { return false; } // Check if empty 
        if ($option === "stringLength" && strlen($method[$name])) { return strlen($method[$name]); }    // Check length of string -- used when checking length of textareas
        return ($method[$name]);
    } else { return false; }
}

if (!isset_globals("$_post", "input_name", "empty")) {
    echo "invalid";
} else {
    /* You are safe to access the variable without worrying about errors! */
    echo "you uploaded: " . $_POST["input_name"];
}
?>

El software no funciona mágicamente por la gracia de Dios. Si está esperando algo que falta, debe manejarlo adecuadamente.

Si lo ignora, probablemente esté creando agujeros de seguridad en sus aplicaciones. En lenguajes estáticos, acceder a una variable no definida simplemente no es posible. No compilará o bloqueará simplemente su aplicación si es nula.

Además, hace que su aplicación no se pueda mantener y se volverá loco cuando sucedan cosas inesperadas. El rigor del lenguaje es imprescindible y PHP, por diseño, está mal en muchos aspectos. Te convertirá en un mal programador si no lo sabes.

No estoy seguro de cuál es su definición de legibilidad, pero el uso adecuado de los bloques empty (), isset () y try / throw / catch es bastante importante para todo el proceso.

Si su E_NOTICE proviene de $ _GET o $ _POST, entonces deben comprobarse con empty () junto con todas las demás comprobaciones de seguridad que esos datos deberían tener que pasar.

Si proviene de fuentes o bibliotecas externas, debe incluirse en try / catch.

Si proviene de la base de datos, se debe marcar $ db_num_rows () o su equivalente.

Si proviene de variables internas, deben inicializarse correctamente. A menudo, este tipo de avisos provienen de asignar una nueva variable al retorno de una función que devuelve FALSE en caso de falla. Estos deben incluirse en una prueba que, en caso de falla, pueda asignar a la variable un valor predeterminado aceptable que el código pueda manejar, o lanzar una excepción que el código pueda manejar.

Estas cosas hacen que el código sea más largo, agregan bloques adicionales y agregan pruebas adicionales, pero no estoy de acuerdo con usted en que creo que definitivamente agregan un valor adicional.

¿Qué pasa con el uso del @operador?

Por ejemplo:

if(@$foo) { /* Do something */ }

Puede decir que esto es malo porque no tiene control de lo que sucede "dentro" de $ foo (si fuera una llamada de función que contiene un error de PHP, por ejemplo), pero si solo usa esta técnica para variables, esto es equivalente a:

if(isset($foo) && $foo) { /* ... */ }