Есть ли в JavaScript стандартная функция для проверки нулевых, неопределенных или пустых переменных?

avatar
Alex
1 апреля 2011 в 15:14
2293738
47
2656

Существует ли универсальная функция JavaScript, которая проверяет, имеет ли переменная значение, и гарантирует, что оно не undefined или null? У меня есть этот код, но я не уверен, что он охватывает все случаи:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}
Источник
Dour High Arch
10 июня 2013 в 19:40
6

возможный дубликат Как проверить наличие пустой строки в JavaScript?

Darren Griffith
13 октября 2016 в 22:42
0

Я сделал скрипку для тестирования: jsfiddle.net/J7m7m/886

David Baucum
2 августа 2017 в 17:55
124

Совет, никогда не делай (truthy statement) ? true : false;. Просто сделай (truthy statement);.

Madbreaks
1 февраля 2018 в 00:55
7

@GeorgeJempty не обман, так как другой ответ спрашивает о строках в частности, тогда как этот спрашивает о переменных .

Madbreaks
1 февраля 2018 в 01:03
3

Любой правильный ответ на этот вопрос полностью зависит от того, как вы определяете «пустой».

Khurshid Ansari
15 февраля 2018 в 08:51
0

ложные значения в javascript, например: developer.mozilla.org/en-US/docs/Glossary/Falsy

Jay
30 января 2019 в 14:54
0

@ Дэвид из любопытства, почему бы и нет? Я использовал оба без видимых побочных эффектов.

David Baucum
30 января 2019 в 22:58
4

@Jay Это не повредит выполнению вашего кода. Это просто слишком многословно. Вы бы не сказали: «Вы голодны, правда?» Вы просто «голодны». Поэтому в коде просто скажите if (hungry) … вместо if (hungry === true) …. Как и все такое кодирование, это дело вкуса. Более конкретно для примера, предоставленного OP, он говорит еще более подробно: «Если это правда, то правда, если нет, то ложь». Но если это правда, то это уже правда. И, если это ложь, это уже ложь. Это похоже на высказывание: «Если вы голодны, значит, вы голодны, а если нет, то нет».

frodo2975
19 января 2020 в 04:29
2

Если вы хотите, чтобы значение было настоящим логическим значением, вы можете сделать !!value. Это просто оператор «не» дважды, поэтому он читается как «не не значение», что является его логическим значением.

Alex
19 января 2020 в 10:18
0

@ frodo2975, спасибо. Не знал, что в JavaScript можно таким способом преобразовать значение в логическое. Это то же самое, что и C ++. Интересно

RaaaCode
14 апреля 2020 в 21:11
0

Правильный ответ зависит от того, как вы определяете ложь, как сказано. Чтобы разобраться с ложью: function isEmpty(val) { return (val || val === false) }

Shahid Hussain Abbasi
16 апреля 2020 в 06:40
0

Это становится ошибкой, когда ввод является логическим.

Rodrigo Borba
26 мая 2021 в 00:29
0

не будет ли, если (variable == null || variable.length <= 0) поможет? неопределенные результаты в ИСТИНА Нулевые результаты в ИСТИНА [] результаты в ИСТИНА

Ответы (47)

avatar
jAndy
1 апреля 2011 в 15:17
5105

Вы можете просто проверить, имеет ли переменная значение truthy или нет. Это означает

if( value ) {
}

будет оцениваться как true, если value равно не :

  • ноль
  • не определено
  • NaN
  • пустая строка ("")
  • 0
  • ложь

В приведенном выше списке представлены все возможные значения falsy в ECMA- / Javascript. Найдите его в спецификации в разделе ToBoolean.

Кроме того, если вы не знаете , существует ли переменная (это означает, что если она была объявлена ​​), вам следует проверить с помощью оператора typeof. Например,

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Если вы можете быть уверены, что переменная объявлена ​​по крайней мере, вы должны напрямую проверить, имеет ли она значение truthy, как показано выше.

TruMan1
30 декабря 2012 в 22:38
147

Что делать, если значение является ложным логическим значением, которое было задумано. Иногда вы хотите указать значение по умолчанию, если значение отсутствует, что не сработает, если было передано false boolean.

jAndy
31 декабря 2012 в 04:58
111

@ TruMan1: в таком случае (когда ваша логика диктует валидацию) вы должны пойти как if( value || value === false ). То же самое касается всех ложных значений , нам нужно проверить их явно.

user
18 апреля 2014 в 21:06
33

За исключением случаев, когда значение является массивом. Интерпретация truthy может вводить в заблуждение. В этом случае мы должны проверять value.length != 0 на наличие непустого массива.

KFL
26 августа 2014 в 07:24
15

Просто хочу добавить, что если вам кажется, что конструкция if синтаксически слишком сложна, вы можете использовать тернарный оператор, например: var result = undefined ? "truthy" : "falsy". Или, если вы просто хотите привести к логическому значению, используйте оператор !!, например !!1 // true, !!null // false.

Christophe Roussy
21 ноября 2014 в 10:28
9

Также обратите внимание, что это не будет проверять строки, содержащие только символы пробела.

Aaron Gray
12 февраля 2015 в 01:54
1

Вот это да. На этот раз JavaScript красивее Ruby. Куда идет мир?

Rohit
5 марта 2015 в 15:27
0

Еще один интересный факт: только переменная NaN не равна самой себе. т.е. если вам нужно конкретно проверить, является ли переменная NaN, используйте (var! == var). var x = NaN; x !== x (true)

Gayle
4 мая 2015 в 19:11
0

Другая причина проверить, больше ли длина 0 (в дополнение к проверке массива, упомянутой @buffer), заключается в том, что "" (пробел) не считается "правдивым", но концептуально пуст.

connexo
16 июня 2015 в 15:05
3

Имейте в виду, что это приведет к нежелательным результатам, если 0 на самом деле нормально value (что в большинстве случаев, когда некоторое целое или десятичное значение должно храниться в value).

Brad
17 июня 2015 в 21:10
0

какая-нибудь версия IE10 этого?

Luboš Turek
6 июля 2015 в 16:58
1

typeof больше не безопасен в ES6. Вы получите ReferenceError, если вы введете переменную, объявленную с помощью let или const позже в области видимости. Подробнее: coderhelper.com/q/31219420/3242070

