Как избежать использования isset () и empty ()

У меня есть несколько старых приложений, которые выдают много сообщений «xyz is undefined» и «undefined offset» при работе на уровне ошибки E_NOTICE, потому что наличие переменных не проверяется явно с помощью isset()и consorts.

Я подумываю о работе над ними, чтобы сделать их совместимыми с E_NOTICE, поскольку уведомления об отсутствующих переменных или смещениях могут быть спасением, могут быть некоторые незначительные улучшения производительности, и в целом это более чистый способ.

Однако мне не нравится то, что делают с моим кодом сотни isset() empty()и array_key_exists(). Он раздувается, становится менее читаемым, не приобретая ничего с точки зрения ценности или смысла.

Как я могу структурировать свой код без лишних проверок переменных, оставаясь при этом совместимым с E_NOTICE?

Для тех, кто заинтересован, я расширил эту тему до небольшой статьи, в которой приведенная ниже информация представлена ​​в несколько лучше структурированной форме: Полное руководство по isset PHP и пусто

ИМХО, вам следует подумать не просто о том, чтобы сделать приложение «совместимым с E_NOTICE», а о реструктуризации всего этого. Наличие сотен точек в вашем коде, которые регулярно пытаются использовать несуществующие переменные, звучит как довольно плохо структурированная программа. Попытки получить доступ к несуществующим переменным никогда не должны происходить, другие языки отказываются от этого во время компиляции. Тот факт, что PHP позволяет вам это делать, не означает, что вы должны это делать.

Эти предупреждения призваны помочь вам, а не раздражать вас. Если вы получаете предупреждение «Вы пытаетесь работать с тем, чего не существует!» , ваша реакция должна быть "Ой, моя проблема, позвольте мне исправить это как можно скорее". Как еще вы собираетесь отличить «переменные, которые прекрасно работают без определения» и действительно неправильный код, который может привести к серьезным ошибкам ? Это также причина, по которой вы всегда, всегда разрабатываете с отчетом об ошибках, обращенным к 11, и продолжаете работать над своим кодом, пока не останется ни одногоNOTICEвыпущен. Отключение отчетов об ошибках предназначено только для производственных сред, чтобы избежать утечки информации и улучшить взаимодействие с пользователем даже при наличии ошибок в коде.

Чтобы уточнить:

Вы всегда будете нуждаться issetили emptyгде-то в вашем коде, единственный способ уменьшить их появление - правильно инициализировать ваши переменные. В зависимости от ситуации это можно сделать разными способами:

Аргументы функции:

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

Нет необходимости проверять, установлены ли $barили $bazвнутри функции, потому что вы просто устанавливаете их, все, о чем вам нужно беспокоиться, это оценивать их значение как trueили false(или что-то еще).

Обычные переменные где угодно:

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

Инициализируйте свои переменные в верхней части блока кода, в котором вы собираетесь их использовать. Это решает !issetпроблему, гарантирует, что ваши переменные всегда имеют известное значение по умолчанию, дает читателю представление о том, над чем будет работать следующий код, и тем самым также служит своего рода самодокументированием.

Массивы:

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

То же, что и выше, вы инициализируете массив значениями по умолчанию и перезаписываете их фактическими значениями.

В остальных случаях, скажем, шаблон, в котором вы выводите значения, которые могут или не могут быть установлены контроллером, вам просто нужно проверить:

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

Если вы обнаружите, что регулярно используете array_key_exists, вам следует оценить, для чего вы его используете. Единственный раз, когда это имеет значение, здесь:

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

Однако, как указано выше, если вы правильно инициализируете свои переменные, вам не нужно проверять, существует ли ключ или нет, потому что вы знаете, что это так. Если вы получаете массив из внешнего источника, то значение будет , скорее всего , не будет , nullно '', 0, '0', falseили нечто подобное, то есть значение , которое можно оценить с issetили empty, в зависимости от вашего намерения. Если вы регулярно устанавливаете ключ массива в значение nullи хотите, чтобы он означал что угодно, но false, например, если в приведенном выше примере разные результаты issetи array_key_existsимеют значение для логики вашей программы, вы должны спросить себя, почему. Само существование переменной не должно иметь значения, важно только ее значение. Если ключ - это true/ falseflag, используйтеtrueили falseнет null. Единственным исключением из этого правила могут быть сторонние библиотеки, которые хотят nullчто-то значить, но, поскольку их nullтак сложно обнаружить в PHP, мне еще предстоит найти какую-либо библиотеку, которая это делает.

Просто напишите для этого функцию. Что-то вроде:

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;
    }
}

который вы можете использовать как

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

