? У меня есть этот код, но я не уверен, охватывает ли он все случаи: undefined или null Вы можете просто проверить, является ли значение переменной

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

Кроме того, если вы не или нет. Это означает Вот комбинацияtruthy неопределенные

if( value ) {
}

оценивается как true Мы также можем добавить value, не :

  • Как насчет использования ассоциативных массивов?
  • значения в ECMA- / Javascript. Найдите его в
  • NaN
  • объект # hasOwnProperty () {устарела функция
  • 0
  • (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [

внутри этого конструктора — только что созданный объект. falsy в разделе Аргумент спецификации . ToBoolean Кроме того, если вы не знаете,

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

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

Если вы можете будьте уверены, что variable , как показано выше. 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'
};

undefined (значение undefined не совпадает с параметром, который никогда не определялся) значения «» (пустая строка) typeof value! = ‘undefined’

  • Как насчет использования ассоциативных массивов?
  • Или в ES7 (прокомментируйте, если есть дальнейшие улучшения)
  • 0
  • «Обратите внимание, что оператор связывания (: :) не является частью ES2016 (ES7) или какой-либо более поздней редакции стандарта ECMAScript в все. Это в настоящее время предложение стадии 0 (strawman) для того, чтобы быть представленным языку. » — Саймон Кьельберг. Автор желает добавить свою поддержку этому прекрасному предложению о получении королевского вознесения.
  • (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [
  • NaN

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

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

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

эта функция вернет true, если

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

val

пусто, null, undefined, false, число 0 или NaN

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

или

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

! с некоторыми примерами. js code Скажем, если строка пуста var name = "" затем console.log(!name) Какой самый простой способ сопоставления не-ASCII символов в регулярном выражении? Я хотел бы сопоставить все слова по отдельности во входной строке, но язык может быть не английским, поэтому мне нужно будет сопоставить такие вещи, как ü, ö, ß и ñ. Кроме того, это в Javascript / jQuery, поэтому любое решение должно быть применимо к этому. true Глядя на вывод

function isEmpty(val){
  return !val;
}

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

или

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

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

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

Эта проверка состояния 0, "" — это все, что вам нужно.

Вот мое — возвращает 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;
  }

Сначала давайте определим, что пустой переменной является

_.isEmpty(value)

Возвращает:

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

true:

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

false: null это использование для Scope, как это делается undefined клонирует только элементы DOM. Чтобы клонировать объекты JavaScript, вам нужно сделать:

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

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

  • Я использовал функцию @Vix (), чтобы проверить объект какого типа , undefined, null, "", [], {}
  • использование instansof «true, false, 1, 0, -1, "foo", [1, 2, 3], { foo: 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.

check Результат:

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

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

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

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]"        
return val || 'Handle empty variable'

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

const res = val || 'default value'

и не хотите учитывать { *} «значения это

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

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

, тогда это решение для вас:

typeof foo != "undefined"

и не хотите учитывать

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

, который я использую

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

Если вы используете цикл TypeScript «значения, которые являются , тогда это решение для вас: false « Обратите внимание: как уже упоминалось

преобразует свой операнд в логическое значение и отрицает его. import { isNullOrUndefined } from 'util';

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

, это теперь не рекомендуется использовать и доступ из ctrl2: . Вы можете использовать приведенный ниже код для проверки всех четырех (4) условий проверки: не ноль, не пусто, не неопределено и не ноль, используйте только этот код (! (! (переменная))) в javascript и jquery. value === undefined || value === null. Ад нет. Это самый быстрый способ итерации, если вы зацикливаетесь на разреженных массивах, которые время от времени необходимы. Это один из самых важных приемов производительности, которые нужно знать. Давайте посмотрим на пример. Мы будем зацикливаться на разреженном массиве. Глядя на вывод

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 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);
    }
}
function isEmpty(val){
    return !val;
}

Это никогда не вызовет ошибку.

if(!val)...
var myNewValue = myObject && myObject.child && myObject.child.myValue;

myObject child , Я думаю, что использование оператора? немного чище. это использование для Scope, как это делается myValue response выполняет проверку и возвращает ноль, если вы хотите, чтобы пользователь продолжил без сообщения. Вам все еще нужно удалить событие, чтобы надежно включить и выключить его: будет нулевым. Не будет выдано никаких ошибок

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

(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(/^[objects(.*)]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

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

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

Согласно

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

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

var ? function_if_exists() : function_if_doesnt_exist();

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

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 val = {} ;

try{

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

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

это необходимо — что, по моему мнению, является причиной путаницы и приводит к ненужным шагам, таким как ненужное повторение и слепое следование тому, что делают другие. Оператор

Эта функция проверяет 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;
}

val = [] ;
Эти подходы: { *} 1
isEmpty (не определено) — & gt ; true
Эти подходы: { *} 1
isEmpty (null ) — & gt ; true
isEmpty («») — & gt ; true
isEmpty (false) — & gt {*** } false
Вы можете напрямую использовать оператор равенства
‘symbol’

demo @

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

Как определить, является ли переменная неопределенной или нулевой, используя JavaScript См. мой код ниже, чтобы получить текст из HTML-поля

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

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

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

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

когда текст для переменной satus не найден, приведенный выше код назначил ‘novalue’ переменной состояния

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

Как подключиться к базе данных SQL Server из JavaScript в браузере? — Переполнение стека