BentOnCoding
23 июля 2015 в 17:20
4

Это действительно простой ответ, который приведет к множеству ложных срабатываний. При проверке значений нужно быть более конкретным.

x0n
19 января 2016 в 05:07
0

по-видимому, последняя мода заключается в том, чтобы протестировать undefined против (void 0), поскольку undefined вполне может быть допустимой переменной в области видимости.

Jim
10 февраля 2016 в 18:01
1

Интересно, возникла ли эта ссылка на «правдивость» до изобретения этого термина Стивеном Колбертом?

Kellen Stuart
5 марта 2016 в 22:03
0

Мне трудно понять синтаксис: я привык видеть что-то вроде if(empty(value)){//value is empty}. Хотя полезно знать

Avinash Agrawal
7 сентября 2016 в 10:31
0

Кажется, в этом ответе есть исправление var a; if (a) {console.log ('I am undefined "');} Выводит" I am undefined "в консоли, где as typeof (a) все еще не определен

Jasmine
9 октября 2016 в 23:43
1

@jAndy: Спасибо, только ваше решение помогло мне сегодня решить проблему :)

Matthew Trow
4 января 2017 в 17:02
2

Это все хорошо, если только вы не проверяете числовое значение, которое может включать 0. Просто предупреждаю, поскольку в какой-то момент это может укусить вас прямо под задницу, как это случилось со мной сегодня. Я проверял наличие переменной, полученной из конечной точки (json), и производил расчет цены. Цена была 0. Таким образом, мой код не удался, так как 0 в моем случае было допустимым значением.

Caverman
9 марта 2017 в 14:48
0

Означает ли «0», что он проверит длину массива? Я работаю над некоторыми унаследованными JS, и есть много проверок на NULL и variable.length> 0. Я знаю правду о получении NULL, но проверяет ли он также переменную массива, имеющую длину?

jAndy
10 марта 2017 в 13:10
0

Нет, совсем нет. Проверка типа if( array_name ) всегда будет true, если array_name ссылается на что-либо. Это включает пустой массив (объект). Вкратце: условие просто проверяет ссылку, а не содержимое, поэтому вам нужно явно проверить наличие array_name.length, если вам нужно знать, есть ли какие-либо элементы, содержащиеся в этом js-массиве.

Buffalo
2 мая 2017 в 13:39
0

Я наткнулся на этот ответ и продолжал использовать это решение, пока не получил значение 0 , не запускающее if. Исключение «0» должно быть выделено жирным шрифтом.

iaforek
4 октября 2017 в 14:23
1

Если значением является пустой объект {} или пустой массив [], будет возвращено true.

Sam Alexander
20 октября 2017 в 20:25
0

неопределенные значения в этом случае разрешаются как неопределенные, а не как ложные

Cazanator
18 января 2018 в 04:53
0

Ответ частично неверен. Если у вас есть const value = '' и вы делаете if (! Value), оно будет оцениваться как true даже без значения. Хотя вы можете делать стенографические записи, они могут сбивать с толку в крупномасштабных проектах, где вам нужно знать, каким должно быть ожидаемое значение ошибки при чтении кода. Сокращение болезненно при работе с проектами, которые вы не писали сами.

user378380
7 марта 2019 в 00:14
0

Это определенно то, чего вы не хотите делать, это будет возвращаться слишком часто. Явная ошибка javascript.

Rafe
24 апреля 2019 в 01:27
0

См. Python. Даже [] будет тестироваться как false. Это, конечно, выбор, так как вы все еще можете использовать == для значений или is в некоторых случаях (хотя здесь не будем объяснять этот последний)

Ed of the Mountain
5 августа 2019 в 20:24
0

Как включить тест для пустого объекта? const emptyObject = {}, вернет true, если проверено.

Nicholas Hamilton
20 октября 2019 в 02:32
0

Не могу поверить, что этот ответ получил 4000 голосов и был отмечен как правильный. null, undefined и false (y) - не одно и то же.

Dulguun Otgon
14 ноября 2019 в 01:47
0

Также помните, что !! "0" === true, иногда он пробирается, например, когда вы получаете его от <input>

Leon
20 июня 2020 в 07:49
0

как насчет "нуль"?

Omar bakhsh Twitter MomoAmoory
17 января 2021 в 15:35
0

в es6 val? doSomthing (): null;

Jonathan
4 февраля 2021 в 13:39
0

0 почти всегда считается определенным и наиболее распространенным источником ошибок с этим типом кода. Видел это слишком много раз.

fcaserio
5 марта 2021 в 15:26
0

этот метод не работает, если переменная равна нулю (0)

jAndy
9 марта 2021 в 22:37
0

@fcaserio Значение 0 упоминается в исходном сообщении.

Switch386
16 июня 2021 в 19:02
0

это действительно не отвечает на вопрос

avatar
bnieland
31 марта 2022 в 21:04
0

ТОЛЬКО проверять наличие undefined и null с помощью "объединения nullish"

if ((myVariable ?? undefined) !== undefined) {
    // handle myVariable has a value, including 0 or ""
}
else {
    // handle undefined or null only
}

из хромированной консоли

{const x=undefined; (x ?? undefined) !== undefined}
false

{const x=null; (x ?? undefined) !== undefined}
false

{const x=0; (x ?? undefined) !== undefined}
true

{const x=""; (x ?? undefined) !== undefined}
true

{const x={}; (x ?? undefined) !== undefined}
true

{const x=[]; (x ?? undefined) !== undefined}
true

{const x="a"; (x ?? undefined) !== undefined}
true
avatar
Pakpoom Tiwakornkit
6 марта 2022 в 10:46
1

Я думаю, ваш код выглядит проще

Чтобы проверить, является ли переменная undefined или null

var a=undefined, b=null, c='hello world', d;
if(a !== (a ?? {})) { /**/ } // true
if(b !== (b ?? {})) { /**/ } // true
if(c !== (c ?? {})) { /**/ } // false
if(d !== (d ?? {})) { /**/ } // true

Чтобы проверить, является ли переменная НЕ undefined или null

var a=undefined, b=null, c='hello world', d;
if(a === (a ?? {})) { /**/ } // false
if(b === (b ?? {})) { /**/ } // false
if(c === (c ?? {})) { /**/ } // true
if(d === (d ?? {})) { /**/ } // false
avatar
Yilmaz
20 ноября 2021 в 19:33
2

