PHP bir değişkenin varlığını sınamak için en iyi yolu;

13 Cevap php

isset() docs :

isset() will return FALSE if testing a variable that has been set to NULL.

Temel olarak, isset() değişkeni tüm ayarlı olup olmadığını kontrol etmez, ama bir şey ayarlanmış ama olsun NULL.

Göz önüne alındığında, aslında bir değişkenin varlığını kontrol etmek için en iyi yolu nedir? Ben böyle bir şey denedim:

if(isset($v) || @is_null($v))

(@ uyarıyı önlemek için gerekli olduğunda $v ayarlı değil) ama is_null() isset() benzer bir sorun var: O geri TRUE unset değişkenlere! Ayrıca, görünür:

@($v === NULL)

tam @is_null($v) gibi çalışır, böylece de, dışarıda.

Nasıl güvenilir PHP bir değişkenin varlığını kontrol etmek gerekiyor?


Edit: ayarlı değil değişkenler ve ayarlanır değişkenler arasında PHP açık bir fark vardır NULL:

<?php
$a = array('b' => NULL);
var_dump($a);

PHP $a['b'] bulunmaktadır ve bir NULL değerine sahip olduğunu göstermektedir. Eğer eklerseniz:

var_dump(isset($a['b']));
var_dump(isset($a['c']));

Eğer ben isset() işleviyle bahsediyorum belirsizlik görebilirsiniz. İşte tüm bu üç çıkış var var_dump()s:

array(1) {
  ["b"]=>
  NULL
}
bool(false)
bool(false)


Ek düzenleme: iki şey.

Bir, kullanımı durum. Bir dizi dizinin anahtarları tablonun sütunları olan bir SQL UPDATE deyimi, bir veri içine döndü ve dizinin değerleri her sütuna uygulanacak değerlerdir ediliyor. Tablonun sütunları herhangi dizideki NULL değeri ileterek anlamına bir NULL değerini tutabilir. Sen need bir dizi mevcut değil tuşu, ve NULL ayarlı bir dizinin değer arasında ayırt etmek için bir yol; Bu sütunun değerini güncellenmesi ve NULL için sütunun değerini güncelleme değil arasındaki fark.

İkincisi, Zoredache's answer, array_key_exists() düzgün çalışır, benim yukarıdaki kullanım durumda ve herhangi bir global değişkenler için:

<?php
$a = NULL;
var_dump(array_key_exists('a', $GLOBALS));
var_dump(array_key_exists('b', $GLOBALS));

çıkışlar:

bool(true)
bool(false)

Ki düzgün hemen her yerde kolları beri PHP NULL, I'm calling array_key_exists() resmi kolay yolu ayarlanır yoktur değişkenleri ve değişkenler arasındaki herhangi bir belirsizlik olması orada görebilirsiniz gerçekten Bir değişken varlığını kontrol edin.

its docs göre, array_key_exists() olmasıyla benzer şekilde çalıştığı, property_exists() orada hangi için (Aklıma sadece diğer vaka, sınıf özellikleri için düzgün ayarlanan ve NULL ayarlı değil birbirinden ayırır.)

13 Cevap

Eğer kontrol ediyoruz değişken yapabileceğini küresel kapsamda olurdu:

array_key_exists('v', $GLOBALS) 

Nesne özellikleri property_exists tarafından varlığı için kontrol edilebilir

Bir birim test, Örnek:

function testPropertiesExist()
{
    $sl =& $this->system_log;
    $props = array('log_id',
                   'type',
                   'message',
                   'username',
                   'ip_address',
                   'date_added');

    foreach($props as $prop) {
        $this->assertTrue(property_exists($sl, $prop),
                           "Property <{$prop}> exists");
    }
}

Sen boş bir değişkenin varlığını sınamak için kompakt dil yapısı kullanabilirsiniz. Boş değerler gösterecektir olurken yoktur Değişkenler, sonuç kadar açılmıyor.

$x = null;
$y = 'y';

$r = compact('x', 'y', 'z');
print_r($r);

// Output:
// Array ( 
//  [x] => 
//  [y] => y 
// ) 

