変数に値があることを確認し、ないundefinedかnullどうかを確認するユニバーサルJavaScript関数はありますか？私はこのコードを持っていますが、すべてのケースをカバーしているかどうかはわかりません：

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

変数にtruthy値があるかどうかを確認できます。つまり

if( value ) {
}

でないtrue場合に評価されます：value

• ヌル
• 未定義
• 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-is-fast.html

値が未定義か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'
};

値が定義されなかった場合と、次のいずれかをカバーします。

• ヌル
• undefined（undefinedの値は、定義されなかったパラメーターと同じではありません）
• 0
• ""（空の文字列）
• 偽
• NaN

_{編集：厳密な等価（！==）に変更されました。これは今では標準だからです;）}

次の関数が役立つことがあります。

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（ストローマン）の提案です。」– Simon Kjellberg。著者は、王位の昇天を受けるためのこの美しい提案に対する彼のサポートを追加したいと考えています。

最高の評価の最初の答えは間違っています。値が未定義の場合、最新のブラウザでは例外がスローされます。使用する必要があります：

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

または

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

この状態チェック

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

は、あなたが必要とすることすべてです。

！空の文字列（ ""）、null、undefined、false、および数値0とNaNをチェックします。たとえば、文字列が空のvar name = ""場合console.log(!name)はを返しますtrue。

function isEmpty(val){
  return !val;
}

この関数は、valが空、null、未定義、false、数値0またはNaNの場合にtrueを返します。

または

問題のドメインに応じて、!valまたはのように使用できます!!val。

私が大好きな解決策：

空の変数を、、、nullまたはundefined長さがある場合はゼロ、オブジェクトである場合はキーがないと定義してみましょう。

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

戻り値：

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

あなたは少しやりすぎです。変数に値が指定されていないかどうかを確認するには、未定義およびnullに対してのみチェックする必要があります。

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

これは想定されている0、""およびオブジェクト（さえ空のオブジェクトとアレイ）有効「値」です。

単純な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)

これが私のものです-値がnull、未定義な​​ど、または空白の場合（つまり、空白スペースのみを含む場合）はtrueを返します。

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

多くの場所でそれを処理する本当に素晴らしくてきれいな方法であり、変数を割り当てるためにも使用できます

const res = val || 'default value'

変数が宣言されていない場合、エラーが発生するため、関数を使用して未定義をテストすることはできません。

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

fooが宣言されていない場合、どちらもエラーを生成します。

変数が宣言されているかどうかをテストしたい場合は、

typeof foo != "undefined"

fooが宣言されていて、それに使用できる値があるかどうかをテストする場合

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

デフォルト値を確認するには

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 function（）を使用して、どのタイプのオブジェクトかを確認しました。

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

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
}

役に立つかもしれません。

配列内のすべての値は、なりたいもの（null、未定義、または別のもの）を表しており、その中から欲しいものを検索します。

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

あなたが使用している場合TypeScriptとを説明するためにしたくない「値ものがあるfalse」、これはあなたのためのソリューションです。

最初： import { isNullOrUndefined } from 'util';

次に： isNullOrUndefined(this.yourVariableName)

注：以下で説明するように、これは非推奨になりvalue === undefined || value === nullました。代わりに使用してください。ref。

空虚

全世界の値が空かどうかを計算する関数を定義または使用することはお勧めしません。「空」とはどういう意味ですか？私が持っている場合let human = { name: 'bob', stomach: 'empty' }、isEmpty(human)戻る必要がありtrueますか？私が持っているならlet reg = new RegExp('');、すべきisEmpty(reg)戻るがありtrueますか？何についてisEmpty([ null, null, null, null ])-このリストには空のみが含まれているので、リスト自体は空ですか？ここでは、JavaScriptの「空白」（既存の関連付けを回避するために意図的にあいまいな単語）についていくつかの注意を述べたいと思います。また、JavaScript値の「空白」は一般的に扱われるべきではないと主張したいと思います。

真実/虚偽

値の「空虚さ」を判断する方法を決定するために、値が「真実」であるか「偽」であるかという、JavaScriptの組み込みの固有の感覚に対応する必要があります。当然、nullそしてundefined両方とも「偽物」です。それほど自然ではないが、この数0（およびを除いて他の数はないNaN）も「偽り」である。当然のことながら''、偽物ですが[]、and {}（およびnew Set()、およびnew Map()）は真実です。

ヌルvs未定義

nullvs についての議論もあります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());

• 与えられた場合、デフォルト値を持つパラメータは、デフォルトを受けundefined、ありませんnull。

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

非一般的な空虚さ

空虚は決して一般的な方法で扱われるべきではないと私は信じています。代わりに、データが空であるかどうかを判断する前に、常にデータについてより多くの情報を取得する必要があります。主にこれは、処理するデータの種類を確認することで行います。

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

この関数はポリモーフィズムを無視することに注意してください。これはvalue、の直接インスタンスでClsあり、のサブクラスのインスタンスではないことを期待していますCls。instanceof2つの主な理由で回避します。

• ([] instanceof Object) === true （「配列はオブジェクトです」）
• ('' instanceof String) === false （「文字列は文字列ではありません」）

注Object.getPrototypeOfのようなケースを避けるために使用される機能は、まだ正しく返す（偽）、およびlet v = { constructor: String };isTypeisType(v, String)isType(v, Object)（真）。

全体的に、私isTypeはこれらのヒントとともにこの関数を使用することをお勧めします：

• 不明なタイプのコード処理値の量を最小限に抑えます。たとえば、の場合let v = JSON.parse(someRawValue);、v変数は未知の型になります。できるだけ早く、可能性を制限するべきです。これを行う最良の方法は、特定のタイプを要求することです。たとえば、if (!isType(v, Array)) throw new Error('Expected Array');これは、の一般的な性質を削除し、v常にであることを確認するための非常に迅速で表現力のある方法Arrayです。ただし、場合vによっては、複数のタイプを許可する必要があります。そのような場合、vジェネリックではなくなったコードブロックをできるだけ早く作成する必要があります。

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

• 検証には常に「ホワイトリスト」を使用してください。文字列、数値、配列などの値が必要な場合は、3つの「白」の可能性を確認し、3つのうちどれも満たされていない場合はエラーをスローします。「黒」の可能性をチェックすることはあまり役に立たないことを確認できるはずです。たとえば、次のように記述します。if (v === null) throw new Error('Null value rejected');これはnull、値が通過しないようにするのに最適ですが、値が通過する場合でも、ほとんどわかりませんそれについて何か。vこのnullチェックに合格した値は、依然として非常に一般的です-それ以外のものnullです！ブラックリストは、一般性を払拭することはほとんどありません。

• 値がnullでない限り、「空の値」を考慮しないでください。代わりに、「空虚なX」を考えてください。基本的に、if (isEmpty(val)) { /* ... */ }そのようなことをすることを決して考えないでください-そのisEmpty関数がどのように実装されていても（私は知りたくありません...）、それは意味がありません！そしてそれはあまりにも一般的です！空虚度は、valのタイプの知識がある場合にのみ計算する必要があります。空虚度チェックは次のようになります。

  • 「文字のない文字列」： if (isType(val, String) && val.length === 0) ...
  • "オブジェクト、0プロップ付き"： if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "ゼロ以下の数値"： if (isType(val, Number) && val <= 0) ...

  • "配列、アイテムなし"： if (isType(val, Array) && val.length === 0) ...

  • 唯一の例外は、nullが特定の機能を示すために使用される場合です。この場合、「空の値」と言うことは意味があります。if (val === null) ...

別のロジックでお試しください。not null、空白、未定義、ゼロでないなど、検証の4つすべての条件をチェックするために次のコードを使用できます。JavaScriptとjqueryでこのコード（！（！（variable）））を使用するだけです。

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

新しいECMAScript Nullish合体演算子を見てください

この機能- ??演算子-は、nullまたはを処理するときにデフォルト値に「フォールバック」する方法と考えることができますundefined。

let x = foo ?? bar();

ここでも、上記のコードは次のコードと同等です。

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

function isEmpty(val){
    return !val;
}

しかし、このソリューションは過度に設計されており、後でbusinesモデルのニーズに合わせて関数を変更したくない場合は、コードで直接使用する方がきれいです。

if(!val)...

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

これは決してエラーをスローしません。場合myObjectという、子供、またはmyValueは nullで、その後myNewValueは nullになります。エラーはスローされません

同様の質問をするためにここに来るすべての人にとって、以下はうまくいき、私は過去数年間、自分のライブラリーにそれを持っています：

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

あなたは値がに応じて、以下のいずれかである場合はtrueを取得しないようにしたい場合はjAndyの答え：

• ヌル
• 未定義
• NaN
• 空の文字列（ ""）
• 0
• 偽

真実の値を取得しない可能性のある1つの解決策は次のとおりです。

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変数がそれらのいずれかとして宣言されている場合、空の文字列、0、false、NaN、null、およびundefinedに対してtrueを返すため、使用するのが最善ではない場合があります。関数は、宣言されたことを示すために使用するように変更できますが、使用できません。

GitHubのコード

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]

これは、不確定なネストの変数が未定義かどうかをチェックします

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である可能性がある場合に、接続されたオブジェクトを介して値へのアクセスを簡略化する方法を提供します。

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

空の合体演算子は、何も見つからなかったときにデフォルト値を構築するために、オプションの連鎖の後に使用できます。

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

また、以下と共に空白（ ''）もチェックします。

• null、未定義、NaN、空、文字列（ ""）、0、false

私は使用すると思いますか？オペレーターは少しきれいです。

var ? function_if_exists() : function_if_doesnt_exist();