это мое решение, чтобы проверить, являются ли данные пустыми или нет.

const _isEmpty = (data) => {
  return (
    // this way we can also check for undefined values. null==undefined is true
    data == null ||
    data == "" ||
    (Array.isArray(data) && data.length === 0) ||
    // we want {} to be false. we cannot use !! because !!{} turns to be true
    // !!{}=true and !!{name:"yilmaz"}=true. !! does not work ofr objects
    (data.constructor === Object && Object.keys(data).length === 0)

  );
};
avatar
thenewjames
15 июня 2021 в 14:30
3

Вы можете использовать нулевой оператор объединения ??, чтобы проверить значения null и undefined. См. Документы MDN

null ?? 'default string'; // returns "default string"

0 ?? 42;  // returns 0

(null || undefined) ?? "foo"; // returns "foo"
avatar
Uladzislau Ulasenka
17 декабря 2020 в 12:10
1

Вернет false только для undefined и null:

return value ?? false

Pi Delport
5 января 2021 в 17:22
2

Не совсем так: false ?? false === false

kli
8 марта 2021 в 20:51
0

Да, это предложение также вернет false для ввода false ...

bnieland
30 апреля 2021 в 11:46
0

Для ясности, этот ответ неверен в этом, !(0 ?? false) === true

avatar
user7396942
13 октября 2020 в 18:26
0
  1. вы можете использовать аргументы
  2. становятся аргументами массива
  3. фильтр

function validateAttrs(arg1, arg2, arg3,arg4){
    var args = Object.values(arguments);
    return (args.filter(x=> x===null || !x)).length<=0
}
console.log(validateAttrs('1',2, 3, 4));
console.log(validateAttrs('1',2, 3, null));
console.log(validateAttrs('1',undefined, 3, 4));
console.log(validateAttrs('1',2, '', 4));
console.log(validateAttrs('1',2, 3, null));
avatar
ParthoShuvo
23 июня 2020 в 10:03
1

Попробуйте Boolean () и isNaN () (для числового типа), чтобы проверить, есть ли у переменной значение или нет.

function isEmpty(val) {
  return typeof val === 'number' ? isNaN(val) : !Boolean(val);
}

var emptyVals = [undefined, null, false, NaN, ''];
emptyVals.forEach(v => console.log(isEmpty(v)));
avatar
Hassan Ali Shahzad
2 июня 2020 в 14:18
2
function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

он также будет проверять пробелы ('') вместе со следующим:

  • null, undefined, NaN, empty, string (""), 0, false
avatar
piyush nath
11 мая 2020 в 18:32
-5

вы всегда можете использовать функции loadash, такие как _.nil или _.undefined. Они довольно удобны в использовании.

Aurovrata
21 сентября 2020 в 08:53
0

ваш ответ бесполезен, поскольку в нем нет ссылок на документацию по указанным вами функциям.

avatar
Kamil Kiełczewski
11 мая 2020 в 09:10
6

Вероятно, самый короткий ответ -

val==null || val==''

если вы измените правую сторону на val==='', тогда пустой массив даст false. Доказательство