Da örnek durumunda:

if (compact('v')) {
   // True if $v exists, even when null. 
   // False on var $v; without assignment and when $v does not exist.
}

Tabii ki küresel alanda değişkenler için de array_key_exists () kullanabilirsiniz.

B.t.w. Şahsen ben bir değişken mevcut değil ve değişken null değerine sahip arasında anlamsal fark var veba gibi durumlardan kaçınmak olacaktır. PHP ve diğer birçok dil sadece orada olduğunu düşünmüyor.

Explaining NULL, logically thinking

I guess the obvious answer to all of this is... Don't initialise your variables as NULL, initalise them as something relevant to what they are intended to become.

Treat NULL properly

NULL should be treated as "non-existant value", which is the meaning of NULL. The variable can't be classed as existing to PHP because it hasn't been told what type of entity it is trying to be. It may aswell not exist, so PHP just says "Fine, it doesn't because there's no point to it anyway and NULL is my way of saying this".

An argument

Şimdi iddia edelim. "Ama NULL 0 veya YANLIŞ veya'' demek gibi.

Yanlış, 0-YANLIŞ-'' tüm hala boş değerler olarak sınıflandırılır, ancak değer veya bir soruya önceden belirlenmiş cevap çeşit olarak belirtilir. FALSE evet ya da hayır, '' Birisi teslim ve 0 miktar veya zaman cevap Onlar ARE vb olup başlığa cevap için cevap ayarlanan olarak onları geçerli kılan cevap / sonucu bazı türü olarak ayarlayın.

NULL kadar hiç, bize evet ya da hayır söylemez ve bize zaman söylemek değil ve sunulan var, bize boş bir dize söylemek değil sadece ne cevap değildir. Bu anlayış NULL olarak temel mantık bu.

Summary

Bu sorunu aşmanın tuhaf işlevleri oluşturma hakkında, sadece beynin NULL'A bakar şekilde değişiyor değil. NULL ise, o şey olarak ayarlanmış değil varsayalım. Eğer önceden tanımlayan değişkenler varsa o YANLIŞ ya da "" onlar için niyetinde kullanım tipine bağlı olarak, 0 olarak önceden tanımlayabilirsiniz.

Feel free to quote this. It's off the top of my logical head :)

Bir ek olarak greatbigmassive's discussion of what NULL means, "bir değişkenin varlığı" aslında ne demek düşünün.

In many languages, you have to explicitly declare every variable before you use it; Bu türünü belirlemek olabilir, ama daha da önemlisi onun scope bildirir. Bir değişken her yerde onun kapsamı ve hiçbir yerde bunun dışında "var" - olması bir bütün işlevi, ya da tek bir "blok".

Within its scope, a variable assigns some meaning to a label hangi, programcı, seçtiniz. Kapsamı dışında, bu etiket (temelde alakasız Farklı kapsamında aynı etiket kullanmak olsun) anlamsızdır.

In PHP, variables do not need to be declared - Onlar kısa sürede bunları ihtiyaç olarak hayat buluyor. Eğer ilk kez bir değişkene yazdığınızda, PHP bu değişken için bellekte bir giriş ayırır. Şu anda bir girdi yoksa bir değişken okursanız, PHP değişken değere sahip olduğunu düşünmektedir NULL.

Önce bunu "başlatılıyor" olmadan bir değişken kullanmak Ancak, otomatik kod kalite Dedektörler genelde sizi uyaracaktır. Birincisi, bu tür $thingId atama ama $thing_id okuma gibi yazım hataları, tespit yardımcı olur; ama ikincisi, sadece bir beyan olduğu gibi, bu değişken anlamı sahip olduğu kapsamını dikkate zorlar.

Any code that cares whether a variable "exists" is part of the scope of that variable - bu başlatılmak edilmiş olsun veya olmasın, bir programcı olarak kod bu noktada anlam bu etiketi verdik. Eğer kullanıyorsanız bu yana, bir anlamda "var" olmalıdır, ve eğer varsa, bu bir örtülü değeri olmalıdır; PHP, bu örtük değeri null.

