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

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

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

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

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

typeof foo != "undefined"

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

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

Это охватывает пустой массив и пустой объект также

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

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));

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

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

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

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

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

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

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

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 === '');
}

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

let x = foo ?? bar();

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

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

Demo @ Как определить если переменная не определена или равна нулю с использованием JavaScript

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
}

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

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

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

try{

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

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

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

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

function isEmpty(val){
  return !val;
}

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

ИЛИ

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

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

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

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

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

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

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

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

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

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

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 (!!foo) {
    //foo is defined
}

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

return val || 'Handle empty variable'

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

const res = val || 'default value'

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

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

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

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

(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));

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]

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

function stringIsEmpty(value) {

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

}

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

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

Или

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

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

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

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

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

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

function isEmpty(val){
    return !val;
}

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

if(!val)...

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

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

Используя instanceof «

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

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

var ? function_if_exists() : function_if_doesnt_exist();