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

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

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

if( value ) {
}

будет вычисляться , trueесли valueэто не :

• значение NULL
• не определено
• NaN
• пустой строкой ("")
• 0
• ложный

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

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

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

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

Далее читайте: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

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

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

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

return value == null; // also returns true if value is undefined

function isEmpty(value){
  return (value == null || value.length === 0);
}

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

undefined  // Because undefined == null

null

[]

""

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

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

function isEmpty(value){
  return (value == null || value === '');
}

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

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

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

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

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

Вам может пригодиться следующая функция:

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 (strawman) для введения в язык». - Саймон Кьельберг. Автор хотел бы добавить свою поддержку этого прекрасного предложения получить королевское вознесение.

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

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

или

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

Это условие проверки

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

это все, что тебе нужно.

! проверьте наличие пустых строк (""), нулевых, неопределенных, ложных и числа 0 и NaN. Скажем, если строка пуста, var name = ""то console.log(!name)возвращается true.

function isEmpty(val){
  return !val;
}

эта функция возвращает истину , если вал является пустым, пустым, не определено, ложь, число 0 или NaN .

ИЛИ

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

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

Давайте определим, что пустая переменная равна 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", [1, 2, 3],{ foo: 1 }

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

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

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

Если вы предпочитаете простой 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)

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

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

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

const res = val || 'default value'

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

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

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

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

typeof foo != "undefined"

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

if (typeof foo != "undefined" && foo) {
    //code here
}

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

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 () для проверки объекта какого типа.

используя instansof «

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]"        

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
}

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

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

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

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

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

Затем: isNullOrUndefined(this.yourVariableName)

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

вырожденность

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

Truthiness / Falsiness

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

Нулевой и неопределенный

Существует также некоторая дискуссия относительно nullvs 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));

Неуниверсальная бессмысленность

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

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

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

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

Обратите внимание , что Object.getPrototypeOfиспользуется , чтобы избежать случая , как функция по- прежнему возвращает правильно для (ложь), и (истина).let v = { constructor: String };isTypeisType(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');
}

• Всегда используйте «белые списки» для проверки. Если вам требуется, чтобы значением было, например, String, Number или Array, проверьте эти 3 «белые» возможности и выведите Error, если ни один из 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) ...

Попробуйте с другой логикой . Вы можете использовать приведенный ниже код для проверки всех четырех (4) условий для проверки, например, не ноль, не пустой, не неопределенный и не ноль, используйте только этот код (! (! (Variable))) только в 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);
    }
}

Взгляните на новый оператор объединения ECMAScript Nullish

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

let x = foo ?? bar();

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

let x = (foo !== null && foo !== undefined) ? foo : bar();

function isEmpty(val){
    return !val;
}

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

if(!val)...

var myNewValue = myObject && myObject.child && myObject.child.myValue;

Это никогда не выдаст ошибку. Если myObject , child или myValue равно нулю, то myNewValue будет равно нулю. Ошибки не будут выброшены

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

(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://stackoverflow.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));

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

• значение NULL
• не определено
• 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, если переменная была объявлена ​​как любая из них, поэтому ее использование может быть не лучшим. Функция может быть изменена, чтобы использовать ее, чтобы показать, что она была объявлена, но ее нельзя использовать.

Код на 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]

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

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 Translate для TranslateElement. Это эквивалентно:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

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

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

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

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

• null, undefined, NaN, пусто, строка (""), 0, false

Я думаю, используя? Оператор немного чище.

var ? function_if_exists() : function_if_doesnt_exist();