Çünkü PHP çalışır şekilde, bu değil anlam verdik etiket kapsamı olarak mevcut değişkenlerin ad davranır kod yazmak mümkündür, ancak anahtar-değer mağaza çeşit olarak. Bu, örneğin, bu gibi bir kod çalıştırabilir: $var = $_GET['var_name']; $$var = $_GET['var_value'];. Just because you can, doesn't mean it's a good idea.

Bu ilişkisel diziler denir, PHP anahtar-değer mağazaları temsil eden çok daha iyi bir yol var, çıkıyor. Bir dizinin değerlerini değişkenler gibi tedavi edilebilir olsa da, aynı zamanda bir bütün olarak dizisinde işlemleri gerçekleştirebilirsiniz. If you have an associative array, you can test if it contains a key using array_key_exists() .

Ayrıca dinamik özelliklerini ayarlayarak, benzer bir şekilde nesneleri kullanabileceğiniz kullanabilirsiniz property_exists() in exactly the same way. Of course, if you define a class, you can declare which properties it has durumda - hatta public, {[arasında seçim yapabilirsiniz (3)]}, ve protected kapsamı.

Orada başlatıldı edilmemiş (ya da unset() açık olan) bir değişken arasında bir technical farkı (bir dizi anahtar veya bir obje özelliğine değil) ve bir rağmen kimin değeri null, bu fark meaningful onlar kullanılacak anlamına değil, bir şekilde değişkenleri kullanıyor olması dikkate herhangi bir kod.

Çeşitli tartışmalar ve cevapları bir bakışını vermek için çalışılıyor:

There is no single answer to the question which can replace all the ways isset kullanılabilir. null mantıksal davranış da Some use cases are addressed by other functions, while others do not stand up to scrutiny, or have dubious value beyond code golf. Far from being "broken" or "inconsistent", other use cases demonstrate why isset 'nin reaksiyonu.

Real use cases (with solutions)

1. Array keys

Diziler unset ve onlar sanki isset onları tedavi ile, değişkenlerin koleksiyonları gibi tedavi edilebilir. Onlar iterated beri Ancak, vb, sayılır, bir eksik değer olan değeri olarak aynı değildir null.

Bu durumda sorunun cevabı, use array_key_exists() instead of isset() olduğunu.

Bu bir işlev argüman olarak kontrol etmek için bir dizi alır beri dizinin kendisi yoksa, PHP hala "uyarıları" çıkaracağız. Bazı durumlarda, bu geçerli olarak her boyut ilk başlatıldı olması gerektiğini iddia edilebilir, bu nedenle bildirim işini yapıyor. Diğer durumlarda, bu da dizinin her bir boyuta kontrol "özyinelemeli" array_key_exists fonksiyonu, bu önlemek, ancak temel olarak @array_key_exists ile aynı olacaktır. Ayrıca, null değerlerinin işlenmesi için biraz teğet.

2. Object properties

"Nesne Tabanlı Programlama" geleneksel teoride, kapsülleme ve polimorfizm nesneler önemli özellikleri şunlardır; PHP'nin gibi sınıf tabanlı OOP uygulanmasında, kapsüllü özellikleri, sınıf tanımının parçası olarak bildirilir ve erişim seviyeleri (public, protected verilen veya {[(2)] vardır }).

Bir dizi anahtarları, ve bazı insanlar sınıf az nesneleri (kullanmak gibi Ancak, PHP, dinamik bir nesneye özellikler eklemenizi sağlar teknik, hiçbir yöntem vardır ki, stdClass yerleşik örnekleri veya çağrışımlı dizilere benzer bir şekilde özel işlevleri). Bu fonksiyon, belirli bir özelliği kendisine verilen nesnesine eklenmiş olup olmadığını bilmek isteyebilirsiniz durumlara yol açar.

Dizi tuşları ile olduğu gibi, a solution for checking object properties is included in the language, called, reasonably enough, property_exists .

Non-justifiable use cases, with discussion

3. register_globals, and other pollution of the global namespace