function isEmpty(val){
    return val==null || val==''
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

Подробнее о == (источник здесь)

Enter image description here

БОНУС : причина, по которой === более понятна, чем ==

Enter image description here

Чтобы писать ясно и легко понятный код, используйте явный список допустимых значений

val===undefined || val===null || val===''|| (Array.isArray(val) && val.length===0)

function isEmpty(val){
    return val===undefined || val===null || val==='' || (Array.isArray(val) && val.length===0)
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE
viam0Zah
21 июня 2020 в 20:36
0

Полезная визуализация! Каков их источник?

Kamil Kiełczewski
21 июня 2020 в 20:45
1

@ viam0Zah ссылка на источник находится под фрагментом -> (source here)

avatar
Sunny Sultan
6 мая 2020 в 10:14
2

Необязательный оператор цепочки предоставляет способ упростить доступ к значениям через подключенные объекты, когда возможно, что ссылка или функция могут быть неопределенными или нулевыми.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

Оператор объединения с нулевым значением может использоваться после необязательного связывания для построения значения по умолчанию, когда ничего не найдено:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city
avatar
Sean Bannister
21 апреля 2020 в 18:28
1

Большинство существующих ответов не удалось для моего варианта использования, большинство из них вернулось пустым, если функция была назначена переменной или если было возвращено NaN. Паскаль дал хороший ответ.

Вот моя реализация, пожалуйста, протестируйте и дайте мне знать, если найдете что-нибудь. Вы можете увидеть, как я тестировал эту функцию здесь.

function isEmpty(value) {
  return (
    // Null or undefined.
    (value == null) ||
    // Check if a Set() or Map() is empty
    (value.size === 0) ||
    // NaN - The only JavaScript value that is unequal to itself.
    (value !== value) ||
    // Length is zero && it's not a function.
    (value.length === 0 && typeof value !== "function") ||
    // Is an Object && has no keys.
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Возвращает:

  • верно: undefined, null, "", [], {}, NaN, new Set(), <6391070>
  • ложь: true, false, 1, 0, -1, "foo", <639107027107027627>, <639107027107027627>,
avatar
Shahid Hussain Abbasi
16 апреля 2020 в 06:39
1

Ниже сработало для меня. Сделайте небольшое изменение, чтобы ускорить работу

function isEmpty(obj) {
    if (!obj) return true;
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
}
avatar
Pascal Polleunus
29 марта 2020 в 00:45
2

Код на GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Тесты для бедных ????

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Результаты теста:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]
Sean Bannister
21 апреля 2020 в 18:30
0

отличная функция, у всех других ответов здесь было несколько проблем, которые, похоже, решает ваш, мне просто жаль, что я не нашел его до того, как написал свой собственный: p подумал, что вы могли бы взглянуть на мою работу coderhelper .com / questions / 5515310 /… обе наши функции, похоже, имеют одинаковый результат, но я немного сократил код. Пожалуйста, дайте мне знать, если я что-то пропустил.

Pascal Polleunus
23 апреля 2020 в 02:43
0

👍 Вы пробовали мои «Тесты для бедняков»? Я думаю, что закончил тем, что добавил больше тестов в функцию для особых случаев, таких как Map, WeakMap и, возможно, также Date, RegExp. Вы уверены в своем value.constructor === Object? Проверь это.

Sean Bannister
23 апреля 2020 в 09:01
0

Да, я проводил ваши тесты, спасибо за них, обе наши функции возвращают одинаковые результаты с обоими нашими тестами. Я все время думаю, не упускаю ли я чего-то, кроме этих тестовых примеров. Я считаю, что value.constructor === Object в порядке, в javascript операторы IF OR имеют порядок выполнения, поэтому оператор OR будет выполняться только в том случае, если предыдущий не вернул TRUE, и мы уже проверили для Null. Фактически, единственная цель этого последнего оператора OR - обнаружить {} и убедиться, что он не возвращает TRUE для вещей, которых не должен.

avatar
Daniel Delgado
9 марта 2020 в 19:28
17

Обратите внимание на новый ECMAScript нулевой оператор объединения

Вы можете рассматривать эту функцию - оператор ?? - как способ «вернуться» к значению по умолчанию при работе с null или undefined.

let x = foo ?? bar();

Опять же, приведенный выше код эквивалентен следующему.

let x = (foo !== null && foo !== undefined) ? foo : bar();
avatar
Narasimha Reddy - Geeker
9 января 2020 в 11:13
0

Это также относится к пустому массиву и пустому объекту

null, undefined, '', 0, [], {}

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));
avatar
yaserso
24 октября 2019 в 06:26
2

Если вы хотите избежать получения истины, если значение имеет одно из следующих значений, согласно ответу jAndy:

  • ноль
  • не определено
  • NaN
  • пустая строка ("")
  • 0
  • ложь

Одно из возможных решений, позволяющих избежать получения истинных значений:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Он будет использоваться следующим образом:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

В дополнение к этим сценариям вы можете захотеть вернуть false, если объект или массив пуст:

  • Объект: {} (с использованием ECMA 7+)
  • Массив: [] (с использованием ECMA 5+)

Вы бы сделали это так:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Если вы хотите проверить все строки с пробелами (""), вы можете сделать следующее:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Примечание: hasOwnProperty возвращает true для пустых строк, 0, false, NaN, null и undefined, если переменная была объявлена ​​как любая из них, поэтому ее использование может быть не лучшим. Функцию можно изменить, чтобы использовать ее, чтобы показать, что она была объявлена, но ее нельзя использовать.

avatar
Gershom Maes
26 августа 2019 в 15:32
9

Пустота

Я не рекомендую пытаться определять или использовать функцию, которая вычисляет, является ли какое-либо значение во всем мире пустым. Что на самом деле значит быть «пустым»? Если у меня let human = { name: 'bob', stomach: 'empty' }, должен ли isEmpty(human) вернуть true? Если у меня let reg = new RegExp('');, должен ли isEmpty(reg) вернуть true? А как насчет isEmpty([ null, null, null, null ]) - в этом списке только пустота, значит, сам список пуст? Я хочу выдвинуть здесь несколько замечаний о «бессодержательности» (намеренно неясное слово, чтобы избежать ранее существовавших ассоциаций) в javascript - и я хочу утверждать, что «бессодержательность» в значениях javascript никогда не следует рассматривать в общих чертах.


Истина / Ложь

Чтобы решить, как определить «бессодержательность» значений, нам нужно учесть встроенное в javascript внутреннее понимание того, являются ли значения «правдивыми» или «ложными». Естественно, что и null, и undefined являются "ложными". Менее естественно, что число 0 (и никакое другое число, кроме NaN) также является "ложным". Наименее естественно: '' ложно, но [] и {}new Set(), и new Map()) правдивы - хотя все они кажутся одинаково бессмысленными!


Нулевое против неопределенного

Существует также некоторая дискуссия по поводу null и undefined - действительно ли нам нужно и то, и другое, чтобы выразить пустоту в наших программах? Я лично избегаю того, чтобы буквы u, n, d, e, f, i, n, e, d появлялись в моем коде именно в таком порядке. Я всегда использую null для обозначения «пустоты». И снова, однако, нам нужно учитывать присущее javascript чувство того, как null и undefined различаются:

  • Попытка получить доступ к несуществующему свойству дает undefined
  • Пропуск параметра при вызове функции приводит к получению этого параметра undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());
  • Параметры со значениями по умолчанию получают значение по умолчанию, только если задано undefined, а не null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Для меня null явный признак пустоты; «то, что могло быть заполнено, было намеренно оставлено пустым».

На самом деле undefined является необходимым усложнением, которое позволяет некоторым функциям js существовать, но, на мой взгляд, его всегда следует оставлять за кадром; не взаимодействует напрямую с . Мы можем думать о undefined как, например, о механизме javascript для реализации аргументов функции по умолчанию. Если вы воздержитесь от предоставления аргумента функции, вместо этого она получит значение undefined. И значение по умолчанию будет применено к аргументу функции, если этот аргумент изначально был установлен на undefined. В этом случае undefined является стержнем аргументов функции по умолчанию, но он остается в фоновом режиме: мы можем добиться функциональности аргументов по умолчанию, даже не обращаясь к undefined:

Это плохая реализация аргументов по умолчанию, поскольку она напрямую взаимодействует с undefined:

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

Это хорошая реализация:

let fnWithDefaults = (arg='default') => { ... };

Это плохой способ принять аргумент по умолчанию:

fnWithDefaults(undefined);

Просто сделайте это:

fnWithDefaults();

Необычная пустота

Я считаю, что с пустотой никогда нельзя разбираться в общих чертах. Вместо этого мы всегда должны проявлять строгость, чтобы получить больше информации о наших данных, прежде чем определять, являются ли они пустыми - я в основном делаю это, проверяя, с каким типом данных я имею дело:

let isType = (value, Cls) => {
  // Intentional use of loose comparison operator detects `null`
  // and `undefined`, and nothing else!
  return value != null && Object.getPrototypeOf(value).constructor === Cls;
};

Обратите внимание, что эта функция игнорирует полиморфизм - она ​​ожидает, что value будет прямым экземпляром Cls, а не экземпляром подкласса Cls. Я избегаю instanceof по двум основным причинам:

  • ([] instanceof Object) === true («Массив - это объект»)
  • ('' instanceof String) === false («Строка не является строкой»)

