JavaScript isset () eşdeğeri


553

PHP ile yapabilirsiniz if(isset($array['foo'])) { ... }. JavaScript'te genellikle if(array.foo) { ... }aynısını yapmak için kullanırsınız , ancak bu tam olarak aynı ifade değildir. Durum varsa array.foo, var ise de yanlış olarak değerlendirilir, ancak falseveya 0(ve muhtemelen diğer değerler de).

issetJavaScript PHP mükemmel eşdeğer nedir ?

Daha geniş anlamda, JavaScript'in mevcut olmayan değişkenleri, değeri olmayan değişkenleri vb. Ele almasına ilişkin genel ve eksiksiz bir rehber uygun olacaktır.


1
Sorgu derinliği ne olursa olsun bir nesne özelliğinin varlığını test edecek bir işlev yazdım: stackoverflow.com/a/12681101/1268003 Kodumu kullanarak, bu iş parçacığında @CMS tarafından paylaşılan bazı bilgilerle birlikte, kolayca küresel yazabilirsiniz PHP: s isset gibi çok çalışan bir işlev.
Martin Andersson

3
Eğer kullanırsanız Underscore.js deneyin_.isUndefined(arr.foo)
Vitalii Fedorenko

İsteğe bağlı Zincirleme muhtemelen çoğu insanın
arayacağı şeydir

Yanıtlar:


938

Genellikle typeofoperatörü kullanıyorum:

if (typeof obj.foo !== 'undefined') {
  // your code here
}

"undefined"Özellik yoksa veya değeri ise döner undefined.

(Ayrıca bkz: Tanımlanıp tanımlanmama arasındaki fark undefined. )

Bir özelliğin, nesne gibi, hasOwnPropertyyöntem gibi olup olmadığını anlamanın başka yolları da vardır :

if (obj.hasOwnProperty('foo')) {
  // your code here
}

Ve inoperatör:

if ('foo' in obj) {
  // your code here
}

Son ikisi arasındaki fark, hasOwnPropertyyöntemin özelliğin nesne üzerinde fiziksel olarak var olup olmadığını kontrol etmesidir (özellik miras alınmaz).

inOperatör prototip zincirinde, örneğin yukarı Ulaşılamıyor tüm özelliklerine kontrol eder:

var obj = { foo: 'bar'};

obj.hasOwnProperty('foo'); // true
obj.hasOwnProperty('toString'); // false
'toString' in obj; // true

Gördüğünüz gibi , yöntemi kontrol ederken operatör hasOwnPropertydöner falseve indöner , bu yöntem prototip zincirinde tanımlanır, çünkü formu devralır .truetoStringobjObject.prototype


23
Neden kullanmak typeofyerine if( obj.foo !== undefined )?
Matt Ball

7
Ah. Bir gün gerçekten çapraz tarayıcı Javascript bir parça yazacağım. O zamana kadar ...
Matt Ball

37
bununla ilgili sorun, daha derin özellikleri kontrol etmeye çalıştığınızda bir hata almanızdır, örneğin: obj.thisdoesntexist.foo! == undefined. PHP'de derin veya güvenli bir şekilde isset veya boş kullanabilirsiniz.
Enrique

6
IE8, "hasOwnPropery"
içermiyor

12
Tam olarak PHP, isset($abc->def->ghi->jkl)JavaScript typeofoperatörünün aksine, bir istisna oluşturmadan ve komut dosyasını durdurmadan izin verir . Gibi bir şey kullanmalısın try{ abc.def.ghi.jkl; isset=true } catch(e){ isset=false }
Steven Pribilinskiy

43

Eski iş parçacığı, ama eşdeğer çalıştırmak için yeni yollar vardır isset().

ESNext (Aşama 4 Aralık 2019)

İki yeni sözdizimi, isset()işlevsellik kullanımını büyük ölçüde basitleştirmemizi sağlar:

Lütfen dokümanları okuyun ve tarayıcı uyumluluğuna dikkat edin.

Önceki Cevap

Açıklama için aşağıya bakın. Not StandardJS sözdizimini kullanıyorum

Örnek Kullanım

// IMPORTANT pass a function to our isset() that returns the value we're
// trying to test(ES6 arrow function)
isset(() => some) // false

// Defining objects
let some = { nested: { value: 'hello' } }

// More tests that never throw an error
isset(() => some) // true
isset(() => some.nested) // true
isset(() => some.nested.value) // true
isset(() => some.nested.deeper.value) // false