register_globals özellik adları HTTP isteğinin yönleri ile tespit edilmiştir (GET ve POST parametreleri ve çerezler) genel kapsam değişkenleri eklendi. Bu PHP 4.2, released Aug 2000 beri varsayılan olarak devre dışıdır ve PHP 5.4, released Mar 2012 tamamen kaldırılmıştır neden olan, arabası ve güvensiz kod yol açabilir. Ancak, bazı sistemler hala bu özellik etkin veya taklit ile çalışan mümkündür. Bu global anahtar kelime veya $GLOBALS dizisi kullanarak başka yollarla küresel ad "kirletme" da mümkündür.

Öncelikle, register_globals kendisi beklenmedik GET beri, POST ve çerez değerleri her zaman ({hala dönen {[2) (]} ile dizeleri olacak, bir null değişkeni üretmek olası değildir oturumda [(3)]} den isset), ve değişkenler tamamen programcının kontrolü altında olmalıdır.

Bu önceki bazı başlatma fazla yazar İkincisi, değer ile bir değişkenin kirlilik null sadece bir konudur. "Over-yazma" kod başka bir yerde, iki devlet arasındaki ayrım ise bu olasılık against yapmak bir argüman olan kendi üzerinde bu kadar null, sadece sorunlu olacaktır ile başlatılmamış bir değişken böyle bir ayrım.

4. get_defined_vars and compact

Böyle get_defined_vars and compact , allow you to treat variable names as though they were keys in an array. For global variables, the super-global array $GLOBALS gibi PHP birkaç nadiren kullanılan fonksiyonlar, benzer erişim sağlar ve daha yaygındır. Bir değişken, ilgili kapsamda tanımlı değilse erişim Bu yöntemler farklı davranacaktır.

Bu mekanizmalardan birini kullanarak bir dizi olarak değişkenler bir dizi tedavi etmek için karar verdik, herhangi normal bir dizide gibi üzerinde aynı işlemleri yapabilir. Sonuç olarak, 1'e bakın.

Sadece bu fonksiyonlar (örneğin "get_defined_vars tarafından döndürülen dizideki bir anahtar 'foo' olacak?") Davranmaya hakkında ne kadar tahmin var İşlevsellik sadece fonksiyonunu çalıştırabilirsiniz beri, gereksiz ve hiçbir kötü etkisi ile öğrenmek.

4a. Variable variables ($$foo)

Bir ilişkisel diziye değişkenler bir dizi çevirmek fonksiyonları oldukça aynı olmasa da, kullanan çoğu durumda "variable variables" ve kullanmak için değiştirilmesi gerektiğini olabilir ("bu diğer değişkene bağlı adında bir değişkene atamak") ilişkisel dizi yerine.

Bir değişken adı, temelde, programcı tarafından bir değere verilen etiket; run-anda belirlenmesi eğer, gerçekten bir etiket ama bazı anahtar-değer deposunda bir anahtar değil. Daha pratik bir dizi kullanarak değil, vb, yineleme, saymak yeteneğini kaybediyor; o da $$foo tarafından yazılmış fazla olabilir bu yana, bir değişken "dışarıda" anahtar-değer mağaza olması imkansız hale gelebilir.

Bir kez bir ilişkisel dizi kullanmak için değiştirildi, kod çözüm 1 mükellef olacaktır. Dolaylı nesne özellik erişimi (örneğin, $foo->$property_name) solüsyonu 2 ile ele alınabilir.

5. isset is so much easier to type than array_key_exists

Ben bu konuyla çok emin değilim, ama evet, PHP'nin fonksiyon isimleri bazen oldukça soluksuz uzun ve tutarsız olabilir. Görünüşe göre, PHP tarih öncesi sürümleri bir diyez gibi bir işlev adım uzunluğu kullanılır, bu yüzden Rasmus kasten htmlspecialchars gibi işlev isimleri oluşur bu yüzden karakter alışılmadık bir dizi olurdu ...

Yine de, en azından biz ha, Java yazmıyorsunuz? ;)

6. Uninitialized variables have a type

