JavaScriptで空/未定義/ null文字列を確認するにはどうすればよいですか？

私はこの質問を見ましたが、JavaScript固有の例を見ませんでした。string.EmptyJavaScriptで利用できるシンプルなものはありますか、それとも単なるチェックのケース""ですか？

値があるかどうかを確認したいだけの場合は、

if (strValue) {
    //do something
}

nullに対して空の文字列を具体的にチェックする必要がある場合""は、===演算子を使用してチェックするのが最善の策だと思います（実際には、比較対象の文字列であることを確認するため）。

if (strValue === "") {
    //...
}

文字列が空、null、または未定義であるかどうかを確認するために、私は次のように使用します。

function isEmpty(str) {
    return (!str || 0 === str.length);
}

文字列が空白、null、または未定義であるかどうかを確認するには、次のように使用します。

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

文字列が空白か、空白のみが含まれているかを確認するには：

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

以前のすべての答えは良いですが、これはさらに良いでしょう。!!（not not）演算子を使用します。

if(!!str){
    // Some code here
}

または型キャストを使用します：

if(Boolean(str)){
    // Code here
}

どちらも同じ機能を果たします。変数をブール値に型キャストしますstr。ここで、は変数です。
それは返すfalseためにnull,undefined,0,000,"",false。文字列「0」と空白「」に対して
返さtrueれます。

あなたが得ることができる最も近いものはstr.Empty（strが文字列であることを前提条件として）です：

if (!str.length) { ...

文字列が単なる一連の空のスペースではないことを確認する必要がある場合（これはフォームの検証用であると想定しています）、スペースを置き換える必要があります。

if(str.replace(/\s/g,"") == ""){
}

私が使う：

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

lodash：_.isEmpty（value）を使用できます。

それはのような例多くをカバーし{}、''、null、undefinedなど、

しかし、JavaScriptプリミティブデータ型の場合、またはその両方が常に返さtrueれます。Number_.isEmpty(10)_.isEmpty(Number.MAX_VALUE)true

関数：

function is_empty(x)
{
    return (
        (typeof x == 'undefined')
                    ||
        (x == null)
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
    );
}

PS：JavaScriptでは、後に改行を使用しないでくださいreturn。

試してください：

if (str && str.trim().length) {  
    //...
}

var s; // undefined
var s = ""; // ""
s.length // 0

JavaScriptでは空の文字列を表すものは何もありません。length（varが常に文字列であることがわかっている場合）またはに対してチェックを行います""

最も効率的な方法についてはあまり心配しません。あなたの意図に最も明確なものを使用してください。私にとってそれは通常strVar == ""です。

Constantinからのコメントのとおり、strVarが整数0の値を含む可能性がある場合、それは実際に意図を明確にする状況の1つになります。

たくさんの答え、そしてたくさんの異なる可能性！

迅速かつ簡単な実装で間違いなく勝者は次のとおりです。 if (!str.length) {...}

ただし、他の多くの例が利用可能です。これに対処するための最良の機能的方法は、次のように提案します。

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

少し過剰だと思います。

正規表現を使うこともできます：

if((/^\s*$/).test(str)) { }

空または空白で埋められた文字列をチェックします。

パフォーマンス

選択した18のソリューションに対してmacOS v10.13.6（High Sierra）でテストを実行します。ソリューションは、以下のスニペットに示されているように（コーナーケースの入力データの場合）少し異なります。

結論

• シンプルなソリューションに基づいて!str、==、===およびlengthすべてのブラウザ（A、B、C、G、I、J）のために高速であります
• 正規表現に基づくソリューション（test、replace）でありcharAt、すべてのブラウザー（H、L、M、P）で最も遅い
• 最速とマークされたソリューションは、1回のテスト実行でのみ最速でした-しかし、多くの実行では、「高速」ソリューショングループ内で変化します

詳細

以下のスニペットでは、さまざまな入力パラメーターを使用して、選択した18のメソッドの結果を比較しています

• "" "a" " "-空の文字列、文字付きの文字列とスペース付きの文字列
• [] {} f-配列、オブジェクト、関数
• 0 1 NaN Infinity -数字
• true false -ブール
• null undefined

テストされたすべてのメソッドがすべての入力ケースをサポートするわけではありません。

function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);

そして、すべての方法についてstr = ""、ブラウザーChrome v78.0.0、Safari v13.0.4、Firefox v71.0.0の速度テストケースを実行します- ここでマシンのテストを実行できます

1. var a;存在することを確認してください

2. false spaces値をトリムしてから、テストしますemptiness

   if ((a)&&(a.trim()!=''))
   {
     // if variable a is not empty do this 
   }

また、空白で満たされた文字列を「空」と見なす場合。

次の正規表現でテストできます。

!/\S/.test(string); // Returns true if blank.

普段はこんな感じで

if (!str.length) {
    // Do something
}

文字列にnull文字が含まれる可能性を考慮した回答に気づきませんでした。たとえば、null文字列がある場合：

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

nullをテストするには、次のようにします。

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

null文字列と空の文字列で機能し、すべての文字列でアクセスできます。さらに、他のJavaScriptの空文字または空白文字（つまり、改行なしスペース、バイトオーダーマーク、行/段落区切り文字など）を含むように拡張できます。

一方、null、undefined、 ''、 ''、{}、[]などのすべての「空」をチェックする1つの関数を使用できます。だから私はこれを書いた。

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

ユースケースと結果。

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

現在のところ、文字列が空かどうかを確認するためのstring.emptyのような直接的なメソッドはありません。ただし、コードでは、次のような空の文字列のラッパーチェックを使用できます。

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}

これを使用して、文字列が未定義またはnullでないことも確認できます。未定義、null、空の3つは異なることを覚えておいてください。

これらの答えはすべていいです。

しかし、変数が文字列であり、スペースだけが含まれているわけではなく（これは私にとって重要です）、 '0'（文字列）が含まれている可能性があります。

私のバージョン：

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

jsfiddleのサンプル。

ここで良い答えが見つかりませんでした（少なくとも私に適した答えではありません）

だから私は自分自身に答えることに決めました：

value === undefined || value === null || value === "";

定義されていないかどうかを確認する必要があります。そうしないと、メソッドが爆発し、nullと等しいか空の文字列と等しいかどうかを確認できます。

持てない!! またはif(value)、チェック0した場合にのみ、誤った答えが返されます（0は偽）。

そうは言っても、次のような方法でまとめてください。

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS .: typeofをチェックする必要はありません。メソッドに入る前でも爆発してスローされるからです。

空の文字列だけでなく空の文字列も検出する必要がある場合は、Goralの答えに追加します。

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

これを試して

str.value.length == 0

JavaScriptのネイティブのStringオブジェクトに簡単に追加して、繰り返し再利用する ことができます... 空の文字列をチェックしたい場合は、以下のコードのような簡単なもので十分です。
''

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);
}

そうでない場合、''空の文字列と' 'スペース付きの両方をチェックしたい場合は、trim()以下のコードのように、を追加するだけでそれを行うことができます。

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);
}

このように呼び出すことができます：

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

これを試して：

export const isEmpty = string => (!string || !string.length);

文字列でも空でもヌルでもない値をテスター関数に渡した場合にどうなるかについて、いくつかの調査を行いました。多くの人が知っているように、（0 == ""）はJavaScriptではtrueですが、0は値であり、空でもnullでもないので、テストすることをお勧めします。

次の2つの関数は、未定義、null、空/空白の値に対してのみtrueを返し、数値、ブール値、オブジェクト、式など、その他すべてに対してfalseを返します。

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

より複雑な例が存在しますが、これらは単純で一貫した結果を提供します。（value == null）チェックに含まれているため、未定義をテストする必要はありません。次のようにStringに追加することで、C＃の動作を模倣することもできます。

String.IsNullOrEmpty = function (value) { ... }

Stringクラスのインスタンスがnullの場合はエラーになるため、これをStringsプロトタイプに含めたくありません。

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

次の値の配列でテストしました。疑わしい場合は、ループして関数をテストできます。

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // Valid number in some locales, not in JavaScript
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

それが正確に空の文字列かどうかを確認するには：

if(val==="")...

それが空の文字列であるか、または値なし（null、undefined、0、NaN、falseなど）の論理的同等物であるかどうかを確認するには：

if(!val)...

isEmpty()メソッドはありません。タイプと長さを確認する必要があります。

if (typeof test === 'string' && test.length === 0){
  ...

型チェックは、testis undefinedまたはの実行時エラーを回避するために必要ですnull。

空白文字列を無視して、これを使用してnull、空、未定義をチェックできます。

var obj = {};
(!!obj.str) // Returns false

obj.str = "";
(!!obj.str) // Returns false

obj.str = null;
(!!obj.str) // Returns false

簡潔であり、未定義のプロパティに対して機能しますが、最も読みやすくはありません。