// Less compact but still viable except when trying to use `this` context
isset(function () { return some.nested.deeper.value }) // false

Yanıtlama İşlevi

/**
 * Checks to see if a value is set.
 *
 * @param {Function} accessor Function that returns our value
 */
function isset (accessor) {
  try {
    // Note we're seeing if the returned value of our function is not
    // undefined
    return typeof accessor() !== 'undefined'
  } catch (e) {
    // And we're able to catch the Error it would normally throw for
    // referencing a property of undefined
    return false
  }
}

açıklama

PHP

PHP'de herhangi bir değişkene herhangi bir derinlikte başvurabileceğinizi unutmayın - dizi olarak dizi olmayan bir diziye erişmeye çalışmak bile basit trueveya false:

// Referencing an undeclared variable
isset($some); // false

$some = 'hello';

// Declared but has no depth(not an array)
isset($some); // true
isset($some['nested']); // false

$some = ['nested' => 'hello'];

// Declared as an array but not with the depth we're testing for
isset($some['nested']); // true
isset($some['nested']['deeper']); // false

JS

JavaScript'te, bu özgürlüğe sahip değiliz, aynısını yaparsak her zaman bir hata alırız çünkü JS, işlevimize deeper sarmadan önce değerine hemen erişmeye çalışıyor isset()...

// Common pitfall answer(ES6 arrow function)
const isset = (ref) => typeof ref !== 'undefined'

// Same as above
function isset (ref) { return typeof ref !== 'undefined' }

// Referencing an undeclared variable will throw an error, so no luck here
isset(some) // Error: some is not defined

// Defining a simple object with no properties - so we aren't defining
// the property `nested`
let some = {}

// Simple checking if we have a declared variable
isset(some) // true

// Now trying to see if we have a top level property, still valid
isset(some.nested) // false

// But here is where things fall apart: trying to access a deep property
// of a complex object; it will throw an error
isset(some.nested.deeper) // Error: Cannot read property 'deeper' of undefined
//         ^^^^^^ undefined

Daha başarısız alternatifler:

// Any way we attempt to access the `deeper` property of `nested` will
// throw an error
some.nested.deeper.hasOwnProperty('value') // Error
//   ^^^^^^ undefined

Object.hasOwnProperty('value', some.nested.deeper) // Error
//                                  ^^^^^^ undefined

// Same goes for typeof
typeof some.nested.deeper !== 'undefined' // Error
//          ^^^^^^ undefined

Ve artık hızlı olabilecek bazı çalışma alternatifleri:

// Wrap everything in try...catch
try { isset(some.nested.deeper) } catch (e) {}
try { typeof some.nested.deeper !== 'undefined' } catch (e) {}

// Or by chaining all of the isset which can get long
isset(some) && isset(some.nested) && isset(some.nested.deeper) // false
//                        ^^^^^^ returns false so the next isset() is never run

Sonuç

Diğer cevapların hepsi - çoğu uygulanabilir olsa da ...

  1. Yalnızca değişkenin tanımlanmamış olup olmadığını kontrol ettiğinizi varsayalım.
  2. Yalnızca üst düzey bir mülke erişmeye çalıştığınızı varsayalım.
  3. Sizi PHP'lere göre daha az ideal bir yaklaşım kullanmaya zorlar, isset()
    ör.isset(some, 'nested.deeper.value')
  4. eval()Hangisinin işe yaradığını kullanın ama şahsen kaçınıyorum

Sanırım birçoğunu ele aldım. Cevabımda değindiğim bazı hususlar var, çünkü konuyla ilgili olsalar da sorunun bir parçası değiller. Gerekirse, cevabımı talebe bağlı olarak daha teknik yönlerden bazılarıyla güncelleyebilirim.

Waaay bu kadar çok zaman geçirdim umarım insanlara yardımcı olur.

Okuduğunuz için teşekkürler!


25

SOURCE kaynağına referans

    module.exports = function isset () {
  //  discuss at: http://locutus.io/php/isset/
  // original by: Kevin van Zonneveld (http://kvz.io)
  // improved by: FremyCompany
  // improved by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Rafał Kukawski (http://blog.kukawski.pl)
  //   example 1: isset( undefined, true)
  //   returns 1: false
  //   example 2: isset( 'Kevin van Zonneveld' )
  //   returns 2: true

  var a = arguments
  var l = a.length
  var i = 0
  var undef

  if (l === 0) {
    throw new Error('Empty isset')
  }

  while (i !== l) {
    if (a[i] === undef || a[i] === null) {
      return false
    }
    i++
  }

  return true
}

phpjs.org çoğunlukla locutus lehine emekli oldu İşte yeni bağlantı http://locutus.io/php/var/isset


6
Arandığında, bu bir istisna yükseltecektir isset(abc.def.ghi)eğer durumda abc.deftanımlanmamış. Ancak, bu çözümü bir dize biçiminde değişken adı kabul eden bir çözümle birleştirerek PHP sürümüyle aynı olacaktır.
Steven Pribilinskiy


8
//
//  tring to reference non-existing variable throws ReferenceError 
//  before test function is even executed
//
//  example, if you do:
//    
//     if ( isset( someVar ) ) 
//        doStuff( someVar );
//   
//  you get a ReferenceError ( if there is no someVar... ) 
//  and isset fn doesn't get executed.
//
//  if you pass variable name as string, ex. isset( 'novar' );, 
//  this might work:
//
function isset ( strVariableName ) { 

    try { 
        eval( strVariableName );
    } catch( err ) { 
        if ( err instanceof ReferenceError ) 
           return false;
    }

    return true;

 } 
//
//


6

Diziler ve nesnelerin yanı sıra ilkel değişkenlerdeki hataları önlemek için her zaman bu genel işlevi kullanırım.

isset = function(obj) {
  var i, max_i;
  if(obj === undefined) return false;
  for (i = 1, max_i = arguments.length; i < max_i; i++) {
    if (obj[arguments[i]] === undefined) {
        return false;
    }
    obj = obj[arguments[i]];
  }
  return true;
};

console.log(isset(obj));                   // returns false
var obj = 'huhu';
console.log(isset(obj));                   // returns true
obj = {hallo:{hoi:'hoi'}};
console.log(isset(obj, 'niet'));           // returns false
console.log(isset(obj, 'hallo'));          // returns true
console.log(isset(obj, 'hallo', 'hallo')); // returns false
console.log(isset(obj, 'hallo', 'hoi'));   // returns true

5

Eğer underscorejs kullanıyorsanız her zaman

if (!_.isUndefined(data) && !_.isNull(data)) {
     //your stuff
}

4

Bu, bir değişken olup olmadığını test etmek için oldukça kurşun geçirmez bir çözümdür:

var setOrNot = typeof variable !== typeof undefined ? true : false;

Ne yazık ki, onu bir işlevde kapsülleyemezsiniz.

Böyle bir şey yapmayı düşünebilirsiniz:

function isset(variable) {
    return typeof variable !== typeof undefined ? true : false;
}

Ancak, değişken variabletanımlanmamışsa bu bir başvuru hatası oluşturur , çünkü var olmayan bir değişken boyunca bir işleve geçemezsiniz:

Yakalanmayan ReferenceError: foo tanımlanmamış

Öte yandan, işlev parametrelerinin tanımsız olup olmadığını test etmenize izin verir:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

yİşlev için hiçbir değer iletilmemesine rağmen test, issetişlevimiz bu bağlamda mükemmel çalışır, çünkü yişlevde testbir undefineddeğer olarak bilinir .


Küçük nit: `? true: false` gereksizdir. Sonucu !==zaten bir boolean.
ToolmakerSteve

4
(typeof SOMETHING) !== 'undefined'

Kullanıldığında yazmak çok uzun. Ancak, typeofanahtar sözcüğü bir işleve paketleyemeyiz , çünkü işlev çağrılmadan önce bir hata atılır, şöyle:

function isdef($var) {
    return (typeof $var) !== 'undefined';
}

isdef(SOMETHING); ///// thrown error: SOMETHING is not defined

Bu yüzden bir yol buldum:

function isdef($type) {
    return $type !== 'undefined';
}

isdef(typeof SOMETHING);

Hem bağımsız değişkenlerle (hiç var olmayan değişkenler) hem de nesne özellikleriyle (var olmayan özellikler) çalışabilir. Ve PHP'den sadece 7 karakter daha isset.


Bu benim için çalışıyor, belirli bir json yanıtının olup olmadığını kontrol etmek için kullandı.
Julius

3

Bu çözüm benim için çalıştı.

function isset(object){
    return (typeof object !=='undefined');
}

5
Unset isset(var)ile çağırmak var:ReferenceError: var is not defined
Gui Imamura

3
function isset(variable) {
    try {
        return typeof eval(variable) !== 'undefined';
    } catch (err) {
        return false;
    }
}

4
biraz açıklama ekleyin.
Shree Krishna

Daha önceki birkaç yanıtın belirttiği gibi, daha önce hiç bildirilmemiş bir değişkenle çağrılırsa, bu bir ReferenceError hatası verecektir. Örneğin isset(someVar), someVardaha önce hiç ilan edilmemiş yerler. Ancak bunu yaptığınızda eval, büyük olasılıkla aktarılacak bir dize istiyorsunuz . Kullanımı göster. Kullanım amacınız mı isset('someVar')? Eğer öyleyse, bu önceki cevaba benziyor - cevabınız yeni mi?
ToolmakerSteve


3

Html bloğunun mevcut olup olmadığını kontrol etmek için bu kodu kullanıyorum:

if (typeof($('selector').html()) != 'undefined') {
    // $('selector') is existing
    // your code here
}

2

Nesne yolunu dize olarak sağlayın, daha sonra bu dizeyi bir yola bölebilir ve hasOwnPropertyher yinelemede nesnenin üzerine yazarken her adımda çözebilirsiniz .

ES6 ortamında kodlama yapıyorsanız, bu yığın akışı Ques'e bir göz atın .

var a;

a = {
    b: {
        c: 'e'
    }
};

function isset (obj, path) {
    var stone;

    path = path || '';

    if (path.indexOf('[') !== -1) {
        throw new Error('Unsupported object path notation.');
    }

    
    path = path.split('.');
    
    do {
        if (obj === undefined) {
            return false;
        }

        stone = path.shift();
        
        if (!obj.hasOwnProperty(stone)) {
            return false;
        }
        
        obj = obj[stone];
        
    } while (path.length);

    return true;
}

console.log(
    isset(a, 'b') == true,
    isset(a, 'b.c') == true,
    isset(a, 'b.c.d') == false,
    isset(a, 'b.c.d.e') == false,
    isset(a, 'b.c.d.e.f') == false
);


2

Değişkenleri ve nesneleri kontrol edebilen bir fonksiyon kullanıyorum. jQuery ile çalışmak için çok uygun

    function _isset (variable) {
        if(typeof(variable) == "undefined" || variable == null)
            return false;
        else
            if(typeof(variable) == "object" && !variable.length) 
                return false;
            else
                return true;
    };

Daha önceki birkaç yanıtın belirttiği gibi, daha önce hiç bildirilmemiş bir değişkenle çağrılırsa, bu bir ReferenceError hatası verecektir.
ToolmakerSteve

1

Bir nesnenin daha derin bir özelliğine erişirken benim için gerçekten bir sorundu, bu yüzden eğer varsa özellik değerini döndürecek bir işlev yaptım aksi takdirde yanlış dönecektir. Bunu zaman kazanmak için kullanabilirsiniz,

//Object on which we want to test
var foo = {
    bar: {
        bik: {
            baz: 'Hello world'
        }
    }
};


/*
USE: To get value from the object using it properties supplied (Deeper),
    if found it will return the property value if not found then will return false

You can use this function in two ways
WAY - 1:
Passing an object as parameter 1 and array of the properties as parameter 2
EG: getValueFromObject(foo, ['bar', 'bik', 'baz']);
WAY - 2: (This will work only if, your object available in window object)
Passing an STRING as parameter 1(Just similarly how we retrieve value form object using it's properties - difference is only the quote)
EG: getValueFromObject('foo.bar.bik.baz');
*/
function getValueFromObject(object, properties) {
    if(typeof(object) == 'string') {            //Here we extract our object and it's properties from the string
        properties = object.split('.');
        object = window[properties[0]];
        if(typeof(object) == 'undefined') {
            return false;
        }
        properties.shift();
    }
    var property = properties[0];
    properties.shift();
    if(object != null && typeof(object[property]) != 'undefined') {
        if(typeof(object[property]) == 'object') {
            if(properties.length != 0) {
                return getValueFromObject(object[property], properties);    //Recursive call to the function
            } else {
                return object[property];
            }
        } else {
            return object[property];
        }
    } else {
        return false;
    }
}
console.log(getValueFromObject('fooo.bar.bik.baz'));        //false
console.log(getValueFromObject('foo.bar.bik.baz'));         //Hello world
console.log(getValueFromObject('foo'));                     //false
console.log(getValueFromObject('foo.bar.bik'));             //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik']));       //returns an object { baz: 'Hello World' }
console.log(getValueFromObject(foo, ['bar', 'bik', 'baz']));//Hello world

1

Bir öğenin var olup olmadığını kontrol etmek istiyorsanız, sadece aşağıdaki kodu kullanın:

if (object) {
  //if isset, return true
} else {
  //else return false
}

Bu örnek:

function switchDiv() {
    if (document.querySelector("#divId")) {
        document.querySelector("#divId").remove();
    } else {
        var newDiv = document.createElement("div");
        newDiv.id = "divId";
        document.querySelector("body").appendChild(newDiv);
    }
}

document.querySelector("#btn").addEventListener("click", switchDiv);
#divId {
    background: red;
    height: 100px;
    width: 100px;
    position: relative;
    
}
<body>
  <button id="btn">Let's Diiiv!</button>
</body>


0
if (var) {
  // This is the most concise equivalent of Php's isset().
} 

0

PHP Manual diyor ki:

isset - Bir değişkenin ayarlanıp ayarlanmadığını ve NULL olmadığını belirleme

Ve böyle bir şeyle arayüz kurun:

bool isset ( mixed $var [, mixed $... ] )

Parametre $varkontrol edilecek değişkendir. yine de herhangi bir sayıda parametre olabilir.

isset () TRUE, var varsa ve değeri dışındaysa döndürür NULL. FALSEaksi takdirde.

Bazı örnekler:

$foo = 'bar';
var_dump(isset($foo));        -> true

$baz = null;
var_dump(isset($baz));        -> false

var_dump(isset($undefined));  -> false

Bu akılda olduğu gibi, Görünüşe göre, php isset()işlevinin tam eşdeğerini yazmak mümkün değildir . Örneğin, böyle çağırdığımızda:

if (isset(some_var)) {

}

function issset() {
    // function definition
}

Javascript tetikleyicisi Uncaught ReferenceError: some_var is not defined at (file_name):line_number. Bu davranışla ilgili önemli ve dikkat çekici olan şey, var olmayan değişkenleri normal işlevlere geçirmeye çalışırken bir hatanın tetiklenmesidir.

Ancak PHP'de isset()aslında normal işlevler değil, dil yapıları vardır. Bu, PHP dilinin bir parçası oldukları, normal işlev kurallarına uymadıkları ve var olmayan değişkenler için bir hata tetiklemekten kurtulabilecekleri anlamına gelir. Bu, bir değişkenin var olup olmadığını anlamaya çalışırken önemlidir. Ancak javscript'te, var olmayan değişkenlerle fonksiyon çağrısını söyleyen bir hatayı tetikler.

Demek istediğim, eşit javscript fonksiyonu olarak yazamıyoruz ama böyle bir şey yapabiliriz

if (typeof some_var !== 'undefined') {
   // your code here
}

Tam olarak aynı etkiyi istiyorsanız PHP de değişken olup olmadığını kontrol edin NULL

Örneğin

$baz = null;
var_dump(isset($baz));        -> false

Yani, bunu javascript'e dahil edebiliriz, sonra şöyle görünür:

if (typeof some_var !== 'undefined' && some_var !== null) {
   // your code here
}

0

javascript isset

let test = {
  a: {
    b: [0, 1]
  }
};

console.log(test.isset('a.b'))   // true
console.log(test.isset('a.b.1')) // true
console.log(test.isset('a.b.5')) // false
console.log(test.isset('a.c'))   // false
console.log('abv'.isset('0'))    // true

0

ES6'da dikkatli olun , let değişkeninin bir bildirimini kontrol etmek ve değilse, bildirmek istiyorsanız önceki tüm çözümler çalışmaz

misal

let myTest = 'text';

if(typeof myTest === "undefined") {
    var myTest = 'new text'; // can't be a let because let declare in a scope
}

bir hata göreceksin

Yakalanmamış SyntaxError: 'myTest' tanımlayıcısı zaten bildirildi

Çözüm onu ​​bir değişkenle değiştirmekti.

var myTest = 'text'; // I replace let by a var

if(typeof myTest === "undefined") {
    var myTest = 'new text';
}

Başka bir çözüm bir izin bir var ile değiştirebilir, var kaldırmanız gerekir

let myTest = 'text';

if(typeof myTest === "undefined") {
    myTest = 'new text'; // I remove the var declaration
}

-1
    isset('user.permissions.saveProject', args);

    function isset(string, context) {
        try {
            var arr = string.split('.');
            var checkObj = context || window;

            for (var i in arr) {
                if (checkObj[arr[i]] === undefined) return false;
                checkObj = checkObj[arr[i]];
            }

            return true;
        } catch (e) {
            return false;
        }
    }
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.