Обратите внимание, что Object.getPrototypeOf используется, чтобы избежать такого случая, как let v = { constructor: String };. Функция isType по-прежнему правильно возвращает для isType(v, String) (ложь) и isType(v, Object) (истина).

В целом, я рекомендую использовать эту функцию isType вместе с этими советами:

  • Минимизировать количество значений обработки кода неизвестного типа. Например, для let v = JSON.parse(someRawValue); наша переменная v теперь имеет неизвестный тип. Как можно раньше мы должны ограничить наши возможности. Лучший способ сделать это - запросить конкретный тип: например, if (!isType(v, Array)) throw new Error('Expected Array'); - это действительно быстрый и выразительный способ удалить общий характер v и убедиться, что это всегда Array. Однако иногда нам нужно разрешить v быть нескольких типов. В этих случаях мы должны как можно раньше создавать блоки кода, в которых v больше не является универсальным:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}
  • Всегда используйте «белые списки» для проверки. Если вам требуется, чтобы значение было, например a String, Number или Array, проверьте эти 3 «белых» возможности и выдайте ошибку, если ни один из 3 не удовлетворен. Мы должны увидеть, что проверка на «черные» возможности не очень полезна: скажем, мы пишем if (v === null) throw new Error('Null value rejected'); - это отлично для того, чтобы гарантировать, что значения null не пройдут, но если значение выживает, мы до сих пор почти ничего об этом не знаем. Значение v, которое проходит эту нулевую проверку, по-прежнему является ОЧЕНЬ универсальным - это что угодно, кроме null ! Черные списки вряд ли устранят универсальность.
  • Если значение не равно null, никогда не рассматривайте «пустое значение». Вместо этого рассмотрите «пустой X». По сути, никогда не думайте о том, чтобы делать что-то вроде if (isEmpty(val)) { /* ... */ } - независимо от того, как реализована эта функция isEmpty (я не хочу знать ...), это не бессмысленно! И это слишком банально! Пустоту следует рассчитывать только с учетом типа val. Проверка на пустоту должна выглядеть так:
    • «Строка без символов»: if (isType(val, String) && val.length === 0) ...

    • «Объект с 0 реквизитами»: if (isType(val, Object) && Object.entries(val).length === 0) ...

    • «Число, равное или меньшее нуля»: if (isType(val, Number) && val <= 0) ...

    • «Массив без элементов»: if (isType(val, Array) && val.length === 0) ...

    • Единственное исключение - когда null используется для обозначения определенных функций. В этом случае имеет смысл сказать: «Пустое значение»: if (val === null) ...

Rui Marques
6 мая 2020 в 09:35
0

Я вижу, вы над этим задумались:>

Lewis
15 сентября 2021 в 14:21
0

Это блестящий ответ, заслуживающий еще большей любви!

avatar
Alexandre Magro
12 декабря 2018 в 21:46
24

Решение, которое мне очень нравится:

Давайте определим, что пустая переменная - это null или undefined, или, если она имеет длину, она равна нулю, или, если это объект, у нее нет ключей:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Возвращает:

  • истина: undefined, null, "", [], {}
  • ложь: true, false, 1, 0, -1, "foo", <258489526954189>
avatar
cubefox
4 декабря 2018 в 12:44
7
return val || 'Handle empty variable'

- действительно хороший и чистый способ справиться с этим во многих местах, также может использоваться для присвоения переменных

const res = val || 'default value'
Molomby
20 марта 2019 в 00:42
0

Много мест, но не тогда, когда по умолчанию true и вы пытаетесь предоставить или вернуть val из false.

cubefox
21 марта 2019 в 13:50
0

@Molomby, это очень специфический крайний случай, но даже с ним легко справиться const res = falsyValue ? true : falsyValue

avatar
nobjta_9x_tq
1 октября 2018 в 03:42
0
try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

Я думаю, что использование try catch позволит избежать ошибок нулевой проверки, в том числе в Angular или JavaScript. Просто перехватывает нулевое исключение и обрабатывает его.

Harsha Biyani
1 октября 2018 в 06:30
1

Еще полезнее было бы включить объяснение того, что делает ваш код и почему он отвечает на вопрос. Публикация только кода иногда может быть неясной.

Gufran Hasan
1 октября 2018 в 08:00
0

Вы должны добавить объяснение, чтобы обосновать свой ответ.

nobjta_9x_tq
1 октября 2018 в 10:26
0

Я попытался написать код на Angular с некоторыми решениями в этом вопросе, но увидел, что try catch - безопасный способ обработки в этом случае: D

avatar
BlackBeard
28 июня 2018 в 15:33
4

Если вы используете TypeScript и не хотите учитывать значения , это false ", то это решение для вас:

Первый: import { isNullOrUndefined } from 'util';

Тогда: isNullOrUndefined(this.yourVariableName)

Обратите внимание: как упоминалось ниже ниже, теперь это устарело, используйте вместо него value === undefined || value === null. ссылка.

atomictom
2 октября 2018 в 22:16
2

Я подумал, что это круто, поэтому изначально я не голосовал, но это устаревшая вещь из Node.js. В файле определений типов указано: /** @deprecated since v4.0.0 - use "value === null || value === undefined" instead. */

BlackBeard
3 октября 2018 в 03:09
0

@atomictom Я думал, что это вещь typescript. Не могли бы вы предоставить ссылку на его документацию?

atomictom
4 октября 2018 в 20:21
0

Здесь: nodejs.org/api/util.html#util_util_isnullorundefined_object. Также: «Я подумал, что это круто, поэтому я изначально проголосовал за », которое должно читаться :)

ticktock
21 января 2020 в 22:01
0

Зачем им осуждать такую ​​полезную простую вещь, как эта? гэээээээээээээ.

avatar
jales cardoso
18 мая 2018 в 13:08
5
function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

В ES6 с обрезкой для обработки строк с пробелами:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}
Fabian von Ellerts
5 октября 2018 в 12:44
1

отличная функция, спасибо! обрабатывает все типы значений - во всех других решениях числа не учитываются!

TylerH
5 октября 2018 в 13:52
1

@FabianvonEllerts Пожалуйста, не пытайтесь редактировать дополнительный код в чужом ответе. Опубликуйте его как свой собственный ответ, как комментарий под ответом или попросите в комментарии, чтобы они сами обновили ответ.

