ฉันจะทราบได้อย่างไรว่าตัวแปร 'ไม่ได้กำหนด' หรือ '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เป็นความจริงโค้ดข้างต้นจะจับทั้งสองและnullundefined

วิธีมาตรฐานในการจับ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
}

สิ่งนี้ควรใช้ได้กับตัวแปรใด ๆ ที่ไม่ได้ประกาศหรือประกาศและตั้งค่าเป็น null หรือไม่ได้กำหนดไว้อย่างชัดเจน นิพจน์บูลีนควรประเมินค่าเป็นเท็จสำหรับตัวแปรที่ประกาศซึ่งมีค่าที่ไม่ใช่ค่าว่างจริง

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

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

จะประเมินค่าเป็นจริงหากค่าไม่ใช่:

• โมฆะ

• ไม่ได้กำหนด

• น่าน

• สตริงว่าง ("")

• 0

• เท็จ

attr()ฟังก์ชันjQuery ส่งคืนสตริงว่างหรือค่าจริง (และไม่มีnullหรือundefined) ครั้งเดียวที่มันส่งคืนundefinedคือเมื่อตัวเลือกของคุณไม่ได้คืนองค์ประกอบใด ๆ

ดังนั้นคุณอาจต้องการทดสอบกับสตริงว่าง อีกทางหนึ่งเนื่องจากสตริงว่าง, null และไม่ได้กำหนดเป็น 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 ที่เข้ากันได้

ฟังก์ชั่นนี้ควรจะทำอย่างไรว่าสิ่งเดียวกันเช่น PHP ของempty()ฟังก์ชั่น (ดูRETURN VALUES)

พิจารณาundefined, null, false, 0, 0.0, "0" {}, []เป็นที่ว่างเปล่า

"0.0", NaN, " ", trueได้รับการพิจารณาไม่ว่างเปล่า

หากตัวแปรที่คุณต้องการตรวจสอบเป็นโกลบอลให้ทำ

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

วิธีตรวจสอบนี้จะไม่ทำให้เกิดข้อผิดพลาดแม้ว่าyourVarNameจะไม่มีตัวแปร

ตัวอย่าง: ฉันต้องการทราบว่าเบราว์เซอร์ของฉันรองรับ History API หรือไม่

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

มันทำงานอย่างไร:

windowเป็นวัตถุที่เก็บตัวแปรส่วนกลางทั้งหมดเป็นคุณสมบัติของมันและใน JavaScript มันถูกกฎหมายเพื่อพยายามเข้าถึงคุณสมบัติวัตถุที่ไม่มีอยู่ ถ้าhistoryไม่ได้อยู่แล้วผลตอบแทนwindow.history เป็นเท็จดังนั้นรหัสในบล็อกจะไม่ทำงานundefinedundefinedif(undefined){}

สั้นที่สุดและง่ายที่สุด:

if(!EmpName ){
 // DO SOMETHING
}

สิ่งนี้จะประเมินค่าจริงถ้า EmpName คือ:

• โมฆะ
• ไม่ได้กำหนด
• น่าน
• ว่างเปล่า
• สตริง ("")
• 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...

ฉันสามารถตรวจสอบสิ่งต่อไปนี้:

• โมฆะ
• ไม่ได้กำหนด
• น่าน
• ว่างเปล่า
• สตริง ("")
• 0
• เท็จ

เพื่อทดสอบว่าตัวแปรเป็นโมฆะหรือไม่ได้กำหนดฉันใช้โค้ดด้านล่าง

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

ฉันรันการทดสอบนี้ในคอนโซล Chrome การใช้ (void 0) คุณสามารถตรวจสอบ undefined:

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ตรวจสอบควรทำเคล็ดลับและแก้ไขกรณี "undefined หรือ null" ในลักษณะที่สั้นที่สุด (ไม่ได้พิจารณากรณี "foo ไม่ได้ถูกประกาศ") แต่คนที่เคยมี 3 เท่ากับ (เป็นการปฏิบัติที่ดีที่สุด) อาจไม่ยอมรับ เพียงแค่ดูeqeqeqหรือกฎสามเท่าใน eslint และ tslint ...

แนวทางที่ชัดเจนเมื่อเรากำลังตรวจสอบว่าตัวแปรเป็นundefinedหรือnullแยกกันควรนำมาใช้ในกรณีนี้และการมีส่วนร่วมของฉันในหัวข้อ (27 คำตอบที่ไม่เป็นลบตอนนี้!) คือการใช้void 0เป็นวิธีที่สั้นและปลอดภัยในการตรวจสอบ undefinedสำหรับ

การใช้foo === undefinedไม่ปลอดภัยเนื่องจากไม่ได้กำหนดไม่ใช่คำที่สงวนไว้และสามารถเป็นเงา ( MDN ) การใช้การtypeof === 'undefined'ตรวจสอบนั้นปลอดภัย แต่ถ้าเราไม่สนใจกรณีที่ foo-is-undeclared วิธีการต่อไปนี้สามารถใช้ได้:

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 ปฏิบัติที่ดีที่สุด