Як я можу визначити, чи є змінна "undefined" або "null"?

Як визначити, чи є змінною undefinedабо null?

Мій код такий:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Але якщо я це зробити, інтерпретатор JavaScript зупиняє виконання.

Ви можете використовувати якості оператора абстрактної рівності для цього:

if (variable == null){
    // your code here.
}

Оскільки null == undefinedце правда, наведений вище код буде ловити і те, nullі undefined.

Стандартний спосіб лову nullі undefinedодночасно такий:

if (variable == null) {
     // do something 
}

- що на 100% еквівалентно більш явним, але менш стислим:

if (variable === undefined || variable === null) {
     // do something 
}

Коли пишуть професійні JS, це зрозуміло, що рівність типу і поведінка ==vs=== розуміється. Тому ми використовуємо ==і лише порівнюємо їх null.

Відредагуйте ще раз

Зауваження, що пропонують використання typeof, просто неправильні. Так, моє рішення вище спричинить ReferenceError, якщо змінної не існує. Це гарна річ. Цей ReferenceError бажаний: він допоможе вам знайти свої помилки та виправити їх перед тим, як надсилати код, як і помилки компілятора в інших мовах. Використовуйте try/ catchякщо ви працюєте з введенням, ви не маєте контролю над.

У вашому коді не повинно бути посилань на незадекларовані змінні.

Поєднуючи вищезазначені відповіді, видається, що найповнішою відповіддю буде:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Це має працювати для будь-якої змінної, яка або незадекларована, або оголошена, і явно встановлена ​​на нуль або невизначена. Булевий вираз має оцінюватися як хибний для будь-якої оголошеної змінної, яка має фактичне ненульове значення.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

оцінюється як вірно, якщо значення не:

• нуль

• невизначений

• NaN

• порожній рядок ("")

• 0

• помилковий

attr()Функція jQuery повертає або порожній рядок, або фактичне значення (і ніколи nullабо undefined). Єдиний раз, коли він повертаєтьсяundefined це коли ваш селектор не повернув жодного елемента.

Тому ви можете перевірити чистий рядок. Крім того, оскільки порожні рядки, null та undefined є false-y, ви можете просто зробити це:

if (!EmpName) { //do something }

Я прийшов написати свою функцію для цього. JavaScript дивний.

Він використовується практично на будь-якому місці. (Зверніть увагу, що це також перевіряє, чи змінна містить якісь корисні значення . Але оскільки ця інформація зазвичай також потрібна, я думаю, що її варто опублікувати). Просимо залишити записку.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Сумісний з TypeScript

Ця функція повинна виконувати точно так само, як і empty()функцію PHP (дивRETURN VALUES )

Вважає undefined, null, false, 0, 0.0, "0" {}, []як порожні.

"0.0", NaN, " ", trueВважаються не порожньо.

Якщо змінна, яку ви хочете перевірити, є глобальною, зробіть це

if (window.yourVarName) {
    // Your code here
}

Цей спосіб перевірки не призведе до помилки, навіть якщо yourVarNameзмінна не існує.

Приклад: я хочу знати, чи підтримує мій браузер API History

if (window.history) {
    history.back();
}

Як це працює:

windowце об'єкт, який містить усі властивості глобальних змінних як свої властивості, а в JavaScript законно намагатися отримати доступ до неіснуючої властивості об'єкта. Якщо historyйого немає, то window.historyповертається undefined. undefinedє фальсі, тому код у if(undefined){}блоці не запускається.

Найкоротший і найпростіший:

if(!EmpName ){
 // DO SOMETHING
}

це оцінить істину, якщо EmpName:

• нуль
• невизначений
• NaN
• порожній
• string ("")
• 0
• помилковий

Напевно, найкоротший спосіб це зробити:

if(EmpName == null) { /* DO SOMETHING */ };

Ось доказ:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

А тут докладніше про ==(джерело тут )

БОНУС : причина, чому ===більш зрозуміла, ніж ==(дивіться на відповідь agc )

У мене щойно була ця проблема, тобто перевірка, чи об’єкт недійсний.
Я просто використовую це:

if (object) {
    // Your code
}

Наприклад:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Оскільки ви використовуєте jQuery , ви можете визначити, чи є змінна невизначена чи її значення недійсне за допомогою однієї функції.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

Елемент перевірки jQuery не має нуля:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

У JavaScript, наскільки мені відомо, ми можемо перевірити невизначену, нульову чи порожню змінну, як показано нижче.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Перевірте всі умови:

if(variable === undefined || variable === null || variable === ''){
}

Ви можете просто скористатись наступним (я знаю, що це коротші способи зробити це, але це може полегшити візуальне спостереження, принаймні для інших, хто дивиться на код).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

Найпростіший спосіб перевірити:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

З рішенням нижче:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Я можу перевірити наступне:

• нуль
• невизначений
• NaN
• порожній
• string ("")
• 0
• помилковий

Щоб перевірити, чи є змінна нульовою чи невизначеною, я використовую наведений нижче код.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Я запускаю цей тест у консолі Chrome. Використовуючи (void 0), ви можете перевірити невизначений:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Подивимось на це,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   У вищесказаному змінна оголошується лише як apple. У цьому випадку, якщо ми викликаємо метод, alertвін відображатиметься невизначеним.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

У другому він відображає нуль, тому що змінна apple значення є нульовою.

Таким чином, ви можете перевірити, чи значення не визначене чи недійсне.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Кращий спосіб:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Тому що === перевіряє і тип, і значення. Тип обох різний, але значення однакове.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

foo == nullЧек повинен зробити трюк і вирішити «невизначений або нульовий» випадок в найкоротшому. (Не враховуючи випадку "foo не оголошено".) Але люди, які звикли мати 3 рівні (як найкраща практика), можуть не прийняти це. Просто подивіться на eqeqeq або потрійні рівні правила в eslint та tslint ...

У цьому випадку слід застосовувати явний підхід, коли ми перевіряємо, чи є змінна undefinedчи nullокремо, і мій внесок у тему (27 негативних відповідей на даний момент!) Полягає у використанні void 0як короткого, так і безпечного способу перевірки. для undefined.

Використання foo === undefinedне є безпечним, оскільки невизначене не є зарезервованим словом і може бути затіненим ( MDN ). Використання typeof === 'undefined'перевірки є безпечним, але якщо ми не будемо піклуватися про нерозголошений варіант foo-is-notcreen, можна використовувати наступний підхід:

if (foo === void 0 || foo === null) { ... }

якщо ви створили функцію для перевірки:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Виклик typeof null повертає значення "object", оскільки спеціальне значення null вважається порожнім посиланням на об'єкт. У Safari через версію 5 та Chrome на версію 7 є примірник, коли виклик typeof у регулярному виразі повертає "функцію", а всі інші браузери повертають "об'єкт".

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

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

Я все ще думаю, що найкращий / безпечний спосіб перевірити ці дві умови - це передати значення рядку:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Ви можете перевірити, чи значення не визначене або недійсне, просто використовуючи typeof:

if(typeof value == 'undefined'){

if(x==null)погана ідея в JavaScript. Судіть із "=="- це може спричинити несподіваний примус типу, і він не може читати CoffeeScript, ніколи не використовуйте "==" або "! =" За умови судження!

if(x)буде краще, але будьте обережні з 0 і "" . Це буде розглядатися як помилковий , а не рівні метод з "!= null"це вірно .

Див. Найкращі практики JavaScript .