avatar
Ravikant
8 мая 2018 в 09:44
4

Попробуйте с другой логикой . Вы можете использовать приведенный ниже код для проверки всех четырех (4) условий для проверки, таких как not null, not blank, not undefined и not zero, используйте только этот код (! (! (Переменная))) в javascript и jquery.

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}
avatar
jonathan klevin
29 марта 2018 в 07:50
0

Вы можете напрямую использовать оператор равенства

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

демонстрация @ Как определить, является ли переменная неопределенной или нулевой с помощью JavaScript

avatar
GorvGoyl
28 февраля 2018 в 12:41
-1

Эта функциональная проверка для empty object {}, empty array [], null, undefined и blank string ""

function isEmpty(val) {
  //check for empty object {}, array []
  if (val !== null && typeof val === 'object') {
    if (Object.keys(obj).length === 0) {
      return true;
    }
  }
  //check for undefined, null and "" 
  else if (val == null || val === "") {
    return true;
  }
  return false;
}

var val = {};
isEmpty (val) -> истина
val = [];
isEmpty (val) -> истина
isEmpty (undefined) -> истина
isEmpty (null) -> истина
isEmpty ("") -> истина
isEmpty (false) -> false
isEmpty (0) -> ложь

avatar
ddagsan
13 декабря 2017 в 06:09
5

Это может быть полезно.

Все значения в массиве представляют то, чем вы хотите быть (null, undefined или что-то еще), и вы ищите в нем то, что хотите.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
JoshKisb
6 января 2018 в 19:07
2

не могли бы вы объяснить, пожалуйста. что там происходит

ddagsan
11 декабря 2018 в 12:07
0

Массив содержит некоторую переменную, которую вы считали пустой.

ddagsan
14 июня 2019 в 10:29
0

@JoshKisb все значения в массиве представляют собой то, чем вы хотите быть (null, undefined или что-то еще), и вы ищите в нем то, что хотите.

Nick
14 июня 2019 в 10:32
1

@ddagsan Хотя JoshKisb может оценить ваш ответ, вам следует поместить объяснение в свой ответ, а не в комментарии

avatar
centurian
2 декабря 2017 в 09:27
2

Для всех, кто приходит сюда, чтобы задать аналогичный вопрос, замечательно работает следующее, и последние годы оно у меня есть в моей библиотеке:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://coderhelper.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));
avatar
Keith Blanchard
20 июня 2017 в 20:44
2
var myNewValue = myObject && myObject.child && myObject.child.myValue;

Это никогда не вызовет ошибки. Если myObject , дочерний или myValue имеет значение null, то myNewValue будет иметь значение null. Ошибок не будет.

avatar
Luca C.
2 июня 2017 в 08:30
2
function isEmpty(val){
    return !val;
}

, но это решение чрезмерно спроектировано, если вы не хотите изменять функцию позже для нужд бизнес-модели, тогда лучше использовать ее непосредственно в коде:

if(!val)...
avatar
Mark Giblin
10 марта 2017 в 09:57
0

Несмотря на то, что они старые, они забывают, что они должны обернуть свой кодовый блок, а затем перехватить ошибку, а затем проверить ...

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

Таким образом, вам действительно не нужно заранее проверять наличие потенциальной проблемы, вы просто ее обнаруживаете, а затем решаете, как хотите.

avatar
Hriju
6 октября 2016 в 11:18
-3

В моем случае я пробовал использовать переменную if null, '',!, Но это не сработало.

См. Мой код ниже, чтобы получить текст из поля html

var status=$(this).text(); //for example (for my case)

если в переменной состояния не было значения (текста), я пытался установить значение «novalue» для переменной состояния.

следующий код работал.

if(status == false)
{
   status='novalue';
} 

когда не было найдено текста для переменной satus, приведенный выше код присвоил переменной статуса 'novalue'

Hriju
14 марта 2018 в 04:33
0

действительно хотел бы знать, почему это получает голоса против? это было бы действительно полезно. Если вы голосуете против, объясните, почему вы считаете этот ответ неправильным.

John Smith
11 февраля 2019 в 10:27
0

Думаю, это не совсем ответ на вопрос. Вы объясняете возникшую у вас проблему, но уже было хорошее решение вопроса кем-то еще за много лет до того, как вы на него ответили.

avatar
rickdog
3 сентября 2016 в 21:49
1

Это проверит, не определена ли переменная неопределенной вложенности

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

