Phương pháp kiểm tra nếu một biến đã được khởi tạo là tốt hơn / đúng? (Giả sử biến có thể chứa bất cứ thứ gì (chuỗi, int, object, function, v.v.))

if (elem) { // or !elem

hoặc là

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

hoặc là

if (elem != null) {

Bạn muốn các typeofnhà điều hành . Đặc biệt:

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

Các typeofnhà điều hành sẽ kiểm tra nếu biến thực sự là không xác định.

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

Các typeofnhà điều hành, không giống như các nhà khai thác khác, không ném một ReferenceError ngoại lệ khi được sử dụng với một biến chưa được khai báo.

Tuy nhiên, hãy lưu ý rằng typeof nullsẽ trở lại "object". Chúng ta phải cẩn thận để tránh sai lầm khi khởi tạo một biến thànhnull . Để an toàn, đây là những gì chúng ta có thể sử dụng thay thế:

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

Để biết thêm thông tin về việc sử dụng so sánh nghiêm ngặt ===thay vì bình đẳng đơn giản ==, hãy xem:
Nên sử dụng toán tử bằng nào (== vs ===) trong so sánh JavaScript?

Trong nhiều trường hợp, sử dụng:

if (elem) { // or !elem

sẽ thực hiện công việc cho bạn! ... điều này sẽ kiểm tra các trường hợp dưới đây:

1. không xác định : nếu giá trị không được xác định và nóundefined
2. null : ví dụ: nếu null, nếu phần tử DOM không tồn tại ...
3. chuỗi rỗng :''
4. 0 : số không
5. NaN : không phải là số
6. sai

Vì vậy, nó sẽ bao gồm loại tất cả các trường hợp, nhưng luôn có những trường hợp kỳ lạ mà chúng tôi muốn bao gồm, ví dụ, một chuỗi có khoảng trắng, như trường hợp này ' ', điều này sẽ được xác định trong javascript vì nó có khoảng trắng bên trong chuỗi ... ví dụ trong trường hợp này, bạn thêm một kiểm tra nữa bằng cách sử dụng trim (), như:

if(elem) {

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

Ngoài ra, các kiểm tra này chỉ dành cho các giá trị , vì các đối tượng và mảng hoạt động khác nhau trong Javascript, mảng []trống và đối tượng trống {}luôn luôn đúng .

Tôi tạo hình ảnh dưới đây để hiển thị tóm tắt nhanh về câu trả lời:

Trong JavaScript, một biến có thể được xác định, nhưng giữ giá trị undefined, vì vậy câu trả lời phổ biến nhất là không chính xác về mặt kỹ thuật và thay vào đó thực hiện như sau:

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
}

Điều đó có thể đủ cho mục đích của bạn. Bài kiểm tra sau đây có ngữ nghĩa đơn giản hơn, giúp dễ dàng mô tả chính xác hành vi mã của bạn và tự hiểu nó (nếu bạn quan tâm đến những điều đó):

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

Tất nhiên, điều này giả sử bạn đang chạy trên trình duyệt ( windowtên của đối tượng toàn cầu). Nhưng nếu bạn đang lẩn quẩn với những quả cầu như thế này thì có lẽ bạn đang ở trong một trình duyệt. Theo chủ quan, sử dụng 'name' in windowlà phù hợp với phong cách sử dụng window.nameđể đề cập đến toàn cầu. Truy cập toàn cầu dưới dạng các thuộc tính windowthay vì dưới dạng biến cho phép bạn giảm thiểu số lượng biến không được khai báo mà bạn tham chiếu trong mã của mình (vì lợi ích của việc nhuộm) và tránh khả năng toàn cầu của bạn bị che khuất bởi một biến cục bộ. Ngoài ra, nếu toàn cầu làm cho da của bạn bò, bạn có thể cảm thấy thoải mái hơn khi chạm vào chúng chỉ với cây gậy tương đối dài này.

Trong phần lớn các trường hợp bạn sẽ sử dụng:

elem != null

Không giống như một đơn giản if (elem), nó cho phép 0, false, NaNvà '', rồi từ chối nullhoặc undefined, làm cho nó một tốt, kiểm tra chung cho sự hiện diện của một cuộc tranh cãi, hoặc tài sản của một đối tượng.

Các kiểm tra khác cũng không chính xác, chúng chỉ có cách sử dụng khác nhau:

• if (elem): Có thể được sử dụng nếu elemlà đảm bảo được một đối tượng, hoặc nếu false, 0vv được coi là giá trị "mặc định" (do đó tương đương với undefinedhoặc null).

• typeof elem == 'undefined'có thể được sử dụng trong trường hợp một chỉ định nullcó ý nghĩa riêng biệt với một biến hoặc thuộc tính chưa được khởi tạo.

  • Đây là kiểm tra duy nhất sẽ không gây ra lỗi nếu elemkhông được khai báo (nghĩa là không có varcâu lệnh, không phải là thuộc tính của windowhoặc không phải là đối số của hàm). Điều này, theo tôi, khá nguy hiểm vì nó cho phép lỗi chính tả bị bỏ qua mà không được chú ý. Để tránh điều này, hãy xem phương pháp dưới đây.

Cũng hữu ích là một so sánh nghiêm ngặt chống lại undefined:

if (elem === undefined) ...

Tuy nhiên, vì toàn cầu undefinedcó thể bị ghi đè bằng một giá trị khác, tốt nhất nên khai báo biến undefinedtrong phạm vi hiện tại trước khi sử dụng nó:

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

Hoặc là:

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

Một lợi thế thứ cấp của phương thức này là các công cụ khai thác JS có thể giảm undefinedbiến thành một ký tự, tiết kiệm cho bạn một vài byte mỗi lần.

Kiểm tra nếu window. hasOwnProperty( " varname" )

Một thay thế cho rất nhiều typeofcâu trả lời;

Biến toàn cục được khai báo với một var varname = value;tuyên bố trong phạm vi toàn cầu

có thể được truy cập như các thuộc tính của đối tượng cửa sổ.

Như vậy, hasOwnProperty()phương pháp, mà

trả về một boolean cho biết liệu đối tượng có thuộc tính được chỉ định làm thuộc tính riêng của nó hay không (trái ngược với việc kế thừa nó)

có thể được sử dụng để xác định xem

a varcủa "varname" đã được khai báo trên toàn cầu tức là một thuộc tính của 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
] );

Điều tuyệt vời hasOwnProperty()là khi gọi nó, chúng ta không sử dụng một biến có thể chưa được khai báo - điều này tất nhiên là một nửa vấn đề ở nơi đầu tiên.

Mặc dù không phải lúc nào cũng là giải pháp hoàn hảo hay lý tưởng , nhưng trong một số trường hợp nhất định, đó chỉ là công việc!

Ghi chú

Điều trên là đúng khi sử dụng varđể xác định một biến , trái ngược với let:

khai báo một biến cục bộ phạm vi khối, tùy ý khởi tạo nó thành một giá trị.

không giống như var từ khóa, định nghĩa một biến trên toàn cầu hoặc cục bộ cho toàn bộ hàm bất kể phạm vi khối.

Ở cấp cao nhất của chương trình và chức năng let, không giống như var, không tạo ra một thuộc tính trên đối tượng toàn cầu.

Để đầy đủ: các const hằng số, theo định nghĩa, không thực sự biến (mặc dù nội dung của chúng có thể); phù hợp hơn:

Các hằng số toàn cầu không trở thành thuộc tính của đối tượng cửa sổ, không giống như varcác biến. Một bộ khởi tạo cho một hằng số là bắt buộc; nghĩa là, bạn phải chỉ định giá trị của nó trong cùng một câu lệnh được khai báo.

Giá trị của hằng số không thể thay đổi thông qua việc gán lại và nó không thể được xác định lại.

Khai báo const tạo một tham chiếu chỉ đọc đến một giá trị. Điều đó không có nghĩa là giá trị mà nó giữ là bất biến, chỉ là định danh biến không thể được gán lại.

Vì letcác biến hoặc consthằng không bao giờ là thuộc tính của bất kỳ đối tượng nào đã kế thừa hasOwnProperty()phương thức, nên nó không thể được sử dụng để kiểm tra sự tồn tại của chúng.

Về tính khả dụng và sử dụng của hasOwnProperty():

Mọi đối tượng xuất phát từ Object đều kế thừa hasOwnProperty()phương thức. [...] Không giống như intoán tử, phương thức này không kiểm tra chuỗi nguyên mẫu của đối tượng.

Làm thế nào để kiểm tra nếu một biến tồn tại

Đây là một giải pháp chống đạn khá hay để kiểm tra nếu một biến tồn tại và đã được khởi tạo:

var setOrNot = typeof variable !== typeof undefined;

Nó thường được sử dụng kết hợp với toán tử ternary để đặt mặc định trong trường hợp một biến nhất định chưa được khởi tạo:

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

Các vấn đề với đóng gói

Thật không may, bạn không thể đơn giản gói gọn kiểm tra của bạn trong một chức năng.

Bạn có thể nghĩ làm một cái gì đó như thế này:

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

Tuy nhiên, điều này sẽ tạo ra một lỗi tham chiếu nếu bạn đang gọi, vd. isset(foo)và biến foochưa được xác định, bởi vì bạn không thể chuyển dọc theo biến không tồn tại cho hàm:

Uncaught ReferenceError: foo không được xác định

Kiểm tra xem các tham số chức năng không được xác định

Mặc dù issetchức năng của chúng tôi không thể được sử dụng để kiểm tra xem một biến có tồn tại hay không (vì lý do đã giải thích ở trên), nhưng nó cho phép chúng tôi kiểm tra xem các tham số của hàm có được xác định không:

var a = '5';

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

test(a);

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

Mặc dù không có giá trị nào yđược truyền cho hàm test, issethàm của chúng ta hoạt động hoàn hảo trong ngữ cảnh này, vì yđược biết đến trong hàm testlà một undefinedgiá trị.

Có một cách ngắn khác để kiểm tra điều này, khi bạn thực hiện các bài tập đơn giản và kiểm tra liên quan. Đơn giản chỉ cần sử dụng Toán tử có điều kiện (Ternary).

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

Ngoài ra, điều này sẽ hữu ích, khi bạn cố gắng khai báo biến Toàn cầu với sự gán gán của biến tham chiếu.

Nếu bạn muốn kiểm tra biến không nên undefinedhoặc null. Sau đó thực hiện kiểm tra bên dưới.

Khi biến được khai báo và nếu bạn muốn kiểm tra giá trị, điều này thậm chí còn đơn giản: và nó sẽ thực hiện undefinedvà nullkiểm tra cùng nhau.

var values = variable ? variable : '';

Cách ngắn để kiểm tra một biến không được khai báo (không xác định) là

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

Tôi thấy nó hữu ích để phát hiện tập lệnh chạy bên ngoài trình duyệt (không có windowbiến khai báo ).

Nó phụ thuộc nếu bạn chỉ quan tâm rằng biến đã được xác định hoặc nếu bạn muốn nó có giá trị có ý nghĩa.

Kiểm tra nếu loại không xác định sẽ kiểm tra xem biến đã được xác định chưa.

=== nullhoặc !== nullsẽ chỉ kiểm tra xem giá trị của biến có chính xác khôngnull .

== nullhoặc != nullsẽ kiểm tra xem giá trị là undefinedhay null.

if(value)sẽ kiểm tra nếu biến đó là undefined, null, 0, hoặc một chuỗi rỗng.

Câu trả lời cao nhất là chính xác, sử dụng typeof.

Tuy nhiên, điều tôi muốn chỉ ra là trong JavaScript undefinedlà có thể thay đổi (vì một số lý do vô duyên). Vì vậy, chỉ cần thực hiện kiểm tra varName !== undefinedcó tiềm năng không phải lúc nào cũng trở lại như bạn mong đợi, bởi vì các lib khác có thể đã thay đổi không xác định. Một vài câu trả lời (@ skalee's, cho một người), dường như không thích sử dụng typeofvà điều đó có thể khiến một người gặp rắc rối.

Cách "cũ" để xử lý việc này là tuyên bố không xác định là var để bù đắp cho bất kỳ sự tắt tiếng / vượt quá tiềm năng nào undefined. Tuy nhiên, cách tốt nhất vẫn là sử dụng typeofvì nó sẽ bỏ qua mọi phần ghi đè củaundefined từ mã khác. Đặc biệt là nếu bạn đang viết mã để sử dụng ngoài tự nhiên, nơi ai biết những gì khác có thể đang chạy trên trang ...

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

Hoặc tốt hơn

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

Hoạt động trong tất cả các trình duyệt

Để đóng góp cho cuộc tranh luận, nếu tôi biết biến nên là một chuỗi hoặc một đối tượng tôi luôn thích if (!variable), vì vậy hãy kiểm tra xem nó có sai không. Điều này có thể mang đến mã sạch hơn, ví dụ:

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

..có thể được giảm xuống:

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

Thật khó để phân biệt giữa không xác định và null. Null là một giá trị bạn có thể gán cho một biến khi bạn muốn chỉ ra rằng biến đó không có giá trị cụ thể. Không xác định là một giá trị đặc biệt sẽ là giá trị mặc định của các biến không được gán.

var _undefined;
var _null = null;

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

Null là một giá trị trong JavaScript và typeof null trả về"object"

Do đó, câu trả lời được chấp nhận sẽ không hoạt động nếu bạn vượt qua các giá trị null. Nếu bạn chuyển các giá trị null, bạn cần thêm một kiểm tra bổ sung cho các giá trị null:

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

Kiểm tra mạnh mẽ nhất 'được xác định' là với typeof

if (typeof elem === 'undefined')

Nếu bạn chỉ kiểm tra một biến xác định để gán mặc định, để dễ đọc một lớp lót, bạn có thể thường xuyên làm điều này:

elem = elem || defaultElem;

Bạn thường sử dụng tốt, xem: Cách thành ngữ để đặt giá trị mặc định trong javascript

Ngoài ra còn có một lớp lót này sử dụng từ khóa typeof :

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

bạn có thể sử dụng typeoftoán tử.

Ví dụ,

var dataSet;

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

Đoạn mã trên sẽ trả về đầu ra như

dữ liệu biến là: không xác định.

Để kiểm tra xem một biến đã được khai báo / bộ chưa, tôi đã thực hiện thủ thuật bẩn này.

Tôi chưa tìm thấy cách trích xuất mã thành hàm, ngay cả với 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");
}

Những câu trả lời này (ngoài giải pháp Fred Gandt) đều không chính xác hoặc không đầy đủ.

Giả sử tôi cần tôi variableName;mang một undefinedgiá trị, và do đó, nó đã được khai báo theo cách thức var variableName;có nghĩa là nó đã được khởi tạo ; - Làm cách nào để kiểm tra xem nó đã được khai báo chưa?

Hoặc thậm chí tốt hơn - làm cách nào để kiểm tra ngay nếu "Book1.ch CHƯƠNG22.par Đoạn37" tồn tại với một cuộc gọi, nhưng không phát sinh lỗi tham chiếu?

Chúng tôi làm điều đó bằng cách sử dụng toán tử JasvaScript mạnh nhất, toán tử trong :

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

Trong thời điểm phổ biến AJAX, tôi đã viết một phương thức (tên sau này) làNS () có khả năng xác định xem không gian tên có tồn tại bao gồm các thử nghiệm sâu cho các tên thuộc tính như "Book1.ch CHƯƠNG22.par Đoạn37" và nhiều hơn nữa.

Nhưng vì nó đã được xuất bản trước đó và vì tầm quan trọng của nó, nó xứng đáng được xuất bản trong một chủ đề riêng biệt nên tôi sẽ không đăng nó ở đây mà sẽ cung cấp từ khóa ( javascript + isNS ) để giúp bạn xác định mã nguồn, được hỗ trợ với tất cả giải thích cần thiết.

Trong tình huống cụ thể được nêu trong câu hỏi,

typeof window.console === "undefined"

giống hệt với

window.console === undefined

Tôi thích cái sau vì nó ngắn hơn.

Xin lưu ý rằng chúng tôi chỉ tìm kiếm consoletrong phạm vi toàn cầu (là một windowđối tượng trong tất cả các trình duyệt). Trong tình huống cụ thể này, nó là mong muốn. Chúng tôi không muốnconsole định nghĩa ở nơi khác.

@BrianKelley trong câu trả lời tuyệt vời của mình giải thích các chi tiết kỹ thuật. Tôi chỉ thêm thiếu kết luận và tiêu hóa nó thành một cái gì đó dễ đọc hơn.

Tôi sử dụng hai cách khác nhau tùy thuộc vào đối tượng.

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

Đôi khi tôi không muốn đánh giá một chuỗi rỗng là falsey, vì vậy sau đó tôi sử dụng trường hợp này

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

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

Nếu bạn cần ngược lại, thì trong trường hợp đầu tiên! Biến trở thành !! biến và trong hàm không hợp lệ === trở thành! = Và tên hàm thay đổi thành notInvalid.

Sở thích của tôi là typeof(elem) != 'undefined' && elem != null .

Tuy nhiên, bạn chọn, xem xét đưa kiểm tra vào một chức năng như vậy

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

Nếu bạn không biết biến được khai báo thì hãy tiếp tục với typeof (x) != 'undefined' && x != null;

Trường hợp bạn biết biến được khai báo nhưng có thể không tồn tại, bạn có thể sử dụng

existy(elem) && doSomething(elem);

Biến bạn đang kiểm tra đôi khi có thể là một thuộc tính lồng nhau. Bạn có thể sử dụng prop | | {} để đi xuống sự tồn tại của dòng kiểm tra đối với thuộc tính được đề cập:

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

Sau mỗi thuộc tính sử dụng (... '|| {}'). NextProp để một thuộc tính bị thiếu sẽ không gây ra lỗi.

Hoặc bạn có thể sử dụng như existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Nó phụ thuộc vào tình hình. Nếu bạn đang kiểm tra thứ gì đó có thể hoặc không được xác định trên toàn cầu bên ngoài mã của bạn (như jQuery có lẽ), bạn muốn:

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

(Không cần bình đẳng nghiêm ngặt ở đó, typeof luôn trả về một chuỗi.) Nhưng nếu bạn có đối số cho hàm có thể hoặc không được thông qua, chúng sẽ luôn được xác định, nhưng không có giá trị nếu bị bỏ qua.

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

Cố gắng bắt

Nếu biến hoàn toàn không được xác định, bạn có thể kiểm tra điều này mà không cần thực thi mã bằng cách sử dụng khối thử bắt như sau (bạn không cần phải use strictchế độ)

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');

THƯỞNG: (tham khảo các câu trả lời khác) Tại sao ===rõ ràng hơn ==( nguồn )

nếu (a == b)

nếu (a === b)

Tôi ngạc nhiên khi điều này chưa được đề cập ...

Dưới đây là một vài biến thể bổ sung sử dụng this['var_name']

lợi ích của việc sử dụng phương pháp này mà nó có thể được sử dụng trước khi một biến được xác định.

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!

Bạn có thể sử dụng một khối thử ... bắt như sau:

var status = 'Variable exists'

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

console.log(status)

Một bất lợi là bạn không thể đặt nó vào một chức năng vì nó sẽ ném ReferenceError

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

console.log(variableExists(x))