So überprüfen Sie, ob ein Wert nicht null und keine leere Zeichenfolge in JS ist

Gibt es eine Überprüfung, ob ein Wert nicht null und keine leere Zeichenfolge in Javascript ist? Ich benutze das folgende:

var data; //get its value from db 
if(data != null && data != '') {
   // do something
}

Aber ich frage mich, ob es eine andere bessere Lösung gibt. Vielen Dank.

Wenn Sie wirklich bestätigen möchten, dass eine Variable nicht null und keine leere Zeichenfolge ist, schreiben Sie:

if(data !== null && data !== '') {
   // do something
}

Beachten Sie, dass ich Ihren Code geändert habe, um die Typgleichheit ( !==| ===) zu überprüfen .

Wenn Sie jedoch nur sicherstellen möchten, dass ein Code nur für "angemessene" Werte ausgeführt wird, können Sie, wie bereits von anderen angegeben, Folgendes schreiben:

if (data) {
  // do something
}

Da in Javascript sowohl Nullwerte als auch leere Zeichenfolgen gleich false (dh null == false) sind.

Der Unterschied zwischen diesen beiden Codeteilen besteht darin, dass für den ersten jeder Wert, der nicht spezifisch null oder eine leere Zeichenfolge ist, in den Wert eingegeben wird if. Aber auf der zweiten, jeder wahre ish Wert geben Sie if: false, 0, null, undefinedund leere Strings, würde nicht.

Beide nullund eine leere Zeichenfolge sind in JS falsche Werte. Deshalb,

if (data) { ... }

ist völlig ausreichend.

Ein Hinweis nebenbei: Ich würde vermeiden, eine Variable in meinem Code zu haben, die sich in verschiedenen Typen manifestieren könnte. Wenn die Daten irgendwann eine Zeichenfolge sein sollen, würde ich meine Variable zunächst mit einer leeren Zeichenfolge definieren, damit Sie Folgendes tun können:

if (data !== '') { ... }

ohne dass die Null (oder irgendwelche seltsamen Dinge wie data = "0") in die Quere kommt.

Anstatt zu verwenden

if(data !== null && data !== ''  && data!==undefined) {

// do something
}

Sie können unten einfachen Code verwenden

if(Boolean(value)){ 
// do something 
}

• Werte, die intuitiv "leer" sind, wie 0, eine leere Zeichenfolge, null, undefiniert und NaN, werden falsch
• Andere Werte werden wahr

Ich teste oft auf wahrheitsgemäßen Wert und auch auf leere Stellen in der Zeichenfolge:

if(!(!data || data.trim().length === 0)) {
  // do something here
}

Wenn Sie eine Zeichenfolge haben, die aus einem oder mehreren Leerzeichen besteht, wird sie als wahr ausgewertet.

if (data?.trim().length > 0) {
   //use data
}

Der ?. optionale Verkettungsoperatorundefined schließt kurz und gibt zurück, wenn Daten nullish( nulloder undefined) sind, die im ifAusdruck als falsch ausgewertet werden .

Sowohl null als auch leer können wie folgt validiert werden:

<script>
function getName(){
    var myname = document.getElementById("Name").value;
    if(myname != '' && myname != null){
        alert("My name is "+myname);
    }else{
        alert("Please Enter Your Name");
    }       
}

versuchen Sie es ----------

function myFun(){
var inputVal=document.getElementById("inputId").value;
if(inputVal){
document.getElementById("result").innerHTML="<span style='color:green'>The value is "+inputVal+'</span>';
}
else{
document.getElementById("result").innerHTML="<span style='color:red'>Something error happen! the input May be empty.</span>";
}
}

<input type="text" id="inputId">
<input type="button" onclick="myFun()" value="View Result">
<h1 id="result"></h1>

Wenn wir im Wesentlichen leer codieren, kann dies unter den gegebenen Umständen eine der folgenden Bedeutungen haben:

• 0 wie im Zahlenwert
• 0,0 wie im Float-Wert
• '0' wie im Stringwert
• '0.0' wie im Stringwert
• null wie im Nullwert, zufällig könnte es auch undefiniert erfassen oder nicht
• undefiniert wie im undefinierten Wert
• falsch wie im falschen Wahrheitswert, nach Zufall 0 auch als wahr, aber was ist, wenn wir falsch so erfassen wollen, wie es ist?
• '' leerer Stichwert ohne Leerzeichen oder Tabulator
• '' Zeichenfolge nur mit Leerzeichen oder Tabulator

In der realen Situation, wie OP angegeben hat, möchten wir sie möglicherweise alle testen oder manchmal möchten wir nur auf begrenzte Bedingungen testen.

Im Allgemeinen if(!a){return true;}erfüllt es seinen Zweck die meiste Zeit, deckt jedoch keine breiteren Bedingungen ab.

Ein weiterer Hack, der seine Runde gemacht hat, ist return (!value || value == undefined || value == "" || value.length == 0);

Aber was ist, wenn wir die Kontrolle über den gesamten Prozess brauchen?

Es gibt keine einfache Schleudertrauma-Lösung in nativem JavaScript, die übernommen werden muss. In Anbetracht der Tatsache, dass wir die Unterstützung für Legacy-IE11 einstellen (um ehrlich zu sein, sollte dies auch Windows tun), funktioniert die aus Frustration entstandene Lösung in allen modernen Browsern.

 function empty (a,b=[])
 {if(!Array.isArray(b)) return; 
 var conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
 if(conditions.includes(a)|| (typeof a === 'string' && conditions.includes(a.toString().trim())))
 {return true;};
 return false;};`

Die Logik hinter der Lösung ist, dass die Funktion zwei Parameter a und b hat hat. A ist der Wert, den wir überprüfen müssen. B ist ein Array mit festgelegten Bedingungen, die wir von den oben aufgeführten vordefinierten Bedingungen ausschließen müssen. Der Standardwert von b wird auf ein leeres Array [] gesetzt.

Der erste Funktionslauf besteht darin, zu überprüfen, ob b ein Array ist oder nicht. Wenn nicht, beenden Sie die Funktion vorzeitig.

Der nächste Schritt besteht darin, die Array-Differenz von [null,'0','0.0',false,undefined,'']und zu Array b zu berechnen . Wenn b ein leeres Array ist, bleiben vordefinierte Bedingungen bestehen, andernfalls werden übereinstimmende Werte entfernt.

Bedingungen = [vordefinierte Menge] - Die Filterfunktion [auszuschließende Menge] macht genau das, was sie nutzt. Nachdem wir die Bedingungen im Array festgelegt haben, müssen wir nur noch prüfen, ob sich der Wert im Bedingungsarray befindet. Includes- Funktion macht genau das, ohne dass Sie böse Schleifen selbst schreiben müssen. Lassen Sie die JS-Engine das schwere Heben erledigen.

Gotcha, wenn wir einen zum Vergleich in einen String konvertieren wollen, würden 0 und 0.0 gut laufen, aber Null und Undefined würden durch Fehler das gesamte Skript blockieren. Wir brauchen eine Edge-Case-Lösung. Unten einfach || deckt den Randfall ab, wenn die erste Bedingung nicht erfüllt ist. Wenn Sie ein weiteres frühes Check-Through-Include ausführen, wird das Programm vorzeitig beendet, wenn es nicht erfüllt ist.

if(conditions.includes(a)||  (['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim())))

Die Funktion trim () deckt nur breitere Leerzeichen und Tabulatoren ab und kommt nur im Randfall zum Einsatz.

Spielplatz

function empty (a,b=[]){
if(!Array.isArray(b)) return;
conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
if(conditions.includes(a)|| 
(['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim()))){
 return true;
} 
return false;
}

console.log('1 '+empty());
console.log('2 '+empty(''));
console.log('3 '+empty('      '));
console.log('4 '+empty(0));
console.log('5 '+empty('0'));
console.log('6 '+empty(0.0));
console.log('7 '+empty('0.0'));
console.log('8 '+empty(false));
console.log('9 '+empty(null));
console.log('10 '+empty(null,[null]));
console.log('11 dont check 0 as number '+empty(0,['0']));
console.log('12 dont check 0 as string '+empty('0',['0']));
console.log('13 as number for false as value'+empty(false,[false]));

Machen wir es komplex - was ist, wenn unser zu vergleichender Wert das Array selbst ist und so tief verschachtelt sein kann, wie es sein kann? Was ist, wenn wir überprüfen möchten, ob ein Wert im Array leer ist? Dies kann ein Edge-Business-Case sein.

function empty (a,b=[]){
    if(!Array.isArray(b)) return;

    conditions=[null,'0','0.0',false,undefined,''].filter(x => !b.includes(x));
    if(Array.isArray(a) && a.length > 0){
    for (i = 0; i < a.length; i++) { if (empty(a[i],b))return true;} 
    } 
    
    if(conditions.includes(a)|| 
    (['string', 'number'].includes(typeof a) && conditions.includes(a.toString().trim()))){
     return true;
    } 
    return false;
    }

console.log('checking for all values '+empty([1,[0]]));
console.log('excluding for 0 from condition '+empty([1,[0]], ['0']));

es ist eine einfache und umfassendere Anwendungsfallfunktion, die ich in mein Framework übernommen habe;

• Gibt die Kontrolle darüber, was genau die Definition von leer in einer bestimmten Situation ist
• Gibt die Kontrolle über die Neudefinition von Leerheitsbedingungen
• Kann für fast alles von String, Number, Float, Truthy, Null, Undefined und Deep Arrays vergleichen
• Die Lösung wird unter Berücksichtigung der Resuabilität und Flexibilität gezogen. Alle anderen Antworten sind für den Fall geeignet, dass ein oder zwei einfache Fälle behandelt werden sollen. Es gibt jedoch immer einen Fall, in dem die Definition leerer Änderungen beim Codieren über Snippets in diesem Fall fehlerfrei funktioniert.

Ich hatte es so satt, speziell nach null und leeren Zeichenfolgen zu suchen, dass ich jetzt normalerweise nur noch eine kleine Funktion schreibe und aufrufe, um dies für mich zu tun.

/**
 * Test if the given value equals null or the empty string.
 * 
 * @param {string} value
**/
const isEmpty = (value) => value === null || value === '';

// Test:
isEmpty('');        // true
isEmpty(null);      // true
isEmpty(1);         // false
isEmpty(0);         // false
isEmpty(undefined); // false