manual page on variable basics Bu ifadeyi içerir:

Başlatılmamış değişkenler kullanıldıkları bağlama göre kendi türünde bir varsayılan değere sahip

Ben bu deyimi içine çok fazla okuma olup olmadığını "başlatılmamış ama bilinen tip" ya da Zend Motoru bazı kavram var olup olmadığından emin değilim.

Ne açıktır İlklendirilmemiş değişkenler için o sayfada anlatılan davranışları değer bir değişkenin davranışı ile aynıdır, çünkü onların davranışları için hiçbir pratik fark yarattığıdır null. Bir örnek almak için, hem $a ve $b bu kodda tamsayı olarak sona erecek 42:

unset($a);
$a += 42;

$b = null;
$b += 42;

(Ilk daha iyi kod yazmak için bir girişim, bir bildirilmemiş değişken hakkında bir haber çıkaracağız, ama kod aslında nasıl çalıştığını herhangi bir fark yapmaz.)

99. Detecting if a function has run

(Keeping this one last, as it's much longer than the others. Maybe I'll edit it down later...)

Aşağıdaki kodu göz önünde bulundurun:

$test_value = 'hello';
foreach ( $list_of_things as $thing ) {
    if ( some_test($thing, $test_value) ) {
        $result = some_function($thing);
    }
}
if ( isset($result) ) {
    echo 'The test passed at least once!';
}

some_function null, echo bile ulaşmış olmayacak bir olasılık var dönebiliyor some_test döndürdü {[(4) }]. Programcının niyeti $result ayarlanmış asla algılamak oldu, ama PHP onları bunu yapmaya izin vermez.

Ancak, bir dış döngü eklerseniz netleşecektir bu yaklaşım ile diğer sorunlar vardır:

foreach ( $list_of_tests as $test_value ) {
    // something's missing here...
    foreach ( $list_of_things as $thing ) {
        if ( some_test($thing, $test_value) ) {
            $result = some_function($thing);
        }
    }
    if ( isset($result) ) {
        echo 'The test passed at least once!';
    }
}

$result açıkça hiçbir zaman başlatıldı çünkü ilk testi geçerken, imkansız sonraki testleri geçti olup olmadığını söylemek için yapım, bir değer alacaktır. This is actually an extremely common bug when variables aren't initialised properly.

Bunu düzeltmek için, ben bir şey eksik yorumladı ettik hattı üzerinde bir şeyler yapmak gerekiyor. En bariz çözüm $result some_function return asla bir "uç değeri" ayarlamak için; Bu ise null, daha sonra kodun geri kalanı iyi çalışacaktır. some_function (muhtemelen kendi başına kötü bir işaret) son derece öngörülemeyen bir dönüş türü vardır çünkü bir terminal değer için doğal aday yoksa, o zaman ek bir mantıksal değerdir, örneğin $found, bunun yerine kullanılabilir.

Thought experiment one: the very_null constant

, Burada bir terminal değer olarak kullanım için - gibi null - PHP teorik özel bir sabit sağlayabilir muhtemelen, bir fonksiyonun bu dönmek için yasadışı olurdu, ya da null zorlanamadığında olacağını ve aynı muhtemelen bir işlev argüman olarak geçen için geçerli olacak. Yani en kısa sürede yeniden faktör kod karar gibi bu çok özel durum biraz daha basit yapmak, ama olur - örneğin, ayrı bir işlevi iç döngü koymak - faydasız olacak. Sürekli fonksiyonlar arasındaki geçmiş olabilir, o some_function iade etmem garanti olamazdı, bu yüzden artık evrensel bir uç değer olarak yararlı olacaktır.

Bu durumda uninitialised değişkenleri tespit etmek için argüman bu özel sabiti için argüman aşağı kaynar: unset($result) ile yorum değiştirin ve farklı $result = null o davranırsanız, size tanıtan bir için "değer" $result etrafında geçti olamaz, ve sadece belirli yerleşik işlevleri ile tespit edilebilir.

Thought experiment two: assignment counter