Вышеупомянутое проверяет, существует ли функция перевода Google TranslateElement. Это эквивалентно:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {
avatar
Pedro Pereira
30 июня 2016 в 09:31
0

Думаю, с помощью? оператор немного чище.

var ? function_if_exists() : function_if_doesnt_exist();
avatar
Yash
5 октября 2015 в 06:51
5

Чтобы проверить значение по умолчанию

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

Результат проверки:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Я использовал функцию @Vix (), чтобы проверить объект, какого типа.

с использованием экземпляра «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        
Yash
25 января 2016 в 10:20
0

Операторы сравнения проверяют == [Данные]. === [Data, Type Of Object] JS-числа всегда хранятся как числа с плавающей запятой двойной точности в соответствии с международным стандартом IEEE 754. // Number Type [int, float literals ] var int = 77; var float = 77.7; console.log( int.toFixed(10) + '\t' + float.toFixed(10) ); // Object Type var number = new Number( 77 ); if( int != float ) console.log('Data Not Equal'); if( int == number && int !== number ) console.log('Data is Equal & Types vary');

avatar
l3x
21 августа 2015 в 13:39
9

Если вы предпочитаете простой JavaScript, попробуйте следующее:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

В противном случае, если вы уже используете подчеркивание или lodash, попробуйте:

_.isEmpty(value)
crmprogdev
22 октября 2015 в 18:58
3

Пробовали ваш код. Я получаю сообщение об ошибке в консоли: «Ошибка неперехваченной ссылки: isArray () не определена». В противном случае было бы здорово, если бы это сработало.

Snixtor
29 мая 2016 в 02:07
11

По крайней мере, в случае lodash, _.isNil - это функция, которую вы ищете, а не _.isEmpty. документация isNil, документация isEmpty

kalyanbk
24 апреля 2017 в 19:28
1

Это не сработает, если значение логическое и имеет значение true.

GFoley83
15 октября 2017 в 19:49
3

Обычный JavaScript не имеет функций isArray или isString на window.

l3x
5 ноября 2017 в 21:45
0

@ GFoley83 - Вы меня поймали! У меня есть причины не использовать Windows. На самом деле я затрагиваю эту тему в главе, в которой рассказывается об истории и развитии языков программного обеспечения. Более релевантной информацией, вероятно, будет обсуждение / код, демонстрирующий обработку монадических ошибок в моей книге «Изучение функционального программирования в Go». Ваше здоровье!

Ry-
4 апреля 2019 в 15:01
3

@ l3x: Это шутка?

avatar
JerryP
1 мая 2015 в 21:01
22

Проверка этого условия

if (!!foo) {
    //foo is defined
}

- это все, что вам нужно.

Daan van Hulst
28 июня 2017 в 07:38
1

Я предполагаю, что это всего лишь отрывок. Но if уже выполняет проверку на ложность, которая просто преобразуется в логическое значение. Ловит ли какие-то случаи, которые нормальный if(foo) не ловит?

Ben Kolya Mansley
23 января 2018 в 20:01
1

Это идеально подходит, когда вам нужно что-то встроенное, например, мне нужен атрибут реакции (называемый активным), который истинен, когда строка не пуста - оператор if был бы излишним, поэтому я могу просто использовать active={!!foo}

Gorky
22 июня 2020 в 05:36
9

Если foo не равно 0

avatar
Vix
12 февраля 2015 в 10:32
31

Вы можете найти следующую функцию полезной:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Или в ES7 (прокомментируйте дальнейшие улучшения)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Результаты:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

«Обратите внимание на то, что оператор связывания (: :) не является частью ES2016 (ES7) или какой-либо более поздней редакции стандарта ECMAScript. В настоящее время это предложение стадии 0 (соломинка) для внедрения в язык». - Саймон Челлберг. автор хочет добавить, что поддерживает это прекрасное предложение получить царское вознесение.

Yash
5 октября 2015 в 06:58
0

+1 полезно знать объект типа 'regexp', 'array' и 'function'

GollyJer
3 сентября 2017 в 04:26
0

@Vix, а чем версия ES7 лучше?

Vix
3 сентября 2017 в 13:37
0

Это не так, я экспериментировал с более удобочитаемыми способами выражения той же функциональности, используя: назначение деструктурирования, оператор связывания.

Simon Kjellberg
12 февраля 2018 в 18:54
4

Обратите внимание, что оператор привязки (::) вообще не является частью ES2016 (ES7) или какой-либо более поздней редакции стандарта ECMAScript. В настоящее время это предложение на стадии 0 (соломенный) для ознакомления с языком.

avatar
Arif
23 января 2015 в 06:56
19

! проверьте наличие пустых строк (""), null, undefined, false, а также числа 0 и NaN. Скажем, если строка пуста, <451856696838566968> тогда <45818 > возвращает true.

function isEmpty(val){
  return !val;
}

эта функция вернет истину, если val равно пусто, null, undefined, false, число 0 или NaN .

ИЛИ

В соответствии с вашим проблемным доменом вы можете просто использовать, например, !val или !!val.

Corey Young
14 января 2016 в 18:09
0

На самом деле это не говорит о том, пуста ли переменная, поскольку false и 0 могут быть допустимыми значениями, а не представлять собой пустое значение. Ценность функции isEmpty - убедиться, что ожидаемые вами пустые значения возвращают истину. на мой взгляд, значения null, undefined, NaN и пустая строка имеют смысл как пустые.

Allen Linatoc
15 апреля 2016 в 00:44
12

Зачем использовать isEmpty(val), если можно просто сделать !val?

Arif
16 апреля 2016 в 09:09
0

Это тебе решать. Вы можете использовать его для повышения читабельности. В противном случае, если вы думаете, что команда, с которой вы работаете, является более продвинутым кодировщиком, вы можете использовать только !val или !!val в зависимости от вашей проблемной области.

avatar
krupar
19 марта 2014 в 13:23
27

Первый ответ с лучшей оценкой неверен. Если значение не определено, в современных браузерах будет выдано исключение. Вы должны использовать:

if (typeof(value) !== "undefined" && value)

или

if (typeof value  !== "undefined" && value)
Oskar Szura
15 октября 2014 в 14:09
3

эээ ... Я думаю, это неправильно, так как если (значение) достаточно (кроме пустых объектов / массивов). если значение равно 'undefined', подтверждение 'if' не пройдет.

Qantas 94 Heavy
16 января 2015 в 14:04
4

Это объединяет переменные, которые не определены (которые вызывают ошибку ReferenceError при оценке), которые отличаются от переменных со значением undefined.

shaosh
6 июня 2015 в 00:51
2

У меня такая же ошибка. if (x), if (! x), if (!! x) выдаст ошибку, если x не определен.

Madbreaks
1 февраля 2018 в 00:53
0

if(value === 0) gameOver();;)

Madbreaks
1 февраля 2018 в 01:02
0

Этот ответ также неверен, потому что он возвращает false, когда value равно нулю, что составляет , а не то, что ищет op.

Ranjith Kumar
27 июля 2020 в 09:47
0

Прочтите @ Qantas94Heavy комментарий, который прояснит эту путаницу. Мы получаем исключение при обращении к переменной, которая не определена. Но здесь переменная определена, а не определено только значение.

avatar
DavidWainwright
12 февраля 2014 в 15:45
11

Вот мой - возвращает true, если значение null, undefined и т. Д. Или пустое (т.е. содержит только пробелы):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}
RationalRabbit
30 января 2020 в 10:43
1

Здесь я проверил несколько методов. С проверкой на undefined ваша функция отлично работает. Поэтому я использую if (typeof value! == 'undefined' &&! IsEmpty (value)) ИЛИ, если вы действительно хотите проверить на пустоту, вы можете использовать if (typeof value === 'undefined' || IsEmpty2 (value) ). Это будет работать для null; Неопределенный; 0; ""; ""; ложный

avatar
guya
10 ноября 2013 в 16:13
60

Это самый безопасный чек, и я еще не видел, чтобы он размещался здесь именно так:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

Он будет охватывать случаи, когда значение никогда не определялось, а также любой из этих случаев:

  • ноль
  • undefined (значение undefined не совпадает с параметром, который никогда не определялся)
  • 0
  • "" (пустая строка)
  • ложь
  • NaN

