variable Wie prüft man auf eine leere Zeichenfolge in JavaScript?




javascript variable null (20)

  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 
    }
    

https://code.i-harness.com

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


Alle diese Antworten sind nett.

Ich kann jedoch nicht sicher sein, dass Variable eine Zeichenkette ist, nicht nur Leerzeichen enthält (dies ist für mich wichtig) und kann '0' (Zeichenfolge) enthalten.

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

Probe auf jsfiddle .


Die unterstrichene Javascript-Bibliothek http://underscorejs.org/ bietet eine sehr nützliche _.isEmpty() Funktion zum Überprüfen auf leere Zeichenfolgen und andere leere Objekte.

Referenz: http://underscorejs.org/#isEmpty

isEmpty _.isEmpty(object)
Gibt "true" zurück, wenn ein Aufzählungsobjekt keine Werte enthält (keine Aufzählungswerteigenschaften). Bei Strings und arrayähnlichen Objekten überprüft _.isEmpty, ob die length-Eigenschaft 0 ist.

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

_.isEmpty({});
=> wahr

Andere sehr nützliche Unterstreichungsfunktionen sind:
http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined _.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)


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 .


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

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 === '')
  ...


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

Ich benutze normalerweise etwas wie:

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

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

Ich habe keine Antwort bemerkt, die die Möglichkeit von Nullzeichen in einer Zeichenfolge berücksichtigt. Wenn wir beispielsweise eine Nullzeichenfolge 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

Um seine Nullheit zu testen, könnte man so etwas tun:

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

Es funktioniert an einer Nullzeichenfolge und an einer leeren Zeichenfolge und ist für alle Zeichenfolgen zugänglich. Außerdem könnte es erweitert werden, um andere leere JavaScript-Zeichen oder Leerzeichen (z. B. Leerzeichen, Byte-Reihenfolge, Zeilen- / Absatztrennzeichen usw.) zu enthalten.


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

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 .


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

Versuche dies

   str.value.length == 0

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ß.


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.


Wenn Sie sicherstellen müssen, dass es sich bei der Zeichenfolge nicht nur um leere Leerzeichen handelt (ich gehe davon aus, dass dies für die Formularüberprüfung gilt), müssen Sie die Leerzeichen ersetzen.

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

Wenn man nicht nur leere, sondern auch leere Zeichenketten finden muss, füge ich Gorals Antwort hinzu:

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

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

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

if (!str.length) { ...

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.





is-empty