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

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

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

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

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

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

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

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

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

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

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

или

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

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

function isEmpty(val){
  return !val;
}

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

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

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

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

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

function stringIsEmpty(value) {

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

}

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

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

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

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

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

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

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

[null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1

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

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

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

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

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

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

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

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

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

typeof foo != "undefined"

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

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

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

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

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

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

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

return val || 'Handle empty variable'

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

const res = val || 'default value'

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
}

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

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

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

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

function isEmpty(val){
    return !val;
}

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

if(!val)...

Это проверит, является ли переменная неопределенной вложенности 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")) {

Я оставлю зарегистрированное решение, которое мне очень понравилось:

Сначала давайте определим, что пустая переменная равна 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)
  )
}

Возвращает:

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

try{

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

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

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

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

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

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

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

var ? function_if_exists() : function_if_doesnt_exist();

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

<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 @Как определить, является ли переменная неопределенной или null с использованием JavaScript

Эта функция проверяет 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) → true
Val = [];
isEmpty (val) → true
isEmpty (undefined) → true
isEmpty (null) → true
isEmpty ("") → true
isEmpty (false) → false
isEmpty (0) → false

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

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

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

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

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

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

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