Bagaimana menghindari isset () dan empty ()

Saya memiliki beberapa aplikasi lama yang membuang banyak pesan "xyz tidak terdefinisi" dan "offset tak terdefinisi" saat berjalan pada tingkat kesalahan E_NOTICE, karena keberadaan variabel tidak secara eksplisit diperiksa menggunakan isset()dan selir.

Saya sedang mempertimbangkan untuk mengatasinya agar kompatibel dengan E_NOTICE, karena pemberitahuan tentang variabel yang hilang atau offset dapat menjadi penyelamat, mungkin ada beberapa peningkatan kinerja kecil yang bisa diperoleh, dan secara keseluruhan cara yang lebih bersih.

Namun, saya tidak suka apa yang menyebabkan ratusan isset() empty()dan array_key_exists()dilakukan pada kode saya. Itu membengkak, menjadi kurang dapat dibaca, tanpa mendapatkan apa pun dalam hal nilai atau makna.

Bagaimana saya dapat menyusun kode saya tanpa pemeriksaan variabel yang berlebihan, sekaligus juga kompatibel dengan E_NOTICE?

Bagi mereka yang tertarik, saya telah memperluas topik ini menjadi artikel kecil, yang memberikan informasi di bawah ini dalam bentuk terstruktur yang agak lebih baik: Panduan Definitif Untuk isset PHP Dan kosong

IMHO Anda harus berpikir tentang tidak hanya membuat aplikasi "E_NOTICE kompatibel", tetapi juga merestrukturisasi semuanya. Memiliki ratusan poin dalam kode Anda yang secara teratur mencoba menggunakan variabel yang tidak ada terdengar seperti program yang terstruktur dengan buruk. Mencoba mengakses variabel yang tidak ada seharusnya tidak pernah terjadi, bahasa lain menolak ini pada waktu kompilasi. Fakta bahwa PHP memungkinkan Anda untuk melakukannya tidak berarti Anda harus melakukannya.

Peringatan ini ada untuk membantu Anda, bukan untuk mengganggu Anda. Jika Anda mendapat peringatan, "Anda mencoba bekerja dengan sesuatu yang tidak ada!" , reaksi Anda seharusnya "Ups, saya buruk, biarkan saya memperbaikinya secepatnya." Bagaimana lagi Anda akan membedakan antara "variabel yang bekerja dengan baik tanpa definisi" dan kode yang benar - benar salah yang dapat menyebabkan kesalahan serius ? Ini juga alasan mengapa Anda selalu, selalu , mengembangkan dengan pelaporan kesalahan berubah menjadi 11 dan terus memasukkan kode Anda sampai tidak ada satu punNOTICE yang dikeluarkan. Menonaktifkan pelaporan kesalahan hanya untuk lingkungan produksi, untuk menghindari kebocoran informasi dan memberikan pengalaman pengguna yang lebih baik bahkan saat menghadapi kode buggy.

Untuk menguraikan:

Anda akan selalu membutuhkan issetatau emptydi suatu tempat dalam kode Anda, satu-satunya cara untuk mengurangi kemunculannya adalah dengan menginisialisasi variabel Anda dengan benar. Bergantung pada situasinya, ada berbagai cara untuk melakukannya:

Argumen fungsi:

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

Tidak perlu untuk memeriksa apakah $baratau $bazditetapkan dalam fungsi karena Anda hanya mengatur mereka, semua yang perlu Anda khawatir tentang adalah jika nilai mengevaluasi mereka untuk trueatau false(atau apapun yang lain).

Variabel biasa di mana saja:

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

Inisialisasi variabel Anda di bagian atas blok kode tempat Anda akan menggunakannya. Ini memecahkan !issetmasalah, memastikan bahwa variabel Anda selalu memiliki nilai default yang diketahui, memberi pembaca gambaran tentang apa yang akan dikerjakan kode berikut dan dengan demikian juga berfungsi sebagai semacam dokumentasi mandiri.

Array:

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

Hal yang sama seperti di atas, Anda menginisialisasi array dengan nilai default dan menimpanya dengan nilai aktual.

Dalam kasus yang tersisa, katakanlah template tempat Anda mengeluarkan nilai yang mungkin atau mungkin tidak disetel oleh pengontrol, Anda hanya perlu memeriksa:

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

Jika Anda sering menggunakannya array_key_exists, Anda harus mengevaluasi untuk apa Anda menggunakannya. Satu-satunya saat hal itu membuat perbedaan adalah di sini:

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

Seperti yang dinyatakan di atas, jika Anda menginisialisasi variabel Anda dengan benar, Anda tidak perlu memeriksa apakah kuncinya ada atau tidak, karena Anda tahu itu ada. Jika Anda mendapatkan array dari sumber eksternal, nilai akan kemungkinan besar tidak akan nulltetapi '', 0, '0', falseatau sesuatu seperti itu, yaitu nilai yang Anda dapat mengevaluasi dengan issetatau empty, tergantung pada niat Anda. Jika Anda secara teratur menyetel kunci array ke nulldan ingin artinya tidak berarti apa pun false, yaitu jika dalam contoh di atas hasil yang berbeda issetdan array_key_existsmembuat perbedaan pada logika program Anda, Anda harus bertanya pada diri sendiri mengapa. Keberadaan variabel seharusnya tidak penting, hanya nilainya yang harus menjadi konsekuensinya. Jika kuncinya adalah true/ falseflag, maka gunakantrueatau . Satu-satunya pengecualian untuk ini adalah perpustakaan pihak ke-3 yang ingin memiliki arti, tetapi karena sangat sulit untuk dideteksi di PHP, saya belum menemukan perpustakaan apa pun yang melakukan ini.false , bukannullnullnull

