Ответ 1

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

if( value ) {
}

оценивает true, если value не:

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

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

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

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

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

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

Ответ 2

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

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

Вы также можете использовать оператор == но это позволяет узнать все правила:

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

Ответ 3

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

Это вернет true для

undefined  // Because undefined == null

null

[]

""

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

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

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

Ответ 4

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

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

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

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

PS нет необходимости строгого равенства в значении typeof! = 'Undefined'

Ответ 5

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

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

Ответ 6

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

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

или

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

Ответ 7

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

function isEmpty(val){
  return !val;
}

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

ИЛИ ЖЕ

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

Ответ 8

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

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

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

Ответ 9

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

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

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

Ответ 10

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

Ответ 11

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

function stringIsEmpty(value) {

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

}

Ответ 12

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

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

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

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

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

Returns:

• true: undefined, null, "", [], {}
• false: true, false, 1, 0, -1, "foo", [1, 2, 3], { foo: 1 }

Ответ 13

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

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

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

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

typeof foo != "undefined"

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

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

Ответ 14

Это очень простой.

if(data) {
  //Comes inside only if the data is not empty and not null 
}

Ответ 15

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

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

Ответ 16

return val || 'Handle empty variable'

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

const res = val || 'default value'

Ответ 17

вы можете использовать:

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

if (someVar.value) 
{
  //its not emppty
}
else
{
  //Its empty
}

Ответ 18

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

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

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

Ответ 19

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
}

Ответ 20

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

Ответ 21

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

Во-первых: import { isNullOrUndefined } from 'util';

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

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

Ответ 22

function isEmpty(val){
    return !val;
}

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

if(!val)...

Ответ 23

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

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

Ответ 24

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

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object 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 
* 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));

Ответ 25

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

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

Ответ 26

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

Я не рекомендую пытаться определить или использовать функцию, которая вычисляет, является ли какое-либо значение во всем мире пустым. Что на самом деле означает быть "пустым"? Если у меня есть 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()) правдивы - хотя все они кажутся одинаково пустыми!

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

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

Ответ 27

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

var ? function_if_exists() : function_if_doesnt_exist();

Ответ 28

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

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

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

Ответ 29

try{

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

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

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

Ответ 30

Вместо того, чтобы использовать

if(data !== null && data !== ''  && data!==undefined) {

// do something
}

Вы можете использовать ниже простой код

if(Boolean(value)){ 
// do something 
}

• Значения, которые интуитивно "пустые", такие как 0, пустая строка, null, undefined и NaN, становятся ложными
• Другие ценности становятся правдой