Ne son if "şey $result için bir atama yaptı?" Sorduğu düşünme başka yolu Aksine özel bir değer olarak dikkate alınarak daha $result, belki "metadata" about değişkeni, Perl "değişken kusur" gibi bir bit olarak düşünebiliriz. Yani ziyade isset Eğer has_been_assigned_to diyoruz, ve oldukça unset, reset_assignment_state daha olabilir.

Ama eğer öyleyse, neden bir mantıksal durdurmak? Ne bilmek istiyorsanız how many times testi geçti; sadece bir tamsayı için meta genişletmek ve var get_assignment_count ve reset_assignment_count ... olabilir

Açıkçası, böyle bir özellik ekleme karmaşıklık ve dil performansında bir trade-off olurdu, bu yüzden dikkatli beklenen faydasına karşı tartılması gerekir. A very_null sabit olduğu gibi, sadece çok dar durumlarda yararlı olacaktır ve yeniden faktoring benzer şekilde dirençli olacaktır.

PHP zamanı motoru oldukça normal bir kodu kullanarak, açıkça bunu yapmak için bırakmak yerine, bu tür şeyleri takip etmek istediğiniz önceden farz niçin umarım-açık bir soru.

isset checks if the variable is set and, if so, whether its value NULL. Ikinci bölümü, bu işlevin kapsamında (bence) değil. Orada bir değişken because it is not set null olup olmadığını belirlemek için hiçbir iyi çözüm olduğundan veya it is explicitly set to NULL.

Burada olası bir çözümdür:

$e1 = error_get_last();
$isNULL = is_null(@$x);
$e2 = error_get_last();
$isNOTSET = $e1 != $e2;
echo sprintf("isNOTSET: %d, isNULL: %d", $isNOTSET, $isNULL);

// Sample output:
// when $x is not set: isNOTSET: 1, isNULL: 1
// when $x = NULL:     isNOTSET: 0, isNULL: 1
// when $x = false:    isNOTSET: 0, isNULL: 0

Diğer çözüm çıkışını araştırmak için get_defined_vars() :

$vars = get_defined_vars();
$isNOTSET = !array_key_exists("x", $vars);
$isNULL = $isNOTSET ? true : is_null($x);
echo sprintf("isNOTSET: %d, isNULL: %d", $isNOTSET, $isNULL);

// Sample output:
// when $x is not set: isNOTSET: 1, isNULL: 1
// when $x = NULL:     isNOTSET: 0, isNULL: 1
// when $x = false:    isNOTSET: 0, isNULL: 0

Bazen belirli bir durumda kullanmak için hangi karşılaştırma işlemi anlamaya çalışıyorum biraz kayıp olsun. isset() sadece başlatılmamış veya açıkça boş değerler için de geçerlidir. Boş atama / Passing beklendiği gibi mantıksal bir karşılaştırma çalışmasını sağlamak için harika bir yoldur.

Yine de, o yüzden burada farklı işlemleri tarafından nasıl değerlendirildiği farklı değerler karşılaştıran basit bir matris düşünmek biraz zor:

|           | ===null | is_null | isset | empty | if/else | ternary | count>0 |
| -----     | -----   | -----   | ----- | ----- | -----   | -----   | -----   |
| $a;       | true    | true    |       | true  |         |         |         |
| null      | true    | true    |       | true  |         |         |         |
| []        |         |         | true  | true  |         |         |         |
| 0         |         |         | true  | true  |         |         | true    |
| ""        |         |         | true  | true  |         |         | true    |
| 1         |         |         | true  |       | true    | true    | true    |
| -1        |         |         | true  |       | true    | true    | true    |
| " "       |         |         | true  |       | true    | true    | true    |
| "str"     |         |         | true  |       | true    | true    | true    |
| [0,1]     |         |         | true  |       | true    | true    | true    |
| new Class |         |         | true  |       | true    | true    | true    |

Tabloyu sığdırmak için ben bir etiket biraz sıkıştırılmış:

  • $a; bildirilmiş ancak başlatılmamış bir değişkenin anlamına gelir
  • everything else in the first column refers to a value being assigned, like:
    • $a = null;
    • $a = [];
    • $a = 0;
    • ...
  • the heading labels refer to comparison operations, like:
    • $a === null
    • isset($a)
    • empty($a)
    • $a ? true : false
    • ...

