Hoe controleer ik op null-waarden in JavaScript?

Hoe kan ik controleren op null-waarden in JavaScript? Ik heb de onderstaande code geschreven, maar het werkte niet.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      
    alert("fill all columns");
    return false;  
}   

En hoe kan ik fouten in mijn JavaScript-programma’s vinden?


Antwoord 1, autoriteit 100%

Javascript is erg flexibel met betrekking tot het controleren op “null”-waarden. Ik vermoed dat je eigenlijk op zoek bent naar lege strings, in welk geval deze eenvoudigere code zal werken:

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

Die zal controleren op lege strings (""), null, undefined, falseen de cijfers 0en NaN

Houd er rekening mee dat als u specifiek op getallen controleert, het een veel voorkomende fout is om 0te missen met deze methode, en num !== 0heeft de voorkeur (of num !== -1of ~num(hacky code die ook controleert op -1)) voor functies die -1, bijv indexOf)


Antwoord 2, autoriteit 64%

Om SPECIFIEKop null te controleren, zou je dit gebruiken:

if (variable === null)

Deze test zal ALLEENslagen voor nullen niet slagen voor "", undefined, false, 0of NaN.

Bovendien heb ik absolute controles gegeven voor elke “false-like” waarde (een die true zou retourneren voor !variable).

Opmerking, voor enkele van de absolute controles, moet u het gebruik van de absolutely equals: ===en typeof.

Ik heb een jsfiddle hier gemaakt om alle individuele tests te tonen

Hier is de uitvoer van elke controle:

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

Zoals je kunt zien, is het iets moeilijker om te testen tegen NaN;


Antwoord 3, autoriteit 8%

vervang gewoon overal de ==door ===.

==is een losse of abstracte gelijkheidsvergelijking

===is een strikte vergelijking van gelijkheid

Zie het MDN-artikel op Gelijkheidsvergelijkingen en gelijkheidvoor meer details.


Antwoord 4, autoriteit 4%

Strikte gelijkheidsoperator:-

We kunnen null controleren door ===

if ( value === null ){
}

Gewoon door if

. te gebruiken

if( value ) {
}

wordt geëvalueerd tot waar als waarde nietis:

  • null
  • niet gedefinieerd
  • NaN
  • lege tekenreeks (“”)
  • vals
  • 0

Antwoord 5, autoriteit 3%

U kunt als volgt controleren of een waarde null is

[pass,cpass,email,cemail,user].some(x=> x===null) 

Antwoord 6

Verbetering van het geaccepteerde antwoord door expliciet te controleren op nullmaar met een vereenvoudigde syntaxis:

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

Antwoord 7

Ten eerste heb je een return-statement zonder een function body. De kans is groot dat dat een foutmelding geeft.

Een schonere manier om uw controle uit te voeren, is door simpelweg de ! operator:

if (!pass || !cpass || !email || !cemail || !user) {
    alert("fill all columns");
}

Antwoord 8

Op het eerste gezicht lijkt het een simpele afweging tussen dekking en striktheid.

  • ==omvat meerdere waarden, kan meer scenario’s aan in minder code.
  • ===is het strengst, en dat maakt het voorspelbaar.

Voorspelbaarheid wint altijd, en dat lijkt ===een totaaloplossing te maken.

Maar het is fout. Hoewel ===voorspelbaar is, resulteert dit niet altijdin voorspelbare code, omdat het scenario’s over het hoofd ziet.

const options = { };
if (options.callback !== null) {
  options.callback();      // error --> callback is undefined.
}

Over het algemeen==doet een meer voorspelbare taak voor nulcontroles:

  • Over het algemeen betekenen nullen undefinedbeide hetzelfde: “er ontbreekt iets”. Voor voorspelbaarheid moet u beide waarden controleren. En dan doet == nullhet perfect, omdat het precies die 2 waarden dekt. (d.w.z. == nullis gelijk aan === null && === undefined)

  • In uitzonderlijke gevallen wil je weleen duidelijk onderscheidtussen nullen undefined. En in die gevallen ben je beter af met een strikte === undefinedof === null. (bijvoorbeeld een onderscheid tussen missen/negeren/overslaan en leeg/wissen/verwijderen.)Maar het is zeldzaam.

Het is niet alleen zeldzaam, het is iets om te vermijden. U kunt undefinedniet opslaan in een traditionele database. En u moet ook niet vertrouwen op undefined-waarden in uw API-ontwerpen, vanwege interoperabiliteitsredenen. Maar zelfs als je helemaal geen onderscheid maakt, je kunt er niet vanuit gaan dat undefinedniet zal gebeuren.Mensen overal om ons heen ondernemen indirect acties die null/undefined(daarom zijn vragen als dezezijn gesloten als “opinionated”.).

Dus, om terug te komen op uw vraag. Er is niets mis met het gebruik van == null. Het doet precies wat het moet doen.

// FIX 1 --> yes === is very explicit
const options = { };
if (options.callback !== null && 
    options.callback !== undefined) {
  options.callback();
}
// FIX 2 --> but == covers both
const options = { };
if (options.callback != null) {
  options.callback();
}

Antwoord 9

u kunt eindelijk proberen te vangen

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 {}   

je kunt ook je eigen fouten throw. Zie dit.


Antwoord 10

In JavaScript is geen enkele string gelijk aan null.

Misschien had je verwacht dat pass == nullwaar zou zijn als passeen lege tekenreeks is, omdat je weet dat de losse gelijkheidsoperator ==voert bepaalde soorten dwang uit.

Deze uitdrukking is bijvoorbeeld waar:

'' == 0

De operator voor strikte gelijkheid ===zegt daarentegen dat dit niet waar is:

'' === 0

Aangezien ''en 0min of meer gelijk zijn, zou je redelijkerwijs kunnen vermoeden dat ''en nullzijn losjes gelijk. Dat zijn ze echter niet.

Deze uitdrukking is niet waar:

'' == null

Het resultaat van het vergelijken van een tekenreeks met nullis onwaar. Daarom zijn pass == nullen al uw andere tests altijd onwaar en krijgt de gebruiker nooit de waarschuwing.

Om uw code te corrigeren, vergelijkt u elke waarde met de lege tekenreeks:

pass === ''

Als je zeker weet dat passeen string is, zal pass == ''ook werken omdat alleen een lege string losjes gelijk is aan de lege string. Aan de andere kant zeggen sommige experts dat het een goede gewoonte is om altijd strikte gelijkheid in JavaScript te gebruiken, tenzij je specifiek het type dwang wilt uitoefenen dat de losse gelijkheidsoperator uitvoert.

Als u wilt weten welke waardeparen losjes gelijk zijn, raadpleegt u de tabel “Gelijkheidsvergelijkingen” in de Mozilla-artikel over dit onderwerp.


Antwoord 11

om te controleren op undefineden nullin javascript, hoeft u alleen maar het volgende te schrijven:

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

Antwoord 12

Eigenlijk denk ik dat je misschien moet gebruiken
if (value !== null && value !== undefined)
want als u if (value)gebruikt, kunt u ook 0 of valse waarden filteren.

Overweeg deze twee functies:

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 mijn situatie moest ik gewoon controleren of de waarde null en ongedefinieerd is en ik wilde 0of falseof ''waarden. dus ik heb de tweede test gebruikt, maar je moet ze misschien ook filteren, waardoor je de eerste test kunt gebruiken.


Antwoord 13

Dit is een opmerking over de oplossing van WebWanderer met betrekking tot het controleren op NaN (ik heb nog niet genoeg vertegenwoordiger om een formele opmerking achter te laten). De oplossing luidt als

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

maar dit zal niet werken voor rationale getallen die zouden afronden op 0, zoals variable = 0.1. Een betere test zou zijn:

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

Antwoord 14

U kunt de lodash-module gebruiken om te controleren of de waarde null of ongedefinieerd is

_.isNil(value)
Example 
 country= "Abc"
    _.isNil(country)
    //false
   state= null
    _.isNil(state)
    //true
city= undefined
    _.isNil(state)
    //true
   pin= true
    _.isNil(pin)
    // false   

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


Antwoord 15

AFAIK in JAVASCRIPTwanneer een variabele gedeclareerdis maar geen waarde heeft, is het type undefined. zodat we de variabele kunnen controleren, zelfs als het een objectzou zijn met een instantiein plaats van waarde.

maak een hulpmethode voor het controleren van nietigheid die trueretourneert en gebruik deze in uw API.

helperfunctie om te controleren of variabele leeg is:

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

probeer uitzonderlijke API-aanroep:

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

enkele testgevallen:

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

Antwoord 16

Ik heb een andere manier gevonden om te testen of de waarde null is:

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

nullfungeert tegelijkertijd als numberen object. Het vergelijken van null >= 0of null <= 0resulteert in true. Vergelijking van null === 0of null > 0of null < 0resulteert in false. Maar aangezien nullook een object is, kunnen we het als null detecteren.

Ik heb een complexere functie natureofgemaakt die het beter zal doen dan typeof en kan worden verteld welke typen moeten worden opgenomen of gegroepeerd

/* 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")) 
}

Antwoord 17

Ik heb deze zeer eenvoudige functie gemaakt die wonderen doet:

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

De route is elke keten van waarden die kan ontploffen. Ik gebruik het voor jQuery/cheerio en objecten en dergelijke.

Voorbeelden 1: een eenvoudig object zoals dit const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Maar het kan een heel groot object zijn dat we niet eens hebben gemaakt. Dus ik geef het door:

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

Natuurlijk kun je, als je wilt, nullof 'No value'gebruiken… Wat je ook nodig hebt.

Meestal kan een DOM-query of een jQuery-selector een foutmelding geven als deze niet wordt gevonden. Maar met iets als:

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

Antwoord 18

Dit werkt niet als Booleaanse waarden afkomstig zijn van DB
bijvoorbeeld:

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

Antwoord 19

Foutcondities controleren:

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

Antwoord 20

Probeer dit:

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

Other episodes