Wie suche ich in JavaScript nach Nullwerten?

Wie kann ich in JavaScript nach Nullwerten suchen? Ich habe den folgenden Code geschrieben, aber er hat nicht funktioniert.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      

    alert("fill all columns");
    return false;  

}   

Und wie finde ich Fehler in meinen JavaScript-Programmen?

Javascript ist sehr flexibel in Bezug auf die Überprüfung auf "Null" -Werte. Ich vermute, Sie suchen tatsächlich nach leeren Zeichenfolgen. In diesem Fall funktioniert dieser einfachere Code:

if(!pass || !cpass || !email || !cemail || !user){

Welche für leere Strings (wird überprüft ""), null, undefined, falseund die Zahlen 0undNaN

Bitte beachten Sie, dass , wenn Sie speziell für die Zahlen überprüfen es ein häufiger Fehler zu verpassen ist 0bei dieser Methode, und num !== 0bevorzugt (oder num !== -1oder ~num(Hacky - Code, der auch Kontrollen gegen -1)) für Funktionen , die Rückkehr -1, zum Beispiel indexOf)

Um SPEZIFISCH auf Null zu prüfen , würden Sie Folgendes verwenden:

if (variable === null)

Dieser Test wird nur für passieren nullund vergehen nicht "", undefined, false, 0, oder NaN.

Zusätzlich habe ich absolute Überprüfungen für jeden "falsch-ähnlichen" Wert bereitgestellt (einer, für den true zurückgegeben wird !variable).

Beachten Sie, dass Sie für einige der absoluten Prüfungen die Verwendung von absolutely equals: ===und implementieren müssen typeof.

Ich habe hier eine JSFiddle erstellt , um zu zeigen, dass alle einzelnen Tests funktionieren

Hier ist die Ausgabe jeder Prüfung:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

Wie Sie sehen können, ist es etwas schwieriger, dagegen zu testen NaN.

ersetzen Sie einfach die ==mit ===in allen Orten.

== ist ein loser oder abstrakter Gleichheitsvergleich

=== ist ein strenger Gleichheitsvergleich

Weitere Informationen finden Sie im MDN-Artikel zu Gleichstellungsvergleichen und Gleichheit .

Strenger Gleichheitsoperator: -

Wir können null durch überprüfen ===

if ( value === null ){

}

Nur mit if

if( value ) {

}

wird als wahr ausgewertet, wenn der Wert nicht ist :

• Null
• nicht definiert
• NaN
• leerer String ("")
• falsch
• 0

Verbesserung gegenüber der akzeptierten Antwort durch explizite Überprüfung, nulljedoch mit vereinfachter Syntax:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

Erstens haben Sie eine return-Anweisung ohne Funktionskörper. Es besteht die Möglichkeit, dass dies einen Fehler auslöst.

Eine sauberere Möglichkeit, Ihre Prüfung durchzuführen, wäre die Verwendung der! Operator:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

Sie können try catch endlich verwenden

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

Sie können auch throwIhre eigenen Fehler machen. Sehen Sie das .

In JavaScript ist keine Zeichenfolge gleich null.

Vielleicht haben Sie erwartet pass == null, dass es wahr ist, wenn passes sich um eine leere Zeichenfolge handelt, weil Sie wissen, dass der Operator für lose Gleichheit ==bestimmte Arten von Typenzwang ausführt.

Zum Beispiel ist dieser Ausdruck wahr:

'' == 0

Im Gegensatz dazu ===sagt der strenge Gleichheitsoperator , dass dies falsch ist:

'' === 0

Wenn man das bedenkt ''und 0lose gleich ist, könnte man das vernünftigerweise vermuten ''und nullist locker gleich. Dies ist jedoch nicht der Fall.

Dieser Ausdruck ist falsch:

'' == null

Das Ergebnis des Vergleichs einer Zeichenfolge mit nullist falsch. Daher sind pass == nullalle Ihre anderen Tests immer falsch, und der Benutzer erhält nie die Warnung.

Vergleichen Sie jeden Wert mit der leeren Zeichenfolge, um Ihren Code zu korrigieren:

pass === ''

Wenn Sie sicher sind, dass passes sich um eine Zeichenfolge handelt, pass == ''funktioniert dies auch, da nur eine leere Zeichenfolge der leeren Zeichenfolge entspricht. Auf der anderen Seite sagen einige Experten, dass es eine gute Praxis ist, in JavaScript immer strikte Gleichheit zu verwenden, es sei denn, Sie möchten speziell den Typzwang ausführen, den der Operator für lose Gleichheit ausführt.

Wenn Sie wissen möchten, welche Wertepaare lose gleich sind, lesen Sie die Tabelle "Sameness-Vergleiche" im Mozilla-Artikel zu diesem Thema .

Um in Javascript nach undefiniert und null zu suchen, müssen Sie nur Folgendes schreiben:

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

Dies ist ein Kommentar zu WebWanderers Lösung zur Überprüfung auf NaN (ich habe noch nicht genügend Mitarbeiter, um einen formellen Kommentar zu hinterlassen). Die Lösung lautet wie folgt

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

aber dies wird für rationale Zahlen scheitern, die sich runden würden 0, wie z variable = 0.1. Ein besserer Test wäre:

if(isNaN(variable) && typeof variable === "number")

Eigentlich denke ich, dass Sie möglicherweise verwenden müssen, if (value !== null || value !== undefined) weil Sie bei Verwendung if (value)auch 0 oder falsche Werte filtern können.

Betrachten Sie diese beiden Funktionen:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

In meiner Situation musste ich nur überprüfen, ob der Wert null und undefiniert ist und ich wollte nicht filtern 0oder falseoder ''Werte. Daher habe ich den zweiten Test verwendet, aber möglicherweise müssen Sie sie auch filtern, was dazu führen kann, dass Sie den ersten Test verwenden.

Ich habe einen anderen Weg gefunden, um zu testen, ob der Wert null ist:

if(variable >= 0 && typeof variable === "object")

nullwirkt als numberund objectgleichzeitig. Vergleichen null >= 0oder null <= 0Ergebnisse in true. Ein Vergleich null === 0oder null > 0oder null < 0führt zu false. Da nulles sich aber auch um ein Objekt handelt, können wir es als Null erkennen.

Ich habe eine komplexere Funktion entwickelt , die besser funktioniert als die Art der Hexe und kann sagen, welche Typen eingeschlossen oder gruppiert werden sollen

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

Ich habe diese sehr einfache Funktion gemacht, die Wunder wirkt:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

Die Route ist jede Wertekette, die explodieren kann. Ich benutze es für jQuery / Cheerio und Objekte und so.

Beispiele 1: Ein einfaches Objekt wie dieses const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Aber es könnte ein sehr großes Objekt sein, das wir noch nicht einmal gemacht haben. Also gebe ich es durch:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

Natürlich, wenn Sie es vorziehen, können Sie verwenden nulloder 'No value'... Was auch immer Ihren Bedürfnissen entspricht.

Normalerweise kann eine DOM-Abfrage oder ein jQuery-Selektor einen Fehler auslösen, wenn er nicht gefunden wird. Aber mit so etwas wie:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

Sie können das lodash-Modul verwenden, um zu überprüfen, ob der Wert null oder undefiniert ist

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

Referenzlink: https://lodash.com/docs/#isNil

Dies funktioniert nicht, wenn boolesche Werte aus der Datenbank stammen, z.

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

AFAIK in JAVASCRIPT Wenn eine Variable deklariert ist , aber keinen Wert zugewiesen hat, ist ihr Typ undefined. so können wir Variablen überprüfen , auch wenn es wäre eine objectgewisse Halt Instanz anstelle von Wert .

Erstellen Sie eine Hilfsmethode zum Überprüfen der zurückgegebenen Nullheit trueund verwenden Sie sie in Ihrer API.

Hilfsfunktion zum Überprüfen, ob die Variable leer ist:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

Try-Catch-API-Aufruf:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

Einige Testfälle:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

Überprüfen der Fehlerbedingungen:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

Versuche dies:

if (!variable && typeof variable === "object") {
    // variable is null
}