Какой метод проверки инициализации переменной лучше/корректнее? (Предполагается, что переменная может содержать что угодно (строку, 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
вернет "объект"
. Мы должны быть осторожны, чтобы избежать ошибки инициализации переменной значением "null". На всякий случай вот что мы могли бы использовать вместо этого:
if (typeof variable === 'undefined' || variable === null) {
// variable is undefined or null
}
Для получения дополнительной информации об использовании строгого сравнения ===
вместо простого равенства ==
см.:
https://stackoverflow.com/q/359494/584192
В 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'' в window
стилистически соответствует использованию window.name
для обращения к глобальным объектам. Обращение к глобальным переменным как к свойствам window
, а не как к переменным, позволяет вам минимизировать количество необъявленных переменных, на которые вы ссылаетесь в коде (для пользы линтинга), и избежать возможности того, что ваша глобальная переменная окажется в тени локальной переменной. Кроме того, если глобальные переменные вызывают у вас неприятные ощущения, вы можете чувствовать себя более комфортно, прикасаясь к ним только этой относительно длинной палкой.
Во многих случаях, используя:
if (elem) { // or !elem
будет делать работу за вас!... это будет проверка следующих случаях:
''
Так что он будет охватывать тот всех случаях, но всегда есть странные случаи, которые мы'd, как для покрытия, например, строку с пробелами, как это' '
один, это будет определено в JavaScript, так как он содержит пробелы внутри строки... например в этом случае можно добавить еще одну проверку, используя отделку(), как:
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 могут сократить переменную 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` не был определен, потому что вы не можете пройти по несуществующей переменной в функцию :
непойманные ReferenceError: фу не определен
Пока наш задается
функция не может использоваться, чтобы проверить, существует ли переменная или нет (по причинам, изложенным hereabove), это позволит нам проверить ли параметры функции неопределены :
var a = '5';
var test = function(x, y) {
console.log(isset(x));
console.log(isset(y));
};
test(a);
// OUTPUT :
// ------------
// TRUE
// FALSE
Хотя никакого значения для г
передается в функцию тест
, наш задается
функция прекрасно работает в этом контексте, ведь М
- это известный в функция "тест" в качестве "неопределенным" значением.
window
.hasOwnProperty
("varname
")Альтернатива изобилие оператора typeof
ответы;
Глобальной переменные, объявленные с помощью VAR имя_переменной = значение;` заявление в глобальной области видимости
могут быть доступны как свойства объекта window.
Как таковой, метод hasOwnProperty()
метод, который
возвращает логическое значение, указывающее, является ли объект указанное имущество как свою собственность (в отличие от наследования)
может быть использован для определения
в ВАР
о ТО"переменная" и был объявлен на глобальном уровне т. е. - свойство "окно".
в
// 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 () заключается в том, что, называя его, мы не'т использовать переменную, которая может еще быть заявлен - но это полбеды в первую очередь.
Хотя не на на отлично или идеал решение, в определенных обстоятельствах, это's просто работу!
Вышесказанное справедливо при использовании ВАР
, чтобы определить переменную, а не давай
, который:
объявляет блок рамки локальной переменной, при необходимости его инициализации значение.
>есть в отличие от ключевого слова var, которая определяет переменную глобально, или локально, чтобы все функции, независимо от объема блока.
В верхнем уровне программ и функций,
давай
, в отличие отВАР
, не создается свойство глобального объекта.
Полнота: константный
константы, по определению, фактически не переменную (хотя их содержание может быть); более уместно:
глобальные константы не являются свойствами объекта window, В отличие от "переменных" переменные. Требуется инициализатор для постоянной-то есть, вы должны указать его стоимость в том же заявлении, в котором она'ы объявили.
значение константы нельзя изменить путем перевода, и он может'т быть повторно объявлен.
константная декларации создает только для чтения ссылка на значение. Это не значит значение, которое он держит, является неизменным, так что идентификатор переменной не могут быть переназначены.
Так давайте переменных или как const
константы не являются свойствами какого-либо объекта, который наследует метод метод hasOwnProperty ()
, он не может быть использован, чтобы проверить их существование.
Относительно наличия и использования метода hasOwnProperty()`:
Есть еще один короткий ручной способ проверить это, когда вы выполняете простые задания и соответствующих проверок. Просто использовать условный (тернарный оператор).
var values = typeof variable !== 'undefined' ? variable : '';
Также это будет полезно, когда вы пытаетесь объявить глобальную переменную с присвоением экземпляр ссылочной переменной.
Если вы хотели проверить переменную должен'т быть не определено
или null
. Затем выполните ниже проверки.
При объявлении переменной, а если вы хотите проверить значение, это даже удобно: и он будет выполнять чеки не определено и
нуль `вместе.
var values = variable ? variable : '';
Это зависит от того, заботитесь ли вы просто о том, чтобы переменная была определена, или хотите, чтобы она имела осмысленное значение.
Проверка на неопределенность типа позволит проверить, была ли переменная еще определена.
=== null
или !== null
проверяет только то, что значение переменной в точности равно null
.
== null
или !== null
будет проверено, является ли значение неопределенным
или нулевым
.
if(value)
проверяет, является ли переменная undefined
, null
, 0
или пустой строкой.
Короткий путь, чтобы проверить, что переменная не объявлена (не undefined) в
if (typeof variable === "undefined") {
...
}
Я нашел его полезным для обнаружения скрипт работает вне браузера (не имея переменная, объявленная "окно").
Высший ответ является правильным, оператор typeof используется.
Однако, то, что я хотел бы отметить, что в JavaScript не определено
- это Мутабельный (по какой-то невообразимой причине). Так просто делать чек на имя_переменной !== неопределенные
имеет потенциал не всегда возвращается так, как вы ожидали, потому что другие библиотеки могли бы изменить неопределенным. Несколько ответов (@skalee'ы, например), предпочитают не используя оператора typeof
, и что может сделать один в неприятности.
В "Старый" и пути, чтобы справиться с этим заявлением определен как ВАР, чтобы компенсировать любые потенциальные отключение/за езду с "неопределенным". Однако, наилучшим способом является все-таки использование оператора typeof
, потому что он будет игнорировать любые переопределения "неопределенным" от других код. Особенно если вы пишете код для использования на природе, где кто знает, что еще может быть запущена на страницу...
Внести свой вклад в дискуссию, если я знаю, что переменная должна быть строкой или объектом, я всегда предпочитаю `если (!переменной), поэтому проверять, если его ложь. Это может привести к более чистый код, например:
в
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 = нуль;
предупреждение(_undefined); предупреждение(_null); предупреждение(_undefined == _null); предупреждение(_undefined === _null); </код> </пред>
Null-это значение в JavaScript и вызова typeof значение null возвращается в "объект"
в
Поэтому, принято отвечать не будет работать, если вы передаете NULL значения. Если вы передаете NULL значения, вам нужно добавить дополнительную проверку на значение null:
if ((typeof variable !== "undefined") && (variable !== null))
{
// the variable is defined and not null
}
вы можете использовать для вызова typeof оператора.
Например,
var dataSet;
alert("Variable dataSet is : " + typeof dataSet);
Выше фрагмент кода возвращает результат
переменная набора данных : не определено.
Эти ответы (в стороне от решения Фред Gandt ) являются неверными или неполными.
Предположим, мне нужен мой имя_переменной;
для того чтобы снести с "неопределенным" значением, и поэтому он был объявлен таким образом, Как помощью VAR имя_переменной;` значит, это's уже инициализировать; - как я могу проверить, если это's уже объявили?
Или даже лучше - как же я сразу не проверить, если на "Книга1.chapter22.paragraph37" не существует ни одного звонка, но не поднимаются ссылка ошибка?
Мы делаем это с помощью самого мощного оператора JasvaScript, в в опе.:
"[variable||property]" in [context||root]
>> true||false
Во времена Аякса пика популярности Я'вэ написано способ (позже названный) иснс (), который способен определять, если пространство имен не существует в том числе и глубокие тесты для имен свойств, таких как "Книга1.chapter22.paragraph37" и многое другое.
Но так как он был ранее опубликован и в силу своей огромной важности, которую оно заслуживает быть опубликованным в отдельном потоке я не разместить его здесь, но будет представить ключевые слова (на JavaScript + иснс ), которая поможет вам найти исходный код, поддерживаемый всеми необходимыми пояснениями.
Самые надежные 'это определено' проверки С для вызова typeof
if (typeof elem === 'undefined')
Если вы просто проверка на определенной переменной присвоить значение по умолчанию, вы можете просто прочитать один вкладыш вы часто можете сделать это:
elem = elem || defaultElem;
Это'ы часто хорошо использовать, см.: https://stackoverflow.com/questions/505840/idiomatic-way-to-set-default-value-in-javascript
Есть еще один вкладыш с использованием от typeof ключевое слово:
elem = (typeof elem === 'undefined') ? defaultElem : elem;
В конкретной ситуации, изложенной в вопросе,
typeof window.console === "undefined"
идентично
window.console === undefined
Я предпочитаю последний, поскольку он's меньше.
Обратите внимание, что мы смотрим на консоли
только в глобальной области видимости (которая является объектом окно
во всех браузерах). В данной конкретной ситуации это'ы желательно. Мы не'т хотим, чтобы консоль `` определен в другом месте.
@BrianKelley в его замечательный ответ объясняет технические детали. Я'вэ только добавил недостающие заключение и переварил его в чем-то легче читать.
Чтобы проверить, если переменная была объявлена/комплект я сделала эту пакость.
Я не'т нашли способ извлечь код в отдельную функцию, даже при функции "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");
}