Wie leer / undefined / null Zeichenfolge in JavaScript überprüfen?

Question

habe ich diesen Thread , aber ich habe kein JavaScript konkretes Beispiel sehen. Gibt es eine einfache string.Empty in JavaScript, oder ist es nur ein Fall von Kontrolle für ""?

Answer 1

Wenn Sie wollen einfach nur überprüfen, ob es irgendeinen Wert, können Sie

if (strValue) {
    //do something
}

Wenn Sie die speziell für eine leere Zeichenfolge über null zu überprüfen, ich glaube, die Überprüfung würde gegen "" ist die beste Wahl, mit der === Operator (so dass Sie wissen, dass es in der Tat, ein String Sie vergleichen gegen).

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

Answer 2

Für die Überprüfung, ob ein String leer ist, null oder nicht definiert Ich benutze:

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

Für die Überprüfung, ob ein String leer ist, null oder nicht definiert Ich benutze:

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

Für die Überprüfung, ob ein String leer oder enthält nur white-space:

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

Answer 3

Alle oben genannten sind gut, aber das wird noch besser. verwenden !! ( nicht nicht ) Operator.

if(!!str){
some code here;
}

oder Verwendung type casting:

if(Boolean(str)){
    codes here;
}

Beide tun die gleiche Funktion, geben Sie die Variable zu gieße boolean, wo str ist eine Variable.
Returns false für null,undefined,0,000,"",false.
Returns true für string "0" und Leerzeichen "".

Answer 4

Wenn Sie müssen sicherstellen, dass die Zeichenfolge nicht nur ein Haufen von leeren Räumen ist (Ich gehe davon aus das ist für Formularvalidierung) Sie müssen sich auf die Räume eine ersetzen tun.

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

Answer 5

Das nächste, was man bekommen kann str.Empty (unter der Voraussetzung, dass str ein String ist) ist:

if (!str.length) { ...

Answer 6

ich benutze:

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

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

Answer 7

Versuchen:

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

Answer 8

Funktion:

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

  

P. S. In Javascript, verwenden Sie Zeilenumbruch nicht nach return;

Answer 9

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

Es gibt nichts, eine leere Zeichenfolge in JavaScript darstellt. Führt eine Überprüfung entweder gegen length (wenn Sie wissen, dass die var immer einen String sein) oder gegen ""

Answer 10

Sie können mit lodash : _.isEmpty (Wert).

Es umfasst eine Menge von Fällen wie {}, '', null, undefined usw.

Aber es gibt immer true für Number Typ Javascript Primitive Datentypen wie _.isEmpty(10) oder _.isEmpty(Number.MAX_VALUE) beide kehrt true.

Answer 11

Ich würde nicht zu viele Sorgen über die meist effizient Methode. Verwenden Sie, was auf Ihre Absicht, am deutlichsten ist. Für mich ist das in der Regel strVar == "".

EDIT: pro Kommentar von Constantin , wenn strVar könnte einige, wie eine ganze Zahl 0 Wert am Ende enthält, dann das wäre in der Tat sein, eine jener Absicht-Klärung Situationen.

Answer 12

Sie auch mit regexps gehen könnte:

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

Checks für Strings, die entweder leer oder gefüllt mit Leerzeichen sind.

Answer 13

Eine Menge Antworten und viele verschiedene Möglichkeiten!

Ohne Zweifel für die schnelle und einfache Implementierung der Gewinner ist: if (!str.length) {...}

Doch wie viele andere Beispiele zur Verfügung. Die beste funktionale Methode, um dies zu, würde ich vorschlagen:

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

Ein bisschen übertrieben, ich weiß.

Answer 14

1. prüfen Sie, dass var a; existieren

2. schneiden Sie die false spaces im Wert, dann Test für emptiness

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

Answer 15

Auch im Fall betrachten Sie ein Leerzeichen gefüllt Zeichenfolge als „leer“. Sie können es mit dieser Regex testen:

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

Answer 16

ich in der Regel so etwas wie diese,

if (!str.length) {
//do some thing
}

Answer 17

Ich habe keine Antwort bemerkt, dass die Möglichkeit von Null-Zeichen in einem String berücksichtigt. Zum Beispiel, wenn wir eine Null-Zeichenfolge haben:

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

seine nullness ein Um zu testen, könnte so etwas tun:

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

Es funktioniert auf eine leere Zeichenfolge, und auf eine leere Zeichenfolge, und es ist für alle Saiten zugänglich. Darüber hinaus könnte es erweitert werden, um andere JavaScript leer oder Leerzeichen enthalten (das heißt geschütztes Leerzeichen, Bytereihenfolgemarkierung, Zeile / Absatz-Separator, etc.).

Answer 18

Wenn man nicht nur leer, sondern auch leere Strings erkennen muss, werde ich zu Goral Antwort hinzufügen:

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

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

Answer 19

All diese Antworten sind nett.

Aber ich kann nicht sicher sein, dass Variable ein String ist, enthält nicht nur Leerzeichen (dies ist wichtig für mich), und enthält ‚0‘ (string).

Meine Version:

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

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

Beispiel auf jsfiddle .

Answer 20

Normalerweise verwende ich so etwas wie:

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

Answer 21

Ich verwende eine Kombination, sind am schnellsten prüft zuerst.

function isBlank(pString){
    if (!pString || pString.length == 0) {
        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);
}

Answer 22

Leerzeichen Strings Ignorieren, Sie könnten so für null zu überprüfen, leer und unbestimmt:

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

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

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

Concise und es funktioniert für nicht definierte Eigenschaften, obwohl es nicht die lesbar ist.

Answer 23

habe ich einige der Forschung, was passiert, wenn Sie eine nicht-String und nicht leer / Nullwert an einen Tester-Funktion übergeben. Wie viele wissen, (0 == „“) ist wahr in Javascript, aber da 0 ein Wert ist und nicht leer oder null, können Sie es testen möchten.

Die beiden folgenden Funktionen return true nur für nicht definierte, null, leer / Leerzeichen Werte und falsch für alles andere, wie Zahlen, boolean, Objekte, Ausdrücke etc.

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

Kompliziertere Beispiele vorhanden, aber diese sind einfache und konsistente Ergebnisse. Es besteht keine Notwendigkeit für undefinierte zu testen, da es in (value == null) Prüfung enthalten ist. Sie können auch Mimik C # Verhalten von ihnen String wie folgt ergänzt:

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

Sie wollen es nicht in Strings Prototyp setzen, denn wenn die Instanz der String-Klasse null ist, wird es Fehler:

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

ich mit dem folgenden Wert Array getestet. Sie Schleife kann es durch Ihre Funktionen im Zweifelsfall zu testen.

// 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 js
    ['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; } }]
];

Answer 24

zu prüfen, ob genau eine leere Zeichenfolge:

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

zu überprüfen, ob es eine leere Zeichenfolge oder eine logische Entsprechung für No-Wert (null, nicht definiert, 0, NaN, falsch, ...):

if(!val)...

Answer 25

Mittlerweile können wir eine Funktion, die für alle überprüft 'leert' wie null, nicht definiert, '', '', {} [] . Also habe ich das gerade geschrieben haben.

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

Anwendungsfälle und Ergebnisse.

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

Answer 26

Es gibt keine isEmpty() Methode, müssen Sie für den Typ und die Länge überprüfen:

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

Die Typprüfung ist erforderlich, um Laufzeitfehler zu vermeiden, wenn test undefined oder null ist.

Answer 27

Nehmen Sie nicht an, dass die Variable, die Sie prüfen, eine Zeichenfolge ist. Gehen Sie nicht davon, dass, wenn diese var eine Länge hat, dann ist es ein String.

Die Sache ist: sorgfältig darüber nachdenken, was Ihre Anwendung muss tun und akzeptieren kann. Bauen Sie etwas robuster.

Wenn Ihre Methode / Funktion sollte nur eine nicht leere Zeichenfolge verarbeitet dann testen, ob das Argument eine nicht leere Zeichenfolge ist und das nicht tut etwas ‚Trick‘.

Als ein Beispiel für etwas, das explodieren, wenn Sie einige Ratschläge folgen hier nicht sorgfältig.

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'

Also, ich würde Stick mit

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

Answer 28

Versuchen Sie, diese

str.value.length == 0

Answer 29

Sie können es leicht in der nativen String Objekts in JavaScript und wieder verwenden es immer und immer wieder ...
Etwas Einfaches wie unten Code kann die Arbeit für Sie tun, wenn Sie '' leere Zeichenfolgen überprüfen möchten:

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

Ansonsten, wenn Sie möchten, dass beide '' leeren String und ' ' mit Platz überprüfen, können Sie das tun, indem Sie gerade hinzufügen trim(), so etwas wie den folgenden Code:

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

und man kann es nennen diese Art und Weise:

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

Answer 30

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

Das ist auch eine generische Art und Weise zu überprüfen, ob Feld leer ist.