Отредактировано: изменено на строгое равенство (! ==), потому что сейчас это норма;)

J.Steve
4 декабря 2013 в 08:45
10

Я не отрицал, но что касается строгого сравнения на равенство, общее правило состоит в том, что если вам не требуется неявное преобразование типа , следует использовать строгое сравнение.

guya
7 декабря 2013 в 22:11
3

Спасибо за ваш комментарий, Стив. Это общее правило вполне нормально. Я просто ожидаю, что люди поймут, почему они используют то или иное. Как бы вы ни выглядели, люди будут рады проповедовать вам о том, что «всегда используйте строгое» - как будто это самая важная вещь в Javascript. Я видел слишком много случаев, таких как if (val! == null) , которые, очевидно, приводят к нежелательному результату. Можно сказать, что сомневаешься - пользуйся строгим, но лучше не сомневаться.

Bryan Downing
10 октября 2014 в 02:10
6

Я думаю, дело здесь в том, что мы ожидаем, что оператор typeof вернет строку, поэтому использование строгой проверки на равенство технически точнее, точнее и быстрее. Так что на самом деле нет причин использовать вольное сравнение, ни наоборот. Также val !== null совершенно справедливо во многих случаях - я делаю это все время. Я согласен с вашим аргументом несоответствия, но я думаю, что это плохой пример. Не пытаюсь тебя троллить.

guya
11 октября 2014 в 02:26
0

Спасибо за ваш комментарий, Брайан, вы используете val! == null, потому что знаете, что делаете. Новичку захочется вернуться к тому моменту, когда val является ложным. Но val никогда не будет нулевым, оно будет неопределенным. Если бы он только не прислушивался к совету «всегда соблюдать строгость», у него было бы меньше ошибок. Я видел, как это происходит в производственном коде. typeof всегда возвращает строку, и разница в скорости будет избыточной. Итак, единственный аргумент в пользу использования strict в приведенном выше случае - это согласованность. Я сказал: «Нет необходимости в строгом равенстве». Это не означает, что вы не можете этого сделать, если хотите, или если это сделает ваш код более последовательным.

rmcsharry
1 декабря 2020 в 23:31
2

@guya Это заслуживает голосования просто за редактирование спустя 7 лет! Особенно с учетом вышеупомянутого обсуждения в тот день;) Престижность, сэр!

Lucio Crusca
6 июля 2021 в 11:17
1

Я считаю, что это наиболее читаемый код. Среди всех ответов этот должен быть принятым.

avatar
herostwist
1 апреля 2011 в 15:25
6

Если переменная не была объявлена, вы не сможете проверить значение undefined с помощью функции, потому что вы получите сообщение об ошибке.

if (foo) {}
function (bar) {}(foo)

Оба сгенерируют ошибку, если foo не был объявлен.

Если вы хотите проверить, была ли объявлена ​​переменная, вы можете использовать

typeof foo != "undefined"

, если вы хотите проверить, был ли объявлен foo и имеет ли оно значение, вы можете использовать

if (typeof foo != "undefined" && foo) {
    //code here
}
avatar
tcooc
1 апреля 2011 в 15:21
18

Вы немного переусердствовали. Чтобы проверить, не присвоено ли переменной значение, вам нужно только проверить на undefined и null.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Предполагается, что 0, "" и объекты (даже пустой объект и массив) являются допустимыми «значениями».

avatar
Salman A
1 апреля 2011 в 15:20
274

Подробный метод проверки, является ли значение неопределенным или нулевым:

return value === undefined || value === null;

Вы также можете использовать оператор ==, но при этом предполагается, что кто-то знает все правила:

return value == null; // also returns true if value is undefined
Christiaan Westerbeek
3 июля 2014 в 11:46
35

Проверить только null или undefined можно так: if (value == null). Обратите внимание на оператор ==, который принуждает. Если вы проверите вот так if (value === null || value === undefined), вы забыли / не знаете, как Javascript принудительно выполняет. webreflection.blogspot.nl/2010/10/…

Salman A
7 июля 2014 в 04:02
38

@ChristiaanWesterbeek: ваша точка зрения, что arg == null дает те же результаты, что и arg === undefined || arg === null. Однако я считаю последний пример более читабельным.

Bryan Downing
10 октября 2014 в 01:56
11

По моему опыту, arg == null довольно часто встречается.

x0n
19 января 2016 в 05:09
9

return value === (void 0) безопаснее, чем тестирование с undefined, который, к сожалению, вполне может быть допустимой переменной по объему.

Sharky
17 октября 2016 в 07:31
0

@ChristiaanWesterbeek, тогда почему это приводит к ошибке ссылки? jsfiddle.net/00rb295d

Christiaan Westerbeek
17 октября 2016 в 08:51
0

@Sharky Потому что переменная не объявлена. Используйте typeof, если вы даже не знаете, объявили ли вы переменную. См. Принятый ответ для получения более подробной информации.

Sharky
17 октября 2016 в 09:57
0

@ChristiaanWesterbeek, тогда ваш первоначальный комментарий неверен.

Christiaan Westerbeek
17 октября 2016 в 10:22
4

@Sharky Существует разница между неопределенной переменной и необъявленной переменной: lucybain.com/blog/2014/null-undefined-undeclared

avatar
Mike Samuel
1 апреля 2011 в 15:19
105
function isEmpty(value){
  return (value == null || value.length === 0);
}

Это вернет истину для

undefined  // Because undefined == null

null

[]

""

и функции с нулевым аргументом, поскольку length функции - это количество объявленных параметров, которые она принимает.

Чтобы запретить последнюю категорию, вы можете просто проверить наличие пустых строк

function isEmpty(value){
  return (value == null || value === '');
}
Ian Boyd
22 февраля 2014 в 15:06
11

undefined == null но undefined !== null

Corey Young
14 января 2016 в 18:03
3

@IanBoyd, потому что вы сравниваете == с ===. это означает, что undefined == null (true) undefined! = null (false) undefined === null (false) undefined! == null (true) было бы лучше дать немного больше информации, чтобы быть полезным и подтолкнуть людей в правильном направлении. moz doc о различии developer.mozilla.org/en-US/docs/Web/JavaScript/…