วิธีใดในการตรวจสอบว่าตัวแปรถูกเริ่มต้นดีกว่า / ถูกต้อง (สมมติว่าตัวแปรสามารถเก็บอะไรได้ (สตริง, int, วัตถุ, ฟังก์ชั่น ฯลฯ ))

if (elem) { // or !elem

หรือ

if (typeof(elem) !== 'undefined') {

หรือ

if (elem != null) {

คุณต้องการผู้ประกอบการ โดยเฉพาะ:typeof

if (typeof variable !== 'undefined') {
    // the variable is defined
}

typeofผู้ประกอบการจะตรวจสอบว่าตัวแปรจะไม่ได้กำหนดจริงๆ

if (typeof variable === 'undefined') {
    // variable is undefined
}

typeofผู้ประกอบการซึ่งแตกต่างจากผู้ประกอบการอื่น ๆ ที่ไม่ได้โยนReferenceErrorยกเว้นเมื่อใช้กับตัวแปรที่ไม่ได้ประกาศ

แต่ไม่ทราบว่าจะกลับมาtypeof null เราจะต้องระมัดระวังเพื่อหลีกเลี่ยงความผิดพลาดของการเริ่มต้นตัวแปรไป"object" nullเพื่อความปลอดภัยนี่คือสิ่งที่เราสามารถใช้แทน:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้การเปรียบเทียบที่เข้มงวด===แทนที่จะใช้ความเท่าเทียมอย่างง่าย==โปรดดู:
ควรใช้ตัวดำเนินการใด (== vs ===) ในการเปรียบเทียบ JavaScript

ในหลายกรณีการใช้:

if (elem) { // or !elem

จะทำงานให้คุณ! ... สิ่งนี้จะตรวจสอบกรณีเหล่านี้ด้านล่าง:

1. ไม่ได้กำหนด : หากค่าไม่ได้ถูกกำหนดและเป็นundefined
2. null : ถ้าเป็นโมฆะตัวอย่างเช่นถ้าไม่มีองค์ประกอบ DOM ...
3. สตริงว่าง :''
4. 0 : หมายเลขศูนย์
5. NaN : ไม่ใช่ตัวเลข
6. เท็จ

ดังนั้นมันจะครอบคลุมทุกกรณี แต่มีกรณีแปลก ๆ อยู่เสมอที่เราต้องการครอบคลุมเช่นสตริงที่มีช่องว่างเช่น' 'นี้จะถูกกำหนดใน javascript เนื่องจากมีช่องว่างภายในสตริง ... ตัวอย่างเช่นในกรณีนี้คุณเพิ่มการตรวจสอบอีกหนึ่งรายการโดยใช้ trim () เช่น:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

นอกจากนี้การตรวจสอบเหล่านี้ใช้สำหรับค่าเท่านั้นเนื่องจากวัตถุและอาร์เรย์ทำงานแตกต่างกันใน Javascript อาร์เรย์[]ว่างและวัตถุว่างเปล่า{}เป็นจริงเสมอจริง

ฉันสร้างภาพด้านล่างเพื่อแสดงคำตอบสั้น ๆ :

ใน JavaScript สามารถกำหนดตัวแปรได้ แต่เก็บค่าundefinedไว้ดังนั้นคำตอบที่พบบ่อยที่สุดนั้นไม่ถูกต้องทางเทคนิคและดำเนินการดังนี้:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

นั่นอาจเพียงพอสำหรับวัตถุประสงค์ของคุณ การทดสอบต่อไปนี้มีความหมายที่ง่ายกว่าซึ่งช่วยให้อธิบายพฤติกรรมของรหัสของคุณได้ง่ายขึ้นและเข้าใจด้วยตัวคุณเอง (หากคุณสนใจสิ่งต่าง ๆ ):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

แน่นอนว่าสิ่งนี้ถือว่าคุณกำลังทำงานในเบราว์เซอร์ (ซึ่งwindowเป็นชื่อสำหรับออบเจกต์ร่วม) แต่ถ้าคุณล้อเล่นรอบตัวแบบนี้คุณอาจอยู่ในเบราว์เซอร์ อัตนัยการใช้'name' in windowมีความสอดคล้องกับการใช้window.nameเพื่ออ้างถึง globals โวหาร การเข้าถึง globals เป็นคุณสมบัติของwindowแทนที่จะเป็นตัวแปรช่วยให้คุณลดจำนวนของตัวแปรที่ไม่ได้ประกาศซึ่งคุณอ้างอิงในโค้ดของคุณ (เพื่อประโยชน์ในการขุย) และหลีกเลี่ยงความเป็นไปได้ที่โลกของคุณจะถูกเงาโดยตัวแปรท้องถิ่น นอกจากนี้หากกลมกลืนทำให้ผิวของคุณคลานคุณอาจรู้สึกสะดวกสบายกว่าเมื่อสัมผัสกับแท่งที่ค่อนข้างยาว

ในกรณีส่วนใหญ่คุณจะใช้:

elem != null

ซึ่งแตกต่างจากที่เรียบง่ายif (elem)จะช่วยให้0, false, NaNและ''แต่ปฏิเสธnullหรือundefinedทำให้มันเป็นที่ดีการทดสอบทั่วไปสำหรับการปรากฏตัวของการโต้แย้งหรือคุณสมบัติของวัตถุ

การตรวจสอบอื่น ๆ ไม่ถูกต้องเช่นกันพวกเขามีการใช้ที่แตกต่างกัน:

• if (elem): สามารถนำมาใช้ในกรณีที่elemมีการประกันเพื่อเป็นวัตถุหรือถ้าfalse, 0ฯลฯ ได้รับการพิจารณาค่า "เริ่มต้น" (จึงเทียบเท่ากับundefinedหรือnull)

• typeof elem == 'undefined'สามารถใช้ในกรณีที่มีการระบุnullมีความหมายที่แตกต่างกับตัวแปรหรือคุณสมบัติเริ่มต้น

  • นี่เป็นการตรวจสอบเพียงอย่างเดียวที่จะไม่เกิดข้อผิดพลาดหากelemไม่ได้รับการประกาศ (เช่นไม่มีvarคำสั่งไม่ใช่คุณสมบัติของwindowหรือไม่ใช่อาร์กิวเมนต์ของฟังก์ชัน) ในความคิดของฉันมันค่อนข้างอันตรายเพราะมันช่วยให้พิมพ์ผิดพลาดโดยไม่มีใครสังเกต เพื่อหลีกเลี่ยงปัญหานี้ให้ดูวิธีการด้านล่าง

ยังมีประโยชน์คือการเปรียบเทียบที่เข้มงวดกับundefined:

if (elem === undefined) ...

อย่างไรก็ตามเนื่องจากโกลบอลundefinedสามารถถูกแทนที่ด้วยค่าอื่นได้ดีที่สุดคือการประกาศตัวแปรundefinedในขอบเขตปัจจุบันก่อนที่จะใช้:

var undefined; // really undefined
if (elem === undefined) ...

หรือ:

(function (undefined) {
    if (elem === undefined) ...
})();

ข้อได้เปรียบที่สองของวิธีนี้คือundefinedตัวย่อJS สามารถลดตัวแปรให้เป็นอักขระเดียวช่วยให้คุณประหยัดได้ไม่กี่ไบต์ทุกครั้ง

windowตรวจสอบว่า hasOwnProperty( " varname" )

อีกทางเลือกหนึ่งของtypeofคำตอบมากมาย

ตัวแปรโกลบอลที่ประกาศพร้อมvar varname = value;คำสั่งในขอบเขตโกลบอล

สามารถเข้าถึงได้เป็นคุณสมบัติของวัตถุหน้าต่าง

เช่นhasOwnProperty()วิธีการซึ่ง

ส่งคืนบูลีนที่ระบุว่าวัตถุนั้นมีคุณสมบัติที่ระบุเป็นคุณสมบัติของตัวเองหรือไม่ (ซึ่งต่างจากการสืบทอด)

สามารถใช้เพื่อตรวจสอบว่า

varของ"varName"ได้รับการประกาศทั่วโลกเช่นwindowเป็นทรัพย์สินของที่

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

มีอะไรที่ยอดเยี่ยมเกี่ยวกับ hasOwnProperty()เรียกมันว่าเราไม่ได้ใช้ตัวแปรที่อาจยังไม่ได้ประกาศซึ่งแน่นอนว่าครึ่งหนึ่งของปัญหาในตอนแรก

แม้ว่าจะไม่ได้เสมอที่สมบูรณ์แบบหรือเหมาะแก้ปัญหาในบางสถานการณ์ก็แค่งาน!

หมายเหตุ

ด้านบนเป็นจริงเมื่อใช้varเพื่อกำหนดตัวแปรซึ่งตรงข้ามกับletที่:

ประกาศตัวแปรโลคัลขอบเขตบล็อกให้เลือกที่จะกำหนดค่าเป็นค่าเริ่มต้น

ไม่เหมือน varคำหลักซึ่งกำหนดตัวแปรทั่วโลกหรือภายในฟังก์ชันทั้งหมดโดยไม่คำนึงถึงขอบเขตบล็อก

ที่ระดับบนสุดของโปรแกรมและฟังก์ชั่นซึ่งletแตกต่างจากการvarสร้างคุณสมบัติบนวัตถุทั่วโลก

เพื่อความสมบูรณ์: constค่าคงที่คือโดยความหมายไม่ใช่ตัวแปรจริง (แม้ว่าเนื้อหาสามารถเป็นได้); มีความเกี่ยวข้องมากขึ้น:

ค่าคงที่ส่วนกลางไม่กลายเป็นคุณสมบัติของวัตถุหน้าต่างซึ่งแตกต่างจากvarตัวแปร ต้องมี initializer สำหรับค่าคงที่ นั่นคือคุณต้องระบุค่าในคำสั่งเดียวกับที่มีการประกาศ

ค่าของค่าคงที่ไม่สามารถเปลี่ยนแปลงได้ผ่านการกำหนดใหม่และไม่สามารถประกาศใหม่ได้

การประกาศ const สร้างการอ้างอิงแบบอ่านอย่างเดียวกับค่า ไม่ได้หมายความว่าค่าที่เก็บไว้นั้นไม่เปลี่ยนรูปเพียง แต่ตัวระบุตัวแปรไม่สามารถกำหนดใหม่ได้

เนื่องจากletตัวแปรหรือconstค่าคงที่ไม่เคยมีคุณสมบัติของวัตถุใด ๆ ที่มีการสืบทอดhasOwnProperty()วิธีการจึงไม่สามารถใช้เพื่อตรวจสอบการมีอยู่ของพวกเขา

เกี่ยวกับความพร้อมใช้งานและการใช้hasOwnProperty():

วัตถุทุกชนิดที่สืบทอดมาจากวัตถุสืบทอดhasOwnProperty()วิธีการ [... ] ไม่เหมือนกับตัวinดำเนินการวิธีนี้ไม่ได้ตรวจสอบโซ่ต้นแบบของวัตถุ

วิธีตรวจสอบว่ามีตัวแปรอยู่หรือไม่

นี่เป็นวิธีแก้ปัญหากระสุนที่ไม่ดีสำหรับการทดสอบว่ามีตัวแปรอยู่หรือไม่และได้รับการเริ่มต้น:

var setOrNot = typeof variable !== typeof undefined;

มันถูกใช้มากที่สุดร่วมกับผู้ประกอบการที่ประกอบไปด้วยกันเพื่อตั้งค่าเริ่มต้นในกรณีที่ตัวแปรบางอย่างยังไม่ได้เริ่มต้น:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

มีปัญหากับการห่อหุ้ม

น่าเสียดายที่คุณไม่สามารถแค็ปซูลเช็คของคุณในฟังก์ชั่น

คุณอาจคิดถึงการทำสิ่งนี้:

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

อย่างไรก็ตามสิ่งนี้จะทำให้เกิดข้อผิดพลาดในการอ้างอิงหากคุณโทรเช่น isset(foo)และตัวแปรfooไม่ได้ถูกกำหนดเนื่องจากคุณไม่สามารถผ่านตัวแปรที่ไม่มีอยู่ไปยังฟังก์ชันได้:

Uncaught ReferenceError: foo ไม่ได้ถูกกำหนดไว้

การทดสอบว่าพารามิเตอร์ฟังก์ชั่นจะไม่ได้กำหนด

ในขณะที่issetฟังก์ชั่นของเราไม่สามารถใช้ในการทดสอบว่ามีตัวแปรอยู่หรือไม่ (ด้วยเหตุผลที่อธิบายไว้ข้างต้น) แต่จะช่วยให้เราสามารถทดสอบว่าพารามิเตอร์ของฟังก์ชันนั้นไม่ได้ถูกกำหนดหรือไม่:

var a = '5';

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

test(a);

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

แม้ว่าจะไม่มีค่าสำหรับการyส่งผ่านไปยังฟังก์ชันtestแต่ฟังก์ชันของเราissetทำงานได้อย่างสมบูรณ์ในบริบทนี้เพราะyเป็นที่รู้จักกันในฟังก์ชั่นtestเป็นundefinedค่า

มีวิธีสั้น ๆ อีกวิธีหนึ่งในการตรวจสอบเรื่องนี้เมื่อคุณทำการมอบหมายอย่างง่ายและการตรวจสอบที่เกี่ยวข้อง เพียงใช้โอเปอเรเตอร์ (Ternary) แบบมีเงื่อนไข

var values = typeof variable !== 'undefined' ? variable : '';

สิ่งนี้จะเป็นประโยชน์เมื่อคุณพยายามประกาศตัวแปร Global พร้อมการกำหนดอินสแตนซ์ของตัวแปรอ้างอิง

หากคุณต้องการที่จะตรวจสอบตัวแปรไม่ควรจะเป็นหรือundefined nullจากนั้นดำเนินการตรวจสอบด้านล่าง

เมื่อมีการประกาศตัวแปรและหากคุณต้องการตรวจสอบค่านี่จะเป็นแบบง่าย ๆ : และมันจะทำงานundefinedและnullตรวจสอบร่วมกัน

var values = variable ? variable : '';

วิธีสั้น ๆ ในการทดสอบตัวแปรไม่ได้ถูกประกาศ (ไม่ได้ไม่ได้กำหนด) คือ

if (typeof variable === "undefined") {
  ...
}

ฉันพบว่ามีประโยชน์สำหรับการตรวจจับสคริปต์ที่ทำงานนอกเบราว์เซอร์ (ไม่มีwindowตัวแปรที่ประกาศไว้)

มันขึ้นอยู่กับว่าคุณแค่สนใจว่าตัวแปรนั้นถูกกำหนดหรือถ้าคุณต้องการให้มันมีค่าที่มีความหมาย

การตรวจสอบว่าประเภทไม่ได้กำหนดจะตรวจสอบว่าตัวแปรได้รับการกำหนดหรือยัง

=== nullหรือ!== nullจะตรวจสอบว่าค่าของตัวแปรนั้นถูกต้องnullหรือไม่

== nullหรือ!= nullจะตรวจสอบว่ามีค่าเป็นหรือundefinednull

if(value)จะตรวจสอบว่าตัวแปรที่undefined, null, 0หรือสตริงที่ว่างเปล่า

คำตอบที่ถูกต้องที่สุดให้ใช้ typeof

อย่างไรก็ตามสิ่งที่ฉันต้องการชี้ให้เห็นคือใน JavaScript undefinedไม่แน่นอน (ด้วยเหตุผลบางอย่างที่ไม่ดี) ดังนั้นเพียงแค่ทำการตรวจสอบvarName !== undefinedมีความเป็นไปได้ที่จะไม่กลับมาตามที่คุณคาดหวังไว้เพราะ libs อื่นอาจมีการเปลี่ยนแปลงที่ไม่ได้กำหนด บางคำตอบ (@ หนึ่งของ skalee) ดูเหมือนจะไม่ต้องการใช้typeofและนั่นอาจทำให้เกิดปัญหา

วิธีที่ "เก่า" ในการจัดการนี้ได้รับการประกาศกำหนดเป็น var เพื่อชดเชยใด ๆ ที่มีศักยภาพการปิด / undefinedมากกว่าขี่ของ อย่างไรก็ตามวิธีที่ดีที่สุดยังคงใช้typeofเพราะจะไม่สนใจการแทนที่ของundefinedรหัสอื่น ๆ โดยเฉพาะอย่างยิ่งถ้าคุณกำลังเขียนโค้ดเพื่อใช้ในแบบไวด์สกรีนซึ่งใครจะรู้ว่ามีอะไรอีกที่สามารถทำงานบนหน้า ...

if (typeof console != "undefined") {    
   ...
}

หรือดีกว่า

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

ใช้งานได้ในเบราว์เซอร์ทั้งหมด

เพื่อสนับสนุนการถกเถียงถ้าฉันรู้ว่าตัวแปรควรเป็นสตริงหรือวัตถุที่ฉันชอบอยู่ตลอดเวลาif (!variable)ดังนั้นให้ตรวจสอบว่ามันผิดพลาดหรือไม่ สิ่งนี้สามารถทำให้โค้ดสะอาดยิ่งขึ้นตัวอย่างเช่น:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

.. สามารถลดเป็น:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

เป็นการยากที่จะแยกแยะระหว่าง undefined และ null Nullเป็นค่าที่คุณสามารถกำหนดให้กับตัวแปรได้เมื่อคุณต้องการระบุว่าตัวแปรนั้นไม่มีค่าใดเป็นพิเศษ ไม่ได้กำหนด เป็นค่าพิเศษซึ่งจะเป็นค่าเริ่มต้นของตัวแปรที่ไม่ได้กำหนด

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null เป็นค่าใน JavaScript และtypeof nullส่งคืน"object"

ดังนั้นคำตอบที่ได้รับการยอมรับจะไม่ทำงานหากคุณผ่านค่า Null หากคุณผ่านค่า Null คุณต้องเพิ่มการตรวจสอบพิเศษสำหรับค่า Null:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

ส่วนใหญ่ที่แข็งแกร่ง 'มันคือกำหนด' เช็คอินคือมีtypeof

if (typeof elem === 'undefined')

หากคุณเพียงแค่ตรวจสอบตัวแปรที่กำหนดไว้เพื่อกำหนดค่าเริ่มต้นเพื่อให้ง่ายต่อการอ่านหนึ่งซับที่คุณสามารถทำได้:

elem = elem || defaultElem;

บ่อยครั้งที่ใช้งานได้ดีโปรดดู: วิธีการตั้งค่าเริ่มต้นในจาวาสคริปต์

นอกจากนี้ยังมีซับในนี้ใช้คำหลักtypeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

คุณสามารถใช้ typeofโอเปอเรเตอร์ได้

ตัวอย่างเช่น,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

ข้อมูลโค้ดด้านบนจะส่งคืนผลลัพธ์เช่น

ชุดข้อมูลตัวแปรคือ: ไม่ได้กำหนด

เพื่อตรวจสอบว่ามีการประกาศตัวแปร / ชุดฉันได้ทำเล่ห์เหลี่ยมสกปรก

evalผมยังไม่ได้พบวิธีที่จะดึงรหัสเพื่อฟังก์ชั่นที่แม้จะมี

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

คำตอบเหล่านี้ (นอกเหนือจากโซลูชัน Fred Gandt) นั้นไม่ถูกต้องหรือไม่สมบูรณ์

สมมติว่าฉันต้องการvariableName;ให้มีundefinedค่าและดังนั้นจึงได้รับการประกาศในลักษณะเช่นvar variableName;ซึ่งหมายความว่ามันเริ่มต้นแล้ว; - ฉันจะตรวจสอบว่ามันประกาศแล้ว?

หรือดียิ่งขึ้น - ฉันจะตรวจสอบทันทีว่า "Book1.chapter22.paragraph37" มีอยู่ด้วยการโทรครั้งเดียว แต่ไม่เกิดข้อผิดพลาดในการอ้างอิงหรือไม่

เราทำได้โดยใช้ตัวดำเนินการ JasvaScript ที่ทรงพลังที่สุดตัวดำเนินการin :

"[variable||property]" in [context||root] 
>> true||false

ในช่วงเวลาของความนิยมสูงสุดของ AJAX ฉันได้เขียนวิธีการ (ชื่อภายหลัง) isNS () ซึ่งสามารถพิจารณาได้ว่ามีเนมสเปซอยู่หรือไม่รวมถึงการทดสอบแบบลึกสำหรับชื่อคุณสมบัติเช่น "Book1.chapter22.paragraph37" และอีกมากมาย

แต่เนื่องจากมีการเผยแพร่ก่อนหน้านี้และเนื่องจากมีความสำคัญอย่างยิ่งจึงสมควรที่จะได้รับการเผยแพร่ในเธรดแยกต่างหากฉันจะไม่โพสต์ไว้ที่นี่ แต่จะให้คำหลัก ( javascript + isNS ) ซึ่งจะช่วยคุณค้นหาซอร์สโค้ด คำอธิบายที่จำเป็น

ในสถานการณ์เฉพาะที่ระบุไว้ในคำถาม

typeof window.console === "undefined"

เหมือนกันกับ

window.console === undefined

ฉันชอบรุ่นหลังมากกว่าเพราะสั้นกว่า

โปรดทราบว่าเราค้นหาconsoleเฉพาะในขอบเขตทั่วโลก (ซึ่งเป็นwindowวัตถุในเบราว์เซอร์ทั้งหมด) ในสถานการณ์พิเศษนี้เป็นที่พึงปรารถนา เราไม่ต้องการให้consoleนิยามไว้ที่อื่น

@BrianKelley ในคำตอบที่ยอดเยี่ยมของเขาอธิบายรายละเอียดทางเทคนิค ฉันได้เพิ่มข้อสรุปที่ขาดไปเท่านั้นและแยกย่อยเป็นสิ่งที่อ่านง่ายขึ้น

ฉันใช้สองวิธีที่แตกต่างกันขึ้นอยู่กับวัตถุ

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

บางครั้งฉันไม่ต้องการประเมินสตริงว่างเปล่าว่าเป็นเท็จดังนั้นฉันจึงใช้กรณีนี้

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

หากคุณต้องการสิ่งที่ตรงกันข้ามในครั้งแรก! ตัวแปรจะกลายเป็นตัวแปร !! และในฟังก์ชั่นที่ไม่ถูกต้อง === กลายเป็น! = และชื่อฟังก์ชั่นจะเปลี่ยนเป็นไม่ใช่ค่าไม่ถูกต้อง

typeof(elem) != 'undefined' && elem != nullการตั้งค่าของฉันคือ

อย่างไรก็ตามคุณเลือกให้ลองวางฟังก์ชั่นเช็คอินแบบนั้น

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

หากคุณไม่ทราบว่ามีการประกาศตัวแปรให้ดำเนินการต่อ typeof (x) != 'undefined' && x != null;

เมื่อคุณทราบว่ามีการประกาศตัวแปร แต่อาจไม่มีอยู่จริงคุณสามารถใช้ได้

existy(elem) && doSomething(elem);

ตัวแปรที่คุณกำลังตรวจสอบอาจเป็นคุณสมบัติที่ซ้อนกันบางครั้ง คุณสามารถใช้ prop || {} เพื่อลงบรรทัดการตรวจสอบที่อยู่ของคุณสมบัติที่มีปัญหา:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

หลังจากใช้คุณสมบัติแต่ละรายการ (... '|| {}') nextProp เพื่อให้คุณสมบัติที่ขาดหายไปจะไม่เกิดข้อผิดพลาด

หรือคุณสามารถใช้ชีวิตเช่น existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

มันขึ้นอยู่กับสถานการณ์ หากคุณกำลังตรวจสอบสิ่งที่อาจกำหนดหรือไม่ได้กำหนดไว้ทั่วโลกนอกรหัสของคุณ (เช่น jQuery) คุณต้องการ:

if (typeof(jQuery) != "undefined")

(ไม่จำเป็นต้องมีความเท่าเทียมกันอย่างเข้มงวดชนิดของมันจะส่งกลับสตริงเสมอ) แต่ถ้าคุณมีข้อโต้แย้งกับฟังก์ชั่นที่อาจจะหรืออาจจะไม่ได้ผ่านมันจะถูกกำหนดไว้เสมอ

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

ลองจับ

หากตัวแปรไม่ได้ถูกกำหนดไว้ทั้งหมดคุณสามารถตรวจสอบได้โดยไม่ต้องดำเนินการกับรหัสทำลายโดยใช้ try-catch block ดังต่อไปนี้ (คุณไม่จำเป็นต้องuse strictโหมด)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

โบนัส: (หมายถึงคำตอบอื่น ๆ ) เหตุใดจึง===ชัดเจนกว่า==( แหล่งที่มา )

ถ้า (a == b)

ถ้า (a === b)

ฉันประหลาดใจที่ยังไม่ได้กล่าวถึง ...

นี่คือรูปแบบเพิ่มเติมสองสามแบบที่ใช้ this['var_name']

ประโยชน์ของการใช้วิธีนี้ที่สามารถใช้ได้ก่อนที่จะมีการกำหนดตัวแปร

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

คุณสามารถใช้ลอง ... catch block ดังต่อไปนี้:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

ข้อเสียคือคุณไม่สามารถใส่มันในฟังก์ชั่นที่มันจะโยน ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))