Сделайте то же самое для тривиальной вещи , как get_number(), get_boolean(), get_array()и так далее.

Я считаю, что одним из лучших способов справиться с этой проблемой является доступ к значениям массивов GET и POST (COOKIE, SESSION и т. Д.) Через класс.

Создайте класс для каждого из этих массивов и объявите __getи __setметоды ( перегрузка ). __getпринимает один аргумент, который будет именем значения. Этот метод должен проверять это значение в соответствующем глобальном массиве, используя isset()или, empty()и возвращать значение, если оно существует, или null(или какое-либо другое значение по умолчанию) в противном случае.

После этого вы можете уверенно обращаться к значениям массива следующим образом: $POST->usernameи при необходимости выполнять любую проверку без использования каких-либо isset()s или empty()s. Если usernameне существует в соответствующем глобальном массиве, то nullбудет возвращено, поэтому никаких предупреждений или уведомлений не будет.

Я не против использовать эту array_key_exists()функцию. Фактически, я предпочитаю использовать эту конкретную функцию, а не полагаться на функции взлома, которые могут изменить свое поведение в будущем, например emptyиisset (зачеркнуто, чтобы избежать уязвимостей ).

Однако я использую простую функцию, которая пригодится в этой и некоторых других ситуациях при работе с индексами массива :

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;
}

Допустим, у вас есть следующие массивы:

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

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

Как получить «значение» из массивов? Просто:

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

У нас уже есть одномерные и многомерные массивы, что еще мы можем сделать?

Возьмем, к примеру, следующий фрагмент кода:

$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';
}

Довольно скучно, правда? Вот еще один подход с использованием Value()функции:

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

В качестве дополнительного примера возьмем RealIP()функцию для теста:

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

Аккуратно, а? ;)

Я здесь с тобой. Но дизайнеры PHP сделали гораздо более худших ошибок, чем это. Если не считать определения пользовательской функции для чтения любого значения, другого пути нет.

Я использую эти функции

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

Примеры

$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";
}

Добро пожаловать в оператор объединения с нулевым значением (PHP> = 7.0.1):

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

PHP говорит:

Оператор объединения с нулевым значением (??) был добавлен в качестве синтаксического сахара для общего случая необходимости использования тернарного элемента вместе с isset (). Он возвращает свой первый операнд, если он существует и не равен NULL; в противном случае возвращается второй операнд.

Создайте функцию, которая возвращает, falseесли не задана, и, если она указана, falseесли она пуста. Если верно, он возвращает переменную. Вы можете добавить дополнительные параметры, как показано в приведенном ниже коде:

<?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"];
}
?>

Программное обеспечение не запускается волшебным образом по милости божьей. Если вы ожидаете чего-то, чего не хватает, нужно правильно с этим справиться.

Если вы игнорируете это, вы, вероятно, создаете дыры в безопасности в своих приложениях. В статических языках доступ к неопределенной переменной просто невозможен. Он не просто скомпилирует или завершит работу вашего приложения, если оно пустое.

Более того, это делает ваше приложение недоступным для обслуживания, и вы сходите с ума, когда случаются неожиданные вещи. Строгость языка является обязательной, и PHP изначально ошибочен во многих аспектах. Если вы не знаете, из вас получится плохой программист.

Я не уверен, каково ваше определение читабельности, но правильное использование блоков empty (), isset () и try / throw / catch очень важно для всего процесса.

Если ваш E_NOTICE поступает из $ _GET или $ _POST, тогда они должны быть проверены на empty () вместе со всеми другими проверками безопасности, которые эти данные должны пройти.

Если он поступает из внешних каналов или библиотек, он должен быть заключен в файл try / catch.

Если он поступает из базы данных, следует проверить $ db_num_rows () или его эквивалент.

Если он исходит от внутренних переменных, они должны быть правильно инициализированы. Часто эти типы уведомлений приходят из-за присвоения новой переменной возвращаемого значения функции, которая возвращает FALSE в случае сбоя. Они должны быть заключены в тест, который в случае сбоя может либо присвоить переменной приемлемое значение по умолчанию, которое может обработать код, либо выдать исключение, которое может обработать код.

Эти вещи делают код длиннее, добавляют дополнительные блоки и дополнительные тесты, но я не согласен с вами в том смысле, что я думаю, что они определенно добавляют дополнительную ценность.

А как насчет использования @оператора?

Например:

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

Вы можете сказать, что это плохо, потому что вы не контролируете, что происходит «внутри» $ foo (например, если это был вызов функции, содержащий ошибку PHP), но если вы используете этот метод только для переменных, это эквивалентно:

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