Cukup tulis fungsi untuk itu. Sesuatu seperti:

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

yang dapat Anda gunakan sebagai

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

Lakukan hal yang sama untuk hal-hal sepele seperti get_number(), get_boolean(), get_array()dan sebagainya.

Saya percaya salah satu cara terbaik untuk mengatasi masalah ini adalah dengan mengakses nilai array GET dan POST (COOKIE, SESSION, dll.) Melalui kelas.

Buat kelas untuk setiap array tersebut dan deklarasikan __getserta __setmetode ( overloading ). __getmenerima satu argumen yang akan menjadi nama nilai. Metode ini harus memeriksa nilai ini dalam larik global terkait, baik menggunakan isset()atau empty()dan mengembalikan nilai jika ada ataunull (atau nilai default lainnya) sebaliknya.

Setelah itu Anda dapat mengakses nilai array dengan percaya diri dengan cara ini: $POST->usernamedan melakukan validasi apa pun jika diperlukan tanpa menggunakan isset()s atau empty()s. Jika usernametidak ada dalam larik global terkait maka nullakan dikembalikan, jadi tidak ada peringatan atau pemberitahuan yang akan dibuat.

Saya tidak keberatan menggunakan array_key_exists()fungsi tersebut. Sebenarnya, saya lebih suka menggunakan fungsi khusus ini daripada mengandalkan fungsi hack yang dapat mengubah perilaku mereka di masa depan seperti emptydanisset (menyerang untuk menghindari kerentanan ).

Bagaimanapun, saya menggunakan fungsi sederhana yang berguna dalam hal ini, dan beberapa situasi lain dalam menangani indeks array :

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

Katakanlah Anda memiliki array berikut:

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

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

Bagaimana Anda mendapatkan "nilai" dari array? Sederhana:

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

Kami sudah memiliki array uni dan multi-dimensi yang tercakup, apa lagi yang bisa kami lakukan?

Ambil potongan kode berikut ini misalnya:

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

Cukup membosankan bukan? Berikut adalah pendekatan lain menggunakan Value()fungsi tersebut:

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

Sebagai contoh tambahan, ambil RealIP()fungsi untuk tes:

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

Rapi, ya? ;)

Aku disini bersama mu. Tapi desainer PHP telah membuat kesalahan yang jauh lebih buruk dari itu. Singkatnya, mendefinisikan fungsi kustom untuk pembacaan nilai apa pun, tidak ada jalan lain.

Saya menggunakan fungsi ini

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

Contoh

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

Selamat datang di operator penggabungan nol (PHP> = 7.0.1):

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

PHP mengatakan:

Operator penggabungan nol (??) telah ditambahkan sebagai gula sintaksis untuk kasus umum yang memerlukan penggunaan terner dalam hubungannya dengan isset (). Ia mengembalikan operan pertamanya jika ada dan bukan NULL; jika tidak, ia mengembalikan operan keduanya.

Buat fungsi yang mengembalikan falsejika tidak disetel, dan, jika ditentukan, falsejika kosong. Jika valid itu mengembalikan variabel. Anda dapat menambahkan lebih banyak opsi seperti yang terlihat pada kode di bawah ini:

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

Perangkat lunak tidak secara ajaib dijalankan oleh rahmat Tuhan. Jika Anda mengharapkan sesuatu yang hilang, Anda harus menanganinya dengan benar.

Jika Anda mengabaikannya, Anda mungkin membuat lubang keamanan di aplikasi Anda. Dalam bahasa statis, mengakses variabel yang tidak ditentukan itu tidak mungkin. Itu tidak akan hanya mengkompilasi atau merusak aplikasi Anda jika null.

Selain itu, itu membuat aplikasi Anda tidak dapat dikelola, dan Anda akan menjadi gila ketika hal-hal yang tidak terduga terjadi. Ketegasan bahasa adalah suatu keharusan dan PHP, secara desain, salah dalam banyak aspek. Ini akan membuat Anda menjadi programmer yang buruk jika Anda tidak menyadarinya.

Saya tidak yakin apa definisi Anda tentang keterbacaan, tetapi penggunaan yang tepat dari blok empty (), isset () dan try / throw / catch, cukup penting untuk keseluruhan proses.

Jika E_NOTICE Anda berasal dari $ _GET atau $ _POST, maka E_NOTICE Anda harus diperiksa dengan empty () bersama dengan semua pemeriksaan keamanan lain yang harus dilalui data tersebut.

Jika berasal dari feed atau pustaka eksternal, itu harus dibungkus dengan try / catch.

Jika berasal dari database, $ db_num_rows () atau yang setara harus diperiksa.

Jika berasal dari variabel internal, mereka harus diinisialisasi dengan benar. Seringkali, jenis pemberitahuan ini berasal dari menetapkan variabel baru untuk mengembalikan fungsi yang mengembalikan FALSE saat gagal. Mereka harus digabungkan dalam pengujian yang, jika terjadi kegagalan, dapat menetapkan variabel nilai default yang dapat diterima yang dapat ditangani kode, atau melontarkan pengecualian yang dapat ditangani kode.

Hal-hal ini membuat kode lebih panjang, menambahkan blok ekstra, dan menambahkan tes ekstra, tetapi saya tidak setuju dengan Anda karena saya pikir mereka pasti menambah nilai ekstra.

Bagaimana dengan menggunakan @ operator?

Sebagai contoh:

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

Anda mungkin mengatakan ini buruk karena Anda tidak memiliki kendali atas apa yang terjadi "di dalam" $ foo (jika itu adalah panggilan fungsi yang berisi kesalahan PHP misalnya), tetapi jika Anda hanya menggunakan teknik ini untuk variabel, ini setara dengan:

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