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

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}
2474
Alex 1 Апр 2011 в 19:14

30 ответов

Лучший ответ

Вы можете просто проверить, имеет ли переменная значение 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 -это- fast.html

4268
JackNavaRow 11 Сен 2019 в 03:04

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

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

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

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

typeof foo != "undefined"

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

if (typeof foo != "undefined" && foo) {
    //code here
}
5
herostwist 1 Апр 2011 в 15:25

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

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

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));
0
Narasimha Reddy - Geeker 9 Янв 2020 в 11:13

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

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

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

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

4
BlackBeard 5 Окт 2018 в 02:48

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

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

2
yaharga 6 Ноя 2019 в 06:30

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

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

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

return value == null; // also returns true if value is undefined
214
Salman A 18 Июл 2018 в 12:26
function isEmpty(value){
  return (value == null || value.length === 0);
}

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

undefined  // Because undefined == null

null

[]

""

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

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

function isEmpty(value){
  return (value == null || value === '');
}
76
Mike Samuel 16 Фев 2015 в 17:04
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
}
5
Fabian von Ellerts 5 Окт 2018 в 14:37

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

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

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

14
tcooc 1 Апр 2011 в 15:21
try{

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

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

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

0
nobjta_9x_tq 1 Окт 2018 в 10:25

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

function isEmpty(val){
  return !val;
}

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

ИЛИ

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

16
Arif 8 Май 2019 в 07:40

Если вы предпочитаете простой 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
l3x 21 Авг 2015 в 13:39
var myNewValue = myObject && myObject.child && myObject.child.myValue;

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

2
Sᴀᴍ Onᴇᴌᴀ 20 Июн 2017 в 20:46

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

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

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

0
Mark Giblin 10 Мар 2017 в 09:57

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

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")) {
1
rickdog 3 Сен 2016 в 21:49

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

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

28
Vix 14 Авг 2018 в 19:42

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

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

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

16
Aryeh Beitz 3 Июн 2017 в 19:51
return val || 'Handle empty variable'

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

const res = val || 'default value'
5
cubefox 4 Дек 2018 в 12:44

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

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

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
5
ddagsan 14 Июн 2019 в 10:36

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

(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));
2
centurian 2 Дек 2017 в 09:27
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]
1
Pascal Polleunus 29 Мар 2020 в 00:45

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

function stringIsEmpty(value) {

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

}
9
DavidWainwright 12 Фев 2014 в 15:45

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

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

Или

if (typeof value  !== "undefined" && value)
25
krupar 19 Мар 2014 в 13:23

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

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

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

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

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

43
guya 2 Янв 2020 в 12:17
function isEmpty(val){
    return !val;
}

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

if(!val)...
2
Luca C. 2 Июн 2017 в 08:30

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

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]"        
5
Yash 9 Апр 2017 в 05:39

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

var ? function_if_exists() : function_if_doesnt_exist();
0
Pedro Pereira 30 Июн 2016 в 09:31