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

Question

この質問を見ましたが、JavaScript 固有の例は見当たりませんでした。string.EmptyJavaScript で簡単に利用できるものはあり""ますか?

score 4357 · Accepted Answer

真の値があるかどうかを確認したいだけの場合は、次のことができます。

if (strValue) {
    //do something
}

特に空の文字列をnullでチェックする必要がある場合は、演算子""を使用してチェックするのが最善の策だと思います（実際に比較している文字列であることがわかります）。===

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

score 1339 · Accepted Answer

変数がfalseyかどうか、または length 属性がゼロ (文字列の場合は空であることを意味します) であるかどうかを確認するには、次を使用します。

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

_{(属性を持つ変数は文字列だけではないことに注意してくださいlength。たとえば、配列にも属性があります。)}

変数がfalseyかどうか、または文字列に空白のみが含まれているか空であるかどうかを確認するには、次を使用します。

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

必要に応じて、次のようにプロトタイプにモンキーパッチを適用できます。String

String.prototype.isEmpty = function() {
    // This doesn't work the same way as the isEmpty function used 
    // in the first example, it will return true for strings containing only whitespace
    return (this.length === 0 || !this.trim());
};
console.log("example".isEmpty());

_{ビルトイン型のモンキーパッチは、何らかの理由でビルトイン型の既存の構造に依存するコードを壊す可能性があるため、議論の余地があることに注意してください。}

score 486 · Accepted Answer

これまでの答えはすべて良いですが、これはさらに良いでしょう。デュアルNOT演算子を使用する（!!）：

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

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

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

どちらも同じ機能を果たします。変数をブール値に型キャストします。ここstrで、は変数です。

、、、、、、、falseに戻ります。null_ undefined_ 0_000""false
true空の文字列以外のすべての文字列値（"0"およびなどの文字列を含む" "）を返します。

score 125 · Accepted Answer

str.Empty（strが文字列であるという前提条件で）到達できる最も近いものは次のとおりです。

if (!str.length) { ...

score 111 · Accepted Answer

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

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

score 71 · Accepted Answer

私が使う：

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

score 42 · Accepted Answer

非常に一般的な「オールインワン」機能 (ただし、お勧めしません):

function is_empty(x)
{
    return (                                                           //don't put newline after return
        (typeof x == 'undefined')
              ||
        (x == null)
              ||
        (x == false)        //same as: !x
              ||
        (x.length == 0)
              ||
        (x == 0)            // note this line, you might not need this. 
              ||
        (x == "")
              ||
        (x.replace(/\s/g,"") == "")
              ||
        (!/[^\s]/.test(x))
              ||
        (/^\s*$/.test(x))
    );
}

ただし、ターゲット変数は特定の型 (文字列、数値、オブジェクトなど) である必要があるため、その使用はお勧めしません。したがって、その変数に関連するチェックを適用します。

score 39 · Accepted Answer

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

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

score 37 · Accepted Answer

37

試す：

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

于 2013-01-09T02:54:50.370 に答える

score 31 · Accepted Answer

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

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

score 21 · Accepted Answer

正規表現を使用することもできます。

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

空または空白で満たされた文字列をチェックします。

score 21 · Accepted Answer

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

迅速かつ簡単に実装できることは間違いありません。勝者は次のとおりです。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;
}

少し過剰です、私は知っています。

score 13 · Accepted Answer

私は組み合わせを使用しており、最速のチェックが最初です。

function isBlank(pString) {
    if (!pString) {
        return true;
    }
    // Checks for a non-white space character
    // which I think [citation needed] is faster
    // than removing all the whitespace and checking
    // against an empty string
    return !/[^\s]+/.test(pString);
}

score 12 · Accepted Answer

文字列にヌル文字が含まれる可能性を考慮した回答に気づいていません。たとえば、ヌル文字列がある場合:

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

その無効性をテストするには、次のようにします。

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

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

score 10 · Accepted Answer

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

しかし、変数が文字列であり、スペースだけが含まれているわけではなく (これは私にとって重要です)、「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のサンプル。

score 10 · Accepted Answer

非文字列および非空/null 値をテスター関数に渡すとどうなるかについて、いくつかの調査を行いました。多くの人が知っているように、JavaScript では (0 == "") は true ですが、0 は値であり空でも null でもないため、テストする必要があるかもしれません。

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

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

もっと複雑な例もありますが、これらは単純で、一貫した結果が得られます。undefined は (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; } }]
];

score 10 · Accepted Answer

正確に空の文字列かどうかを確認するには:

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

それが空の文字列か、または値なしの論理的な等価物 (null、undefined、0、NaN、false、...) であるかどうかを確認するには、次のようにします。

if(!val)...

score 9 · Accepted Answer

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

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

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

score 8 · Accepted Answer

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

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

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

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

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

score 7 · Accepted Answer

7

これを試して

str.value.length == 0

于 2010-07-22T15:30:53.933 に答える

score 7 · Accepted Answer

チェックする変数が文字列であると想定しないでください。この var に長さがある場合、それは文字列であると想定しないでください。

問題は、アプリが何をしなければならず、何を受け入れることができるかを慎重に考えることです。堅牢なものを構築します。

メソッド/関数が空でない文字列のみを処理する必要がある場合は、引数が空でない文字列であるかどうかをテストし、「トリック」を実行しないでください。

ここでのアドバイスに注意深く従わないと爆発するものの例として。


var getLastChar = function (str) {
 if (str.length > 0)
   return str.charAt(str.length - 1)
}

getLastChar('hello')
=> "o"

getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'

だから、私は固執します


if (myVar === '')
  ...

score 6 · Accepted Answer

私は通常、次のようなものを使用します。

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}

score 6 · Accepted Answer

次の方法を検証し、違いを理解できます。

var j = undefined;
console.log((typeof j == 'undefined') ? "true":"false");
var j = null; 
console.log((j == null) ? "true":"false");
var j = "";
console.log((!j) ? "true":"false");
var j = "Hi";
console.log((!j) ? "true":"false");

score 5 · Accepted Answer

JavaScript はダック型言語であるため、常に型も確認する必要があります。そのため、プロセスの途中でデータがいつ、どのように変更されたかがわからない場合があります。したがって、より良い解決策は次のとおりです。

    let undefinedStr;
    if (!undefinedStr) {
      console.log("String is undefined");
    }
    
    let emptyStr = "";
    if (!emptyStr) {
      console.log("String is empty");
    }
    
    let nullStr = null;
    if (!nullStr) {
      console.log("String is null");
    }

score 5 · Accepted Answer

次の正規表現は、null、空、または未定義の文字列に使用できる別のソリューションです。

(/(null|undefined|^$)/).test(null)

次のように空または値をチェックするためにさらに拡張できるため、このソリューションを追加しました。次の正規表現は、文字列が空の null 未定義である可能性があるか、整数のみを含むかをチェックしています。

(/(null|undefined|^$|^\d+$)/).test()

score 4 · Accepted Answer

function tell()
{
    var pass = document.getElementById('pasword').value;
    var plen = pass.length;

    // Now you can check if your string is empty as like
    if(plen==0)
    {
        alert('empty');
    }
    else
    {
        alert('you entered something');
    }
}

<input type='text' id='pasword' />

これは、フィールドが空かどうかを確認する一般的な方法でもあります。

score 4 · Accepted Answer

Underscore.js JavaScript ライブラリ ( http://underscorejs.org/ )_.isEmpty()は、空の文字列やその他の空のオブジェクトをチェックするための非常に便利な機能を提供します。

参照: http://underscorejs.org/#isEmpty

isEmpty _.isEmpty(object)
列挙可能なオブジェクトに値が含まれていない (列挙可能な独自のプロパティがない) 場合は、true を返します。文字列と配列のようなオブジェクトの場合、_.isEmpty は長さプロパティが 0 かどうかをチェックします。

_.isEmpty([1, 2, 3]);
=>偽

_.isEmpty({});
=>真

その他の非常に便利な Underscore.js 関数には、次のものがあります。

http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined
_.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)

score 3 · Accepted Answer

未定義の項を渡そうとしていないことを確認するのも良い考えです。

function TestMe() {
  if((typeof str != 'undefined') && str) {
    alert(str);
  }
 };

TestMe();

var str = 'hello';

TestMe();

通常、オブジェクトインスタンスの文字列属性が空でないときに何かを実行したい場合に遭遇します。属性が常に存在するとは限らないことを除いて、これは問題ありません。

score 2 · Accepted Answer

別の方法ですが、bdukesの答えが最善だと思います。

var myString = 'hello'; 
if(myString.charAt(0)){
    alert('no empty');
}
alert('empty');

score 1 · Accepted Answer

isBlank 関数の究極かつ最短のバリアント:

/**
 * Will return:
 * False for: for all strings with chars
 * True for: false, null, undefined, 0, 0.0, "", " ".
 *
 * @param str
 * @returns {boolean}
 */
function isBlank(str){
    return (!!!str || /^\s*$/.test(str));
}

// tests
console.log("isBlank TRUE variants:");
console.log(isBlank(false));
console.log(isBlank(undefined));
console.log(isBlank(null));
console.log(isBlank(0));
console.log(isBlank(0.0));
console.log(isBlank(""));
console.log(isBlank(" "));

console.log("isBlank FALSE variants:");
console.log(isBlank("0"));
console.log(isBlank("0.0"));
console.log(isBlank(" 0"));
console.log(isBlank("0 "));
console.log(isBlank("Test string"));
console.log(isBlank("true"));
console.log(isBlank("false"));
console.log(isBlank("null"));
console.log(isBlank("undefined"));

score 0 · Accepted Answer

この関数は、文字列であり空ではないことを保証して、私にとってはうまくいきました。

isNonBlankString = function(s) { return ((typeof s === 'string' || s instanceof String) && s !== ''); }

score 0 · Accepted Answer

.blank?js文字列のレールを探している人のために：

function is_blank(str) { 
  return (!str || str.length === 0 || str.trim() == '')
}

score -2 · Accepted Answer

これを処理するために使用するカスタム関数を次に示します。コードの実行方法の例とともに。

const v1 = 0
const v2 = '4'
const v2e = undefined
const v2e2 = null
const v3 = [1, 2, 3, 4]
const v3e = []
const v4 = true
const v4e = false
const v5 = {
  test: 'value'
}
const v5e = {}
const v6 = 'NotEmpty'
const v6e = ''

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n)
}

function isEmpty(v, zeroIsEmpty = false) {
  /**
   * When doing a typeof check, null will always return "object" so we filter that out first
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null
   */
  if (v === null) {
    return true
  }

  if (v === true) {
    return false
  }

  if (typeof v === 'object') {
    return !Object.keys(v).length
  }

  if (isNumeric(v)) {
    return zeroIsEmpty ? parseFloat(v) === 0 : false
  }

  return !v || !v.length || v.length < 1
}

console.log(isEmpty(v1), isEmpty(v1, true))
console.log(isEmpty(v2), isEmpty(v2e), isEmpty(v2e))
console.log(isEmpty(v3), isEmpty(v3e))
console.log(isEmpty(v4), isEmpty(v4e))
console.log(isEmpty(v5), isEmpty(v5e))
console.log(isEmpty(v6), isEmpty(v6e))

また、参考までに、lodash isEmpty のソースは次のとおりです: https://github.com/lodash/lodash/blob/master/isEmpty.js

score -6 · Accepted Answer

<html>
    <head>
        <script lang="javascript">

            function nullcheck()
            {
                var n = "fdgdfg";
                var e = n.length;
                if (e == 0)
                {
                    return true;
                }
                else
                {
                    alert("success");
                    return false;
                }
            }
        </script>
    </head>

    <body>
        <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
</html>

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

59 に答える 59

Related

Reference