Tüm sonuçlar true basılır ve false atlanırsa, boolean vardır.

You can run the tests yourself, check this gist:
https://gist.github.com/mfdj/8165967

PHP programlama hayatım, ben isset() null değişken false dönen bir sorunla karşılaştı asla söylemek zorunda. OTOH, ben isset(), bir null dizi girişine başarısız ile karşılaşılan problemler var - ama array_key_exists() bu durumda düzgün çalışır.

Bazı karşılaştırma için, Simge açıkça &null dönen olarak kullanılmayan bir değişken tanımlar böylece aynı zamanda bir unset değişkeni kontrol etmek için Icon olan null testi kullanın. Bu işler kolay yapar. Öte yandan, Visual BASIC (Boş şey, ..., boş) bir değere sahip olmayan bir değişken için birden fazla devlet vardır ve sık sık onları birden fazla kontrol etmek zorunda. Bu hataların kaynağı olduğu bilinmektedir.

Kullanmayı deneyin

unset($v)

Bu ($ v) özellikle unset olduğunda değişken ayarlı değil sadece zaman görünüyor. 'Varoluş' senin anlamı PHP'nin tanımından farklı gibi geliyor. NULL kesinlikle NULL, mevcut olduğunu.

I don't agree with your reasoning about NULL, ve NULL'A hakkında zihniyet değiştirmek gerektiğini söyleyerek sadece garip.

I isset () isset (değişken set edilmiştir ve değişkenin gerçek değeri ile ilgili olması gerektiğini ise) size söylemeliyim, doğru tasarlanmış değildi düşünüyorum.

Bir veritabanından döndürülen değerleri kontrol edilir ve sütunlardan biri bir NULL değeri varsa, yine de değeri NULL olsa bile varsa bilmek istiyorum ... Ne hayır burada () isset güven yok.

aynı şekilde

$a = array ('test' => 1, 'hello' => NULL);

var_dump(isset($a['test']));   // TRUE
var_dump(isset($a['foo']));    // FALSE
var_dump(isset($a['hello']));  // FALSE

isset () bu gibi çalışmak üzere tasarlanmış olmalıdır:

if(isset($var) && $var===NULL){....

değeri NULL olduğu için biz türlerini kontrol ve onun değil orada varsaymak) (isset o kadar bırakmak değil programcı o kadar bırakın bu şekilde - onun sadece aptal tasarım

Ben şu çalıştırın:

echo '<?php echo $foo; ?>' | php

Ben bir hata alıyveyaum:

PHP Notice:  Undefined variable: foo in /home/altern8/- on line 1

Ben şu çalıştırın:

echo '<?php if ( isset($foo) ) { echo $foo; } ?>' | php

Ben hata alamadım.

Ben ayarlanması gereken değişken varsa, genellikle aşağıdaki gibi bir şey yapmak.

$foo = isset($foo) ? $foo : null;

veya

if ( ! isset($foo) ) $foo = null;

That way, later in the script, I can safely use $foo and know that it "is set", and that it defaults to null. Later I can if ( is_null($foo) ) { /* ... */ } if I need to and know fveya certain that the variable exists, even if it is null.

The full isset documentation reads a little mveyae than just what was initially pasted. Yes, it returns false fveya a variable that was previously set but is now null, but it also returns false if a variable has not yet been set (ever) and fveya any variable that has been marked as unset. It also notes that the NULL byte ("\0") is not considered null and will return true.

Değişken ayarlanmış olup olmadığını belirlemek.

If a variable has been unset with unset(), it will no longer be set. isset() will return FALSE if testing a variable that has been set to NULL. Also note that a NULL byte ("\0") is not equivalent to the PHP NULL constant.

I a) var olan bir değişkenin varlığını kontrol etmek için en iyi yöntem olarak boş değil kullanmayı tercih, ve b) boş değildir.

if (!empty($variable)) do_something();