Який метод перевірки, чи ініціалізована змінна, є кращою / правильною? (Припустимо, що змінна може містити все, що завгодно (рядок, 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 : якщо значення не визначене, воно єundefined
2. null : якщо це 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для позначення глобальних точок. Доступ до глобальних глобальних ресурсів як властивостей, 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) ...
})();

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

Перевірте, чи window. hasOwnProperty( " varname" )

Альтернатива безлічі typeofвідповідей;

Глобальні змінні, оголошені var varname = value;заявою в глобальній області

можна отримати доступ до властивостей об'єкта вікна.

Як такий, hasOwnProperty()метод, який

повертає булеве значення, що вказує, чи має об'єкт вказану властивість як власну властивість (на відміну від успадкування)

можна використовувати для визначення, чи є

varз «» перем оголошена глобально тобто є власністю 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змінних. Потрібен ініціалізатор для константи; тобто ви повинні вказати його значення в тому самому виписці, в якому воно оголошено.

Значення константи не може змінюватися за допомогою перепризначення, і її неможливо змінити.

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

Оскільки letзмінні або constконстанти ніколи не є властивостями жодного об'єкта, який успадкував hasOwnProperty()метод, його не можна використовувати для перевірки їх існування.

Щодо наявності та використання hasOwnProperty():

Кожен об'єкт, що походить від Object, успадковує 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значення.

Існує ще один короткий спосіб перевірити це, коли ви виконуєте прості завдання та відповідні перевірки. Просто використовуйте умовного (термінального) оператора.

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

Також це стане в нагоді, коли ви намагаєтеся оголосити глобальну змінну з присвоєнням екземпляру посилальної змінної.

Якщо ви хочете перевірити змінну, не повинно бути undefinedабо null. Потім виконайте перевірку нижче.

Коли змінна оголошена, і якщо ви хочете перевірити значення, це навіть просто: і вона буде виконуватись undefinedі nullперевірятися разом.

var values = variable ? variable : '';

Короткий спосіб перевірки змінної не оголошено (не визначено) є

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

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

Це залежить, якщо вам просто важливо, щоб змінна була визначена або ви хочете, щоб вона мала значуще значення.

Перевіряючи, чи не визначено тип, перевірятиметься, чи вказана змінна ще не визначена.

=== nullабо !== nullперевірять, чи точно вказане значення змінної null.

== nullабо != nullперевірить, чи є значення undefinedчи null.

if(value)перевірятиме , якщо змінна undefined, null, 0або порожній рядок.

Найвища відповідь правильна, використовуйте typeof.

Однак те, що я хотів зазначити, це те, що в JavaScript undefinedє змінним (з якоїсь безбожної причини). Тож просто перевірка на varName !== undefinedнаявність потенціалу не завжди повертається так, як ви очікуєте, тому що інші моменти можуть змінитися невизначено. Кілька відповідей (@ skalee's, наприклад), схоже, вважають за краще не використовувати typeof, і це може призвести до неприємностей.

"Старий" спосіб вирішення цього питання був оголошений невизначеним як вар для компенсації будь-якого потенційного приглушення / надмірної їзди 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)
} 

Важко відрізнити невизначений від недійсного. Null - це значення, яке можна призначити змінній, коли ви хочете вказати, що змінна не має конкретного значення. Undefined - це особливе значення, яке буде типовим значенням непризначених змінних.

var _undefined;
var _null = null;

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

Null - значення в JavaScript і typeof nullповертається"object"

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

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

Найбільш надійна перевірка "це визначено" - це typeof

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

Це часто добре використовувати, див. Ідіоматичний спосіб встановити значення за замовчуванням у JavaScript

Існує також цей один вкладиш, який використовує ключове слово typeof :

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

можна скористатися typeofоператором.

Наприклад,

var dataSet;

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

Вище фрагмент коду поверне вихідний результат

Змінна setSet: не визначена.

Щоб перевірити, чи була оголошена / встановлена ​​змінна, я зробив цей брудний трюк.

Я навіть не знайшов способу витягти код до функції, навіть за допомогою 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");
}

Ці відповіді (окрім рішення Фреда Гандта) є або неправильними, або неповними.

Припустимо, мені потрібно, 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")

(Тут немає суворої рівності, typeof завжди повертає рядок.) Але якщо у вас є аргументи до функції, яка може бути або не може бути передана, вони завжди будуть визначені, але нульові, якщо вони опущені.

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

Спробуйте-ловити

Якщо змінна взагалі не була визначена, ви можете перевірити це без виконання коду розриву, використовуючи блок try-catch наступним чином (вам не потрібно 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 на зразок наступного:

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