Equivalente JavaScript isset ()

In PHP puoi fare if(isset($array['foo'])) { ... } . In JavaScript si usa spesso if(array.foo) { ... } fa lo stesso, ma questa non è esattamente la stessa affermazione. La condizione valuterà anche false se array.foo esiste ma è false o 0 (e probabilmente anche altri valori).

Qual è l’equivalente perfetto dell’emissione di PHP in JavaScript?

In un senso più ampio, una guida generale e completa sulla gestione di JavaScript di variabili che non esistono, variabili prive di valore, ecc. Sarebbe conveniente.

Generalmente uso l’operatore typeof :

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

Restituirà "undefined" se la proprietà non esiste o se il suo valore undefined è undefined .

(Vedi anche: Differenza tra undefined e non definito. )

Esistono altri modi per capire se esiste una proprietà su un object, come il metodo hasOwnProperty :

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

E l’operatore in:

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

La differenza tra gli ultimi due è che il metodo hasOwnProperty controllerà se la proprietà esiste fisicamente sull’object (la proprietà non è ereditata).

L’operatore in controllerà tutte le proprietà raggiungibili nella catena del prototipo, ad esempio:

 var obj = { foo: 'bar'}; obj.hasOwnProperty('foo'); // true obj.hasOwnProperty('toString'); // false 'toString' in obj; // true 

Come si può vedere, hasOwnProperty restituisce false e l’operatore in restituisce true quando si controlla il metodo toString , questo metodo è definito nella catena del prototipo, poiché obj eredita form Object.prototype .

Riferimento a SOURCE

  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 è in gran parte ritirato a favore di locutus Ecco il nuovo link http://locutus.io/php/var/isset

 if (!('foo' in obj)) { // not set. } 

Thread vecchio, ma ecco un nuovo modo di eseguire un equivalente isset() .

Risposta

Vedi sotto per la spiegazione. Nota Io uso la syntax StandardJS

Esempio di utilizzo

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

Risposta Funzione

 /** * 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 } } 

Spiegazione

PHP

Nota che in PHP puoi fare riferimento a qualsiasi variabile a qualsiasi livello di profondità – anche provando ad accedere a un non-array come un array restituirà un semplice true o 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

In JavaScript, non abbiamo quella libertà, avremo sempre un errore se facciamo lo stesso perché JS sta tentando immediatamente di accedere al valore di deeper prima di poterlo includere nella nostra funzione isset() così …

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

Alternative più fallimentari:

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

E alcune alternative di lavoro che possono essere ridondate velocemente:

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

Conclusione

Tutte le altre risposte – anche se la maggior parte sono fattibili …

  1. Supponiamo che tu stia verificando solo se la variabile non è indefinita, il che va bene per alcuni casi d’uso, ma può ancora generare un errore
  2. Supponiamo che tu stia solo tentando di accedere a una proprietà di primo livello, che di nuovo va bene per alcuni casi d’uso
  3. Costringi a utilizzare un approccio isset() che ideale rispetto a isset() di PHP isset()
    ad esempio isset(some, 'nested.deeper.value')
  4. Usa eval() che funziona ma io personalmente evito

Penso di averne parlato molto. Nella mia risposta ci sono alcuni punti che non tocchi perché, sebbene rilevanti, non fanno parte della domanda. Se necessario, però, posso aggiornare la mia risposta con collegamenti ad alcuni degli aspetti più tecnici basati sulla domanda.

Ho dedicato molto tempo a questo, quindi spero che aiuti le persone.

Grazie per aver letto!

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

Questa semplice soluzione funziona, ma non per il controllo degli oggetti profondi.

 function isset(str) { return window[str] !== undefined; } 

Uso sempre questa funzione generica per evitare errori su variabili primitive, nonché matrici e oggetti.

 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 

Se usi underscorejs, io lo uso sempre

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

Questa soluzione ha funzionato per me.

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

Questa è una soluzione piuttosto a prova di proiettile per testare se esiste una variabile:

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

Sfortunatamente, non puoi semplicemente incapsularlo in una funzione.

Potresti pensare di fare qualcosa del genere:

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

Tuttavia, questo produrrà un errore di riferimento se la variabile variable non è stata definita, perché non è ansible passare una variabile non esistente a una funzione:

Uncaught ReferenceError: foo non è definito

D’altra parte, ti permette di verificare se i parametri di funzione non sono definiti:

 var a = '5'; var test = function(x, y) { console.log(isset(x)); console.log(isset(y)); }; test(a); // OUTPUT : // ------------ // TRUE // FALSE 

Anche se nessun valore per y viene passato al test funzioni, la nostra funzione isset funziona perfettamente in questo contesto, poiché y è conosciuto come test funzione come valore undefined .

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

Fornire il percorso dell’object come stringa, quindi è ansible suddividere questa stringa in un percorso e risolvere hasOwnProperty ad ogni passaggio mentre si sovrascrive l’object stesso con ogni iterazione.

Se si sta codificando in ambiente ES6, dare un’occhiata a questo Stackoverflow Ques .

 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, 'bcd') == false, isset(a, 'bcde') == false, isset(a, 'bcdef') == false ); 
 window.isset = function(v_var) { if(typeof(v_var) == 'number'){ if(isNaN(v_var)){ return false; }} if(typeof(v_var) == 'undefined' || v_var === null){ return false; } else { return true; } }; 

più test:

https://gist.github.com/daylik/24acc318b6abdcdd63b46607513ae073

Per verificare se il blocco html è esistente o meno, sto usando questo codice:

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

È troppo lungo per scrivere quando usato. Ma non possiamo impacchettare la parola chiave typeof in una funzione, perché verrà generato un errore prima che venga chiamata la funzione, in questo modo:

 function isdef($var) { return (typeof $var) !== 'undefined'; } isdef(SOMETHING); ///// thrown error: SOMETHING is not defined 

Così ho capito un modo:

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

Può funzionare sia con variabili individuali (variabili che non esistono affatto), sia con proprietà dell’object (proprietà inesistenti). E solo 7 caratteri in più rispetto a PHP isset .

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

Manuale PHP:

isset – Determina se una variabile è impostata e non è NULL

E interfaccia qualcosa come questo:

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

Il parametro $var è la variabile da verificare. tuttavia può avere un numero qualsiasi di parametri.

isset () restituisce TRUE se var esiste e ha valore diverso da NULL . FALSE altrimenti.

Qualche esempio:

 $foo = 'bar'; var_dump(isset($foo)); -> true $baz = null; var_dump(isset($baz)); -> false var_dump(isset($undefined)); -> false 

Tenendo presente questo, apparentemente, non è ansible scrivere un equivalente esatto della funzione php isset() . Ad esempio quando chiamiamo così:

 if (isset(some_var)) { } function issset() { // function definition } 

Trigger JavaScript Uncaught ReferenceError: some_var is not defined at (file_name):line_number . La cosa importante e notevole di questo comportamento è che quando si tenta di passare variabili inesistenti alle normali funzioni, viene generato un errore.

Ma in PHP isset() non sono in realtà funzioni regolari ma costrutti linguistici. Ciò significa che fanno parte del linguaggio PHP stesso, non giocano secondo le normali regole delle funzioni e possono quindi farla franca non triggersndo un errore per variabili inesistenti. Questo è importante quando si cerca di capire se esiste una variabile o meno. Ma in javscript, si innesca un errore, in primo luogo dire chiamata di funzione con variabili inesistenti.

Il mio punto è che non possiamo scriverlo come funzione javscript equivlente, ma possiamo fare qualcosa di simile

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

Se vuoi lo stesso effetto PHP controlla anche varable non è NULL

Per esempio

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

Quindi, possiamo incorporare questo in javascript, quindi assomiglia a questo:

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