Какой метод проверки правильности инициализации переменной лучше/правильно? (Предполагая, что переменная может содержать что угодно (строка, int, объект, функция и т.д.))
if (elem) { // or !elem
или
if (typeof(elem) !== 'undefined') {
или
if (elem != null) {
Оператор typeof проверяет, действительно ли переменная undefined.
if (typeof variable === 'undefined') {
// variable is undefined
}
Оператор typeof, в отличие от других операторов, не генерирует исключение ReferenceError при использовании с необъявленной переменной.
Однако обратите внимание, что typeof null вернет "object". Мы должны быть осторожны, чтобы избежать ошибки инициализации переменной до null. Чтобы быть в безопасности, это то, что мы могли бы использовать вместо этого:
if (typeof variable === 'undefined' || variable === null) {
// variable is undefined or null
}
Для получения дополнительной информации об использовании строгого сравнения === вместо простого равенства == см.: Какой equals оператор (== vs ===) следует использовать в сравнении JavaScript?
Вы хотите оператор typeof. В частности:
if (typeof variable !== 'undefined') {
// the variable is defined
}
В 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, а не как переменные, позволяет свести к минимуму количество необъявленных переменных, которые вы ссылаетесь в своем коде (в интересах листинга), и избегает возможности того, что ваш глобальный объект будет затенен локальной переменной. Кроме того, если глобалы заставят вашу кожу сканировать, вы можете чувствовать себя более комфортно, касаясь их только этой относительно длинной палкой.
Во многих случаях использование:
if (elem) { // or !elem
сделают эту работу за вас!... это проверит следующие случаи:
undefined'' Таким образом, он будет охватывать все случаи, но всегда есть странные случаи, которые мы хотели бы также затронуть, например, строку с пробелами, такую как ' ' один", это будет определено в javascript, поскольку оно имеет пробелы внутри строки... например, в этом случае вы добавляете еще одну проверку с помощью trim(), например:
if(elem) {
if(typeof elem === 'string' && elem.trim()) {
///
Кроме того, эти проверки предназначены только для значений, поскольку объекты и массивы работают по-разному в Javascript, пустой массив [] и пустой объект {} всегда верны.
Я создаю изображение ниже, чтобы быстро показать ответ:
В большинстве случаев вы будете использовать:
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 minifiers может уменьшить переменную undefined до одного символа, каждый раз сохраняя несколько байтов.
Это довольно пуленепробиваемое решение для тестирования, если переменная существует и была инициализирована:
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 не определена, потому что вы не можете передать несуществующую переменную функции:
Неподготовлено ReferenceError: foo не определен
Хотя наша функция isset не может использоваться для проверки наличия или отсутствия переменной (по причинам, описанным выше), это позволяет нам проверить, являются ли параметры функции undefined:
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.
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
] );Есть еще один короткий способ проверить это, когда вы выполняете простые назначения и связанные проверки. Просто используйте условный (тройной) оператор.
var values = typeof variable !== 'undefined' ? variable : '';
Также это будет полезно, когда вы попытаетесь объявить глобальную переменную с назначением экземпляра ссылочной переменной.
Если вы хотите проверить переменную, она не должна быть undefined или null. Затем выполните проверку ниже.
Когда переменная объявлена, и если вы хотите проверить значение, это даже просто: и он будет выполнять undefined и null проверки вместе.
var values = variable ? variable : '';
Это зависит, если вам просто нужно, чтобы была определена переменная или если вы хотите, чтобы она имела значение.
Проверка того, является ли тип undefined, будет проверять, была ли еще определена переменная.
=== null или !== null будет проверять, действительно ли значение переменной равно null.
== null или != null проверит, имеет ли значение undefined или null.
if(value) проверяет, есть ли переменная undefined, null, 0 или пустая строка.
undefined, логическое значение, строка, число, функция
if( typeof foo !== 'undefined' ) {
}
Объект, Массив
if( foo instanceof Array ) {
}Самый верный ответ правильный, используйте typeof.
Однако, я хотел бы отметить, что в JavaScript undefined является изменяемым (по какой-то нечестивой причине). Поэтому просто проверка на varName !== undefined может не всегда возвращаться, как вы ожидаете, потому что другие библиотеки могли бы изменить undefined. Несколько ответов (@skalee's, для одного), похоже, предпочитают не использовать typeof, и это может вызвать проблемы.
"Старый" способ справиться с этим заключался в объявлении undefined как 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);
}Трудно различить undefined и null. 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
}
Краткий способ проверки переменной не объявлен (не определен)
if (typeof variable === "undefined") {
...
}
Я нашел это полезным для обнаружения скрипта, работающего вне браузера (без объявленной переменной window).
вы можете использовать оператор typeof.
Например,
var dataSet;
alert("Variable dataSet is : " + typeof dataSet);
Выше фрагмента кода вернет вывод, например
переменная dataSet: undefined.
Самый надежный "он определен" проверяется с помощью typeof
if (typeof elem === 'undefined')
Если вы просто проверяете определенную переменную, чтобы назначить значение по умолчанию, для удобного для чтения одного вкладыша вы часто можете это сделать:
elem = elem || defaultElem;
Часто бывает полезно использовать: Идиоматический способ установки значения по умолчанию в javascript
Существует также этот один вкладыш, используя ключевое слово typeof:
elem = (typeof elem === 'undefined') ? defaultElem : elem;
Эти ответы (кроме решения Фреда Гэндта) являются либо неправильными, либо неполными.
Предположим, что мне нужно 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;
}
Если вам нужно обратное, то в первом экземпляре! Переменная становится переменной !!, а в недопустимой функции === становится! = И имена функций изменяются на notInvalid.
Если вы хотите, чтобы определенный блок сделал что-то, используйте
if (typeof variable !== 'undefined') {
// the variable is defined
}
Если вы хотите, чтобы блок undefined выполнял что-либо или назначал или определял переменную, используйте этот
if (typeof variable === 'undefined') {
// the variable is undefined
}
Это зависит от ситуации. Если вы проверяете что-то, что может быть или не определено глобально вне вашего кода (например, jQuery), вы хотите:
if (typeof(jQuery) != "undefined")
(Нет необходимости строгого равенства там, typeof всегда возвращает строку.) Но если у вас есть аргументы для функции, которая может быть или не быть передана, они всегда будут определены, но null, если они опущены.
function sayHello(name) {
if (name) return "Hello, " + name;
else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"
Мое предпочтение - 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)
Немного более функциональный и простой в использовании:
function exist(obj)
{
return (typeof obj !== 'undefined');
}
Функция вернет true, если существует, else false, если этого не существует.
Помните, что когда вы проверяете! == or! = Против "undefined", он не будет работать
Протестировано на Firfox Quantum 60.0.1
используйте тест, подобный этому, чтобы избежать конфликтов
if(!(typeof varibl['fl'] === 'undefined')) {
console.log(varibl['fl']);
console.log("Variable is Defined");
}else{
console.log(varibl['fl']);
console.log("Variable is Un-Defined");
}
Как насчет простой:
if(!!variable){
//the variable is defined
}
Я удивлен, что это еще не упомянуто...
вот несколько дополнительных вариантов, использующих 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 been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it 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!
Чтобы проверить, объявлена /установлена переменная, я сделал этот грязный трюк.
Я не нашел способ извлечь код в функцию, даже с 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");
}
Не уверен, что это поможет, мне нужно было проверить, был ли выбран Var, который был определен на странице, перед запуском связанных скриптов, и для меня это работало отлично.
if (window.myvar) { // run scripts here }
Это немного просто, но отлично подходит для одного из них или подобных.