Comment vérifier les valeurs nulles en JavaScript?

Comment puis-je vérifier les valeurs nulles en JavaScript? J'ai écrit le code ci-dessous mais cela n'a pas fonctionné.

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

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

}   

Et comment puis-je trouver des erreurs dans mes programmes JavaScript?

Javascript est très flexible en ce qui concerne la vérification des valeurs "nulles". Je suppose que vous recherchez en fait des chaînes vides, auquel cas ce code plus simple fonctionnera:

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

Qui vérifie la présence des chaînes vides ( ""), null, undefined, falseet les numéros 0etNaN

Veuillez noter que si vous vérifiez spécifiquement les nombres, c'est une erreur courante de manquer 0avec cette méthode, et num !== 0est préférée (ou num !== -1ou ~num(code hacky qui vérifie également -1)) pour les fonctions qui retournent -1, par exemple indexOf)

Pour vérifier NUL SPÉCIFIQUEMENT, vous utiliseriez ceci:

if (variable === null)

Ce test seulement passer pour nullet ne passera pas pour "", undefined, false, 0ou NaN.

De plus, j'ai fourni des vérifications absolues pour chaque valeur "false-like" (celle qui retournerait true pour !variable).

Notez que pour certaines des vérifications absolues, vous devrez implémenter l'utilisation de absolutely equals: ===et typeof.

J'ai créé un JSFiddle ici pour montrer tous les tests individuels qui fonctionnent

Voici la sortie de chaque contrôle:

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

Comme vous pouvez le voir, c'est un peu plus difficile à tester NaN;

remplacez simplement le ==par ===dans tous les endroits.

== est une comparaison d'égalité lâche ou abstraite

=== est une comparaison stricte d'égalité

Voir l'article de MDN sur les comparaisons d'égalité et la similitude pour plus de détails.

Opérateur d'égalité stricte: -

Nous pouvons vérifier null par ===

if ( value === null ){

}

Juste en utilisant if

if( value ) {

}

sera évalué à vrai si la valeur n'est pas :

• nul
• indéfini
• NaN
• chaîne vide ("")
• faux
• 0

Amélioration de la réponse acceptée en vérifiant explicitement nullmais avec une syntaxe simplifiée:

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

Tout d'abord, vous avez une instruction return sans corps de fonction. Il y a de fortes chances que cela génère une erreur.

Une façon plus propre de faire votre vérification serait d'utiliser simplement le! opérateur:

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

    alert("fill all columns");

}

vous pouvez enfin utiliser try catch

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

vous pouvez également throwvos propres erreurs. Regardez ça .

En JavaScript, aucune chaîne n'est égale à null.

Peut-être vous attendiez-vous pass == nullà être vrai quand passest une chaîne vide parce que vous savez que l'opérateur d'égalité lâche ==effectue certains types de coercition de type.

Par exemple, cette expression est vraie:

'' == 0

En revanche, l'opérateur d'égalité stricte ===dit que c'est faux:

'' === 0

Étant donné que '' et 0sont vaguement égaux, vous pourriez raisonnablement supposer cela ''et nullsont vaguement égaux. Mais ce n'est pas le cas.

Cette expression est fausse:

'' == null

Le résultat de la comparaison d'une chaîne à nullest faux. Par conséquent, pass == nulltous vos autres tests sont toujours faux et l'utilisateur ne reçoit jamais l'alerte.

Pour corriger votre code, comparez chaque valeur à la chaîne vide:

pass === ''

Si vous êtes certain que pass s'agit d'une chaîne, pass == ''cela fonctionnera également car seule une chaîne vide est à peu près égale à la chaîne vide. D'un autre côté, certains experts disent que c'est une bonne pratique de toujours utiliser une égalité stricte dans JavaScript, sauf si vous voulez spécifiquement faire la coercition de type que l'opérateur d'égalité lâche effectue.

Si vous voulez savoir quelles paires de valeurs sont approximativement égales, consultez le tableau "Comparaisons de similitude" dans l' article de Mozilla sur ce sujet .

pour vérifier non défini et null en javascript, il vous suffit d'écrire ce qui suit:

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

Ceci est un commentaire sur la solution de WebWanderer concernant la vérification de NaN (je n'ai pas encore assez de représentant pour laisser un commentaire formel). La solution se lit comme suit:

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

mais cela échouera pour les nombres rationnels qui arrondiraient à 0, tels que variable = 0.1. Un meilleur test serait:

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

En fait, je pense que vous devrez peut-être utiliser if (value !== null || value !== undefined) parce que si vous utilisezif (value) vous pouvez également filtrer 0 ou de fausses valeurs.

Considérez ces deux fonctions:

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

Dans ma situation, j'avais juste besoin de vérifier si la valeur était nulle et non définie et je ne voulais pas filtrer les valeurs 0ou falseou ''. J'ai donc utilisé le deuxième test, mais vous devrez peut-être également les filtrer, ce qui pourrait vous obliger à utiliser le premier test.

J'ai trouvé une autre façon de tester si la valeur est nulle:

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

nullagit comme un numberet objecten même temps. Comparaison null >= 0ou null <= 0résultats true. Comparer null === 0ounull > 0 ou null < 0entraînera un faux. Mais comme nullc'est aussi un objet, nous pouvons le détecter comme nul.

J'ai fait une fonction plus complexe, la nature de la sorcière fera mieux que le type et je peux dire quels types inclure ou garder groupés

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

J'ai fait cette fonction très simple qui fait des merveilles:

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

L'itinéraire est la chaîne de valeurs qui peut exploser. Je l'utilise pour jQuery / cheerio et des objets et autres.

Exemples 1: un objet simple comme celui-ci const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Mais ce pourrait être un très grand objet que nous n'avons même pas fabriqué. Je passe donc par:

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

Bien sûr, si vous préférez, vous pouvez utiliser nullou'No value' ... ce qui convient à vos besoins.

Habituellement, une requête DOM ou un sélecteur jQuery peut générer une erreur s'il n'est pas trouvé. Mais en utilisant quelque chose comme:

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

Vous pouvez utiliser le module lodash pour vérifier que la valeur est nulle ou non définie

_.isNil(value)
Example 

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

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

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

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

Lien de référence: https://lodash.com/docs/#isNil

Cela ne fonctionnera pas en cas de valeurs booléennes provenant de DB par exemple:

 value = false

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

AFAIK dans JAVASCRIPT lorsqu'une variable est déclarée mais n'a pas de valeur assignée, son type est undefined. afin que nous puissions vérifier la variable même si ce serait une objectdétention d'une instance à la place de la valeur .

créer une méthode d'assistance pour vérifier la nullité qui retourne trueet l'utiliser dans votre API.

fonction d'assistance pour vérifier si la variable est vide:

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

essayez d'appeler un appel d'API exceptionnel:

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

quelques cas de test:

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

Vérification des conditions d'erreur:

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

Essaye ça:

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