null prüfen - Wie prüft man auf eine leere Zeichenfolge in JavaScript?



ob variable (25)

Ich habe diesen thread , aber kein JavaScript-spezifisches Beispiel gesehen. Gibt es eine einfache string.Empty in JavaScript verfügbar, oder ist es nur eine Überprüfung auf "" ?


Answers

Ich habe etwas recherchiert, was passiert, wenn Sie einer Testerfunktion einen Nicht-String und einen nicht leeren / Nullwert übergeben. Wie viele wissen, ist (0 == "") in Javascript wahr, aber da 0 ein Wert ist und nicht leer oder null ist, sollten Sie ihn testen.

Die folgenden beiden Funktionen geben nur für undefined, null, empty / whitespace-Werte true und false für alles andere zurück, wie z. B. Zahlen, Boolesche Objekte, Objekte, Ausdrücke usw.

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

Es gibt kompliziertere Beispiele, die jedoch einfach sind und konsistente Ergebnisse liefern. Es ist nicht erforderlich, auf undefined zu testen, da es in der Prüfung (Wert == null) enthalten ist. Sie können das Verhalten von C # auch nachahmen, indem Sie sie wie folgt zu String hinzufügen:

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

Sie möchten es nicht in einen Strings-Prototyp einfügen, denn wenn die Instanz der String-Klasse NULL ist, wird Folgendes ausgegeben:

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

Ich habe mit dem folgenden Wertefeld getestet. Sie können es durchlaufen, um 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; } }]
];

Gehen Sie nicht davon aus, dass die überprüfte Variable eine Zeichenfolge ist. Gehen Sie nicht davon aus, dass diese Variable eine Zeichenfolge ist, wenn diese Variable eine Länge hat.

Die Sache ist: Denken Sie sorgfältig darüber nach, was Ihre App tun muss und akzeptieren kann. Baue etwas Robustes.

Wenn Ihre Methode / Funktion nur eine nicht leere Zeichenfolge verarbeiten soll, testen Sie, ob das Argument eine nicht leere Zeichenfolge ist, und führen Sie keinen 'Trick' aus.

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


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 würde ich bei bleiben


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


Viele Antworten und viele verschiedene Möglichkeiten!

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

Es stehen jedoch so viele andere Beispiele zur Verfügung. Die beste funktionale Methode, um dies zu erreichen, 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ß.


  1. überprüfe das var a; existieren
  2. Die false spaces im Wert ausschneiden und auf emptiness prüfen

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

Wenn Sie Whitespace-Zeichenfolgen ignorieren, können Sie dies auf null, leer und undefined überprüfen:

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

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

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

Kurz und es funktioniert für undefinierte Eigenschaften, obwohl es nicht am lesbarsten ist.


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

In JavaScript steht nichts für eine leere Zeichenfolge. Überprüfen Sie entweder die length (wenn Sie wissen, dass die Variable immer eine Zeichenfolge ist) oder gegen ""


Funktion:

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

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

Sie könnten auch mit Regexs gehen:

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

Überprüft, ob Zeichenfolgen leer oder mit Leerzeichen gefüllt sind.


In der Zwischenzeit können wir eine Funktion haben, die auf alle 'Leergüter' prüft, wie null, undefined, '', '', {}, [] . Also habe ich das gerade geschrieben.

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

um zu überprüfen, ob genau eine leere Zeichenfolge ist:

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

Um zu überprüfen, ob es sich um einen leeren String handelt ODER ein logisches Äquivalent für keinen Wert (null, undefined, 0, NaN, false, ...):

if(!val)...

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

Es deckt viele Fälle ab wie {} , '' , null , undefined usw.

Es gibt jedoch immer true für den Number Typ von primitiven Javascript-Datentypen wie _.isEmpty(10) oder _.isEmpty(Number.MAX_VALUE) zurück. Beide geben true .


Ich benutze normalerweise so etwas,

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

Ich benutze normalerweise etwas wie:

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

Es gibt keine isEmpty() -Methode, Sie müssen 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 .


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

Dies ist auch eine generelle Methode, um zu überprüfen, ob das Feld leer ist.


Wenn Sie nur prüfen möchten, ob es einen Wert gibt, können Sie dies tun

if (strValue) {
    //do something
}

Wenn Sie speziell nach einer leeren Zeichenfolge über Null === , würde ich denken, dass das === mit "" Ihre beste Wette ist. Verwenden Sie den Operator === (damit Sie wissen, dass es sich tatsächlich um eine Zeichenfolge handelt, mit der Sie vergleichen.) ).

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

Um zu überprüfen, ob eine Zeichenfolge leer, null oder undefiniert ist, verwende ich:

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

Um zu überprüfen, ob eine Zeichenfolge leer, null oder undefiniert ist, verwende ich:

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

Um zu überprüfen, ob eine Zeichenfolge leer ist oder nur Leerzeichen enthält:

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

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

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

oder verwenden Sie Typguss:

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

Beide haben dieselbe Funktion, geben Sie die Variable in boolean um, wobei str eine Variable ist.
Gibt false für null,undefined,0,000,"",false .
Gibt " true für String "0" und Leerzeichen "" zurück.


Ich benutze eine Kombination. Schnellste Prüfungen stehen an erster Stelle.

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

str.Empty (mit der Voraussetzung, dass str ein String ist) ist am nächsten:

if (!str.length) { ...

Versuche dies

   str.value.length == 0

Versuchen:

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

Für den Fall, dass Sie eine mit Leerzeichen gefüllte Zeichenfolge als "leer" betrachten. Sie können es mit dieser Regex testen:

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

Der Autor von Closures hat Schließungen ziemlich gut erklärt, den Grund erklärt, warum wir sie brauchen, und auch LexicalEnvironment, das zum Verständnis von Schließungen notwendig ist.
Hier ist die Zusammenfassung:

Was ist, wenn auf eine Variable zugegriffen wird, diese aber nicht lokal ist? Wie hier:

In diesem Fall findet der Interpreter die Variable im äußeren LexicalEnvironmentObjekt.

Der Prozess besteht aus zwei Schritten:

  1. Wenn eine Funktion f erstellt wird, wird sie nicht in einem leeren Bereich erstellt. Es gibt ein aktuelles LexicalEnvironment-Objekt. Im obigen Fall ist es das Fenster (a ist zum Zeitpunkt der Funktionserstellung undefiniert).

Wenn eine Funktion erstellt wird, erhält sie eine verborgene Eigenschaft namens [[Scope]], die auf die aktuelle LexicalEnvironment verweist.

Wenn eine Variable gelesen wird, aber nirgendwo gefunden werden kann, wird ein Fehler generiert.

Verschachtelte Funktionen

Funktionen können ineinander verschachtelt werden und bilden eine Kette von LexicalEnvironments, die auch als Scope-Chain bezeichnet werden kann.

Funktion g hat also Zugriff auf g, a und f.

Verschlüsse

Eine verschachtelte Funktion kann weiterleben, nachdem die äußere Funktion abgeschlossen ist:

Markieren von Lexikalischen Umgebungen:

Wie wir sehen, this.sayist eine Eigenschaft im Benutzerobjekt, also lebt es weiter, nachdem der Benutzer abgeschlossen ist.

Wenn Sie sich erinnern, wann sie this.sayerstellt wird, erhält sie (wie jede Funktion) einen internen Verweis this.say.[[Scope]]auf die aktuelle LexicalEnvironment. Die LexicalEnvironment der aktuellen User-Ausführung bleibt also im Speicher. Alle Variablen des Benutzers sind auch seine Eigenschaften. Daher werden sie auch sorgfältig aufbewahrt und nicht wie üblich als Junk-Objekte verwendet.

Es geht darum, sicherzustellen, dass die innere Funktion in der Lage ist, auf eine äußere Variable zuzugreifen.

Zusammenfassen:

  1. Die innere Funktion enthält einen Verweis auf die äußere LexicalEnvironment.
  2. Die innere Funktion kann jederzeit auf Variablen von ihr zugreifen, auch wenn die äußere Funktion beendet ist.
  3. Der Browser speichert die LexicalEnvironment und alle ihre Eigenschaften (Variablen) im Speicher, bis eine innere Funktion vorhanden ist, die auf sie verweist.

Dies wird als Schließung bezeichnet.





javascript null is-empty