Wie kann ich in JavaScript nach einer leeren / undefinierten / Null-Zeichenfolge suchen?

Ich habe diese Frage gesehen , aber kein JavaScript-spezifisches Beispiel. Gibt es ein einfaches string.Emptyin JavaScript verfügbares oder ist es nur eine Frage der Suche ""?

Wenn Sie nur überprüfen möchten, ob ein Wert vorhanden ist, können Sie dies tun

if (strValue) {
    //do something
}

Wenn Sie speziell nach einer leeren Zeichenfolge über Null suchen müssen, ist es meiner Meinung nach am ""besten, mit dem ===Operator zu prüfen (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));
}

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

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

Alle vorherigen Antworten sind gut, aber das wird noch besser. Verwenden Sie den Operator !!( nicht nicht ).

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

Oder verwenden Sie Typ Casting:

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

Beide haben die gleiche Funktion. Geben Sie die Variable in Boolean ein, wobei stres sich um eine Variable handelt.
Es kehrt zurück falsefür null,undefined,0,000,"",false.
Es wird truefür die Zeichenfolge "0" und das Leerzeichen "" zurückgegeben.

Das nächste, was Sie erreichen können str.Empty(unter der Voraussetzung, dass str ein String ist), ist:

if (!str.length) { ...

Wenn Sie sicherstellen müssen, dass die Zeichenfolge nicht nur eine Reihe von Leerzeichen ist (ich gehe davon aus, dass dies zur Formularüberprüfung dient), müssen Sie die Leerzeichen ersetzen.

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

Ich benutze:

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

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

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

Aber es gibt immer truefür NumberArt von JavaScript primitiven Datentypen wie _.isEmpty(10)oder _.isEmpty(Number.MAX_VALUE)beide zurückkehren true.

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

PS: Verwenden Sie in JavaScript keinen Zeilenumbruch danach return.

Versuchen:

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

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

In JavaScript gibt es nichts, was eine leere Zeichenfolge darstellt. Führen Sie eine Überprüfung gegen length(wenn Sie wissen, dass die Variable immer eine Zeichenfolge sein wird) oder gegen""

Ich würde mir keine Sorgen um die effizienteste Methode machen. Verwenden Sie das, was Ihrer Absicht am klarsten ist. Für mich ist das normalerweise strVar == "".

Laut dem Kommentar von Constantin wäre dies in der Tat eine dieser Situationen, in denen die Absicht geklärt werden könnte, wenn strVar einen ganzzahligen Wert von 0 enthalten könnte.

Viele Antworten und viele verschiedene Möglichkeiten!

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

Es sind jedoch ebenso viele andere Beispiele verfügbar. 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ß.

Sie können auch reguläre Ausdrücke verwenden:

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

Sucht nach Zeichenfolgen, die entweder leer oder mit Leerzeichen gefüllt sind.

Performance

Ich führe Tests unter macOS 10.13.6 (High Sierra) für 18 ausgewählte Lösungen durch. Die Lösungen funktionieren etwas anders (für Eckfall-Eingabedaten), die im folgenden Snippet dargestellt wurden.

Schlussfolgerungen

• die einfachen Lösungen auf Basis von !str, ==, ===und lengthist schnell für alle Browser (A, B, C, G, I, J)
• Die Lösungen basieren auf dem regulären Ausdruck ( test, replace) und charAtsind für alle Browser am langsamsten (H, L, M, P).
• Die als am schnellsten gekennzeichneten Lösungen waren nur für einen Testlauf am schnellsten - in vielen Läufen ändert sich dies jedoch innerhalb der Gruppe "schnelle" Lösungen

Einzelheiten

Im folgenden Snippet vergleiche ich die Ergebnisse der ausgewählten 18 Methoden anhand verschiedener Eingabeparameter

• "" "a" " "- leere Zeichenfolge, Zeichenfolge mit Buchstaben und Zeichenfolge mit Leerzeichen
• [] {} f- Array, Objekt und Funktion
• 0 1 NaN Infinity - Zahlen
• true false - Boolescher Wert
• null undefined

Nicht alle getesteten Methoden unterstützen alle Eingabefälle.

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

Und dann für alle Methoden , die ich Geschwindigkeit Testfall durchführen str = ""für Browser Chrome v78.0.0, Safari v13.0.4 und Firefox v71.0.0 - können Sie Tests auf Ihrem Rechner laufen hier

1. Überprüfen Sie, ob var a;vorhanden

2. Schneiden Sie false spacesden Wert aus und testen Sie ihn aufemptiness

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

Für den Fall, dass Sie eine mit Leerzeichen gefüllte Zeichenfolge als "leer" betrachten.

Sie können es mit diesem regulären Ausdruck testen:

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

Ich benutze normalerweise so etwas,

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

Ich habe keine Antwort bemerkt, die die Möglichkeit von Nullzeichen in einer Zeichenfolge berücksichtigt. Wenn wir zum Beispiel 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 mit einer Nullzeichenfolge und einer leeren Zeichenfolge und ist für alle Zeichenfolgen zugänglich. Darüber hinaus könnte es erweitert werden, um andere leere JavaScript- oder Leerzeichen zu enthalten (z. B. nicht unterbrechendes Leerzeichen, Byte-Ordnungszeichen, Zeilen- / Absatztrennzeichen usw.).

In der Zwischenzeit können wir eine Funktion haben, die nach allen 'Leergut' wie null, undefined, '', '', {}, [] sucht . 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

Derzeit gibt es keine direkte Methode wie string.empty, um zu überprüfen, ob ein String leer ist oder nicht. In Ihrem Code können Sie jedoch eine Wrapper-Prüfung für eine leere Zeichenfolge verwenden, z.

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

}

Auf diese Weise können Sie auch sicherstellen, dass die Zeichenfolge nicht undefiniert oder auch null ist. Denken Sie daran, undefiniert, null und leer sind drei verschiedene Dinge.

Alle diese Antworten sind nett.

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

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 .

Ich habe hier keine gute Antwort gesehen (zumindest keine Antwort, die zu mir passt)

Also beschloss ich, mir selbst zu antworten:

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

Sie müssen überprüfen, ob es undefiniert ist. Andernfalls kann Ihre Methode explodieren und Sie können überprüfen, ob sie gleich null oder gleich einer leeren Zeichenfolge ist.

Das kannst du nicht haben !! oder nur if(value)seitdem, wenn Sie überprüfen, wird 0es Ihnen eine falsche Antwort geben (0 ist falsch).

Wenn dies gesagt ist, wickeln Sie es in eine Methode wie:

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

PS.: Sie müssen den Typ nicht überprüfen , da er explodieren und werfen würde, noch bevor er in die Methode eintritt

Wenn man nicht nur leere, sondern auch leere Zeichenfolgen erkennen muss, werde ich zu Gorals Antwort hinzufügen:

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

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

Versuche dies

str.value.length == 0

Sie können es einfach zu einem nativen String- Objekt in JavaScript hinzufügen und es immer wieder verwenden ...
Etwas Einfaches wie der folgende Code kann die Arbeit für Sie erledigen, wenn Sie ''leere Strings überprüfen möchten :

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

Wenn Sie andernfalls sowohl ''leere Zeichenfolgen als auch ' 'Leerzeichen überprüfen möchten , können Sie dies tun, indem Sie einfach trim()den folgenden Code hinzufügen :

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

und Sie können es so nennen:

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

Versuche dies:

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

Ich habe einige Nachforschungen angestellt, was passiert, wenn Sie einer Testerfunktion einen Wert ohne Zeichenfolge und ohne Leerzeichen / Null übergeben. Wie viele wissen, ist (0 == "") in JavaScript wahr, aber da 0 ein Wert ist und nicht leer oder null, möchten Sie ihn möglicherweise testen.

Die folgenden zwei Funktionen geben true nur für undefinierte Werte, null, leere Werte / Leerzeichen und false für alles andere zurück, z. B. Zahlen, Boolesche Werte, 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 besteht keine Notwendigkeit, auf undefiniert zu testen, da es in der Prüfung (value == null) enthalten ist. Sie können das C # -Verhalten auch nachahmen, indem Sie sie wie folgt zu String hinzufügen:

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

Sie möchten es nicht in den Strings-Prototyp einfügen, da ein Fehler auftritt, wenn die Instanz der String-Klasse null ist:

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

So überprüfen Sie, ob es sich genau um eine leere Zeichenfolge handelt:

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

So überprüfen Sie, ob es sich um eine leere Zeichenfolge ODER ein logisches Äquivalent für No-Value handelt (null, undefiniert, 0, NaN, false, ...):

if(!val)...

Es gibt keine isEmpty()Methode, Sie müssen nach Typ und Länge suchen:

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

Die Typprüfung ist erforderlich , um Laufzeitfehler zu vermeiden , wenn testist undefinedoder null.

Wenn Sie Leerzeichenfolgen ignorieren, können Sie damit nach null, leer und undefiniert suchen:

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

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

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

Es ist prägnant und funktioniert für undefinierte Eigenschaften, obwohl es nicht am besten lesbar ist.