Javascript est un langage de programmation populaire largement utilisé dans le développement Web. L'une des tâches les plus courantes en JavaScript consiste à vérifier si une variable possède un valeur ou pas . Une variable peut avoir un valeur ou nul , ce qui signifie qu’il n’a aucune valeur. Cela peut provoquer des erreurs dans votre code si vous essayez d'effectuer des opérations sur une variable nulle. Il est donc important de vérifier si une variable n’est pas nulle avant de l’utiliser.
Dans cet article, nous explorerons différentes manières de vérifier si une variable n'est pas nulle en JavaScript.
1. Utilisation de l'opérateur '!== null' :
Le moyen le plus simple de vérifier si une variable n'est pas nulle en JavaScript est d'utiliser le ' !== opérateur null . Cet opérateur vérifie si la valeur d'une variable n'est pas nulle. Voici un exemple :
let myVar = null; if (myVar !== null) { console.log('Variable is not null'); } else { console.log('Variable is null'); } La variable maVar est donné le valeur nulle dans ce code. Le si clause détermine si maVar n'est pas égal à nul. La console affichera 'La variable n'est pas nulle' si la condition est vraie (c'est-à-dire maVar est non nulle). Sinon, il s'imprimera 'La variable est nulle' à la console si la condition est fausse (c'est-à-dire que myVar est nulle).
Le résultat sera :
Variable is null
MaVar on donne la valeur nul , donc le code du bloc else est exécuté car la condition maVar!== null est évalué à faux, journalisation 'La variable est nulle' à la console.
2. Utilisation de l'opérateur 'typeof' :
Une autre façon de vérifier si une variable n'est pas nulle est d'utiliser le opérateur 'typeof' . Le opérateur 'typeof' renvoie le type d'une variable. Si une variable est nul , le 'Type de' l'opérateur reviendra 'objet'. Voici un exemple :
concaténation de chaînes
let myVar = null; if (typeofmyVar === 'object' &&myVar !== null) { console.log('Variable is not null'); } else { console.log('Variable is null'); } Dans ce code, la variable maVar on donne la valeur nul . Le type de maVar est ensuite vérifié à l'aide du type d'opérateur ator, qui donnera « objet » pour null dans ce cas.
Deux conditions sont vérifiées par l'instruction if :
typeofmyVar === 'objet' : Ce test détermine si maVar le type est « objet ». Depuis 'objet' est renvoyé par Type de null, c'est obligatoire. Cette exigence garantit que myVar est un objet et non un autre type.
maVar!== null : Ce test détermine si oui ou non maVar est égal à nul. Le Type de L'opérateur à lui seul est incapable de faire la distinction entre les objets nuls et les autres objets, ce qui nécessite une vérification supplémentaire.
MyVar enregistrera 'La variable n'est pas nulle' à la console si les deux conditions, c'est-à-dire qu'il s'agit à la fois d'un objet et non nul , sont vrai. Sinon, il affichera 'La variable est nulle' à la console si l'une des conditions est fausse.
Le résultat sera :
Variable is null
Explication:
La première condition typeofmyVar === 'objet' évalue à vrai parce que maVar a la valeur nul , mais la deuxième condition maVar!== null évalue à FAUX parce que maVar a la valeur nul . En conséquence, le code du bloc else est exécuté et 'La variable est nulle' est imprimé sur la console.
3. Utilisation du mot-clé « null » :
Vous pouvez également vérifier si une variable est nulle en utilisant le 'nul' mot-clé. Le 'nul' Le mot-clé représente l'absence de toute valeur d'objet. Voici un exemple :
let myVar = null; if (myVar !== null) { console.log('Variable is not null'); } else { console.log('Variable is null'); } Dans ce code, la variable maVar reçoit la valeur null. Le si clause détermine si maVar n'est pas égal nul .
MaVar n'est pas nulle si la condition maVar!== null évalue à vrai . La fonction du bloc if sera alors exécutée si tel est le cas. Le commentaire '// faire quelque chose' dans l'exemple, le code désigne le code que vous pouvez inclure dans le si bloquer pour réaliser l'action souhaitée lorsque la variable n'est pas nulle.
En revanche, si le test de maVar!== null Retour FAUX , maVar est en fait nul. La fonction du bloc else sera alors exécutée dans ce scénario. La variable est déclarée nulle dans le code fourni, qui enregistre 'La variable est nulle' à la console.
Le résultat sera :
Variable is null
Explication:
La condition maVar!== null est évalué à faux car la valeur null a été attribuée à maVar . En conséquence, le code du bloc else est exécuté et 'La variable est nulle' est imprimé sur la console.
4. Utilisation du double point d'exclamation (!!) :
Le double point d'exclamation est une autre façon de vérifier si une variable n'est pas nulle en JavaScript. Le double point d'exclamation est utilisé pour convertir une valeur en valeur booléenne. Si une variable n'est pas nulle, le double point d'exclamation renverra 'vrai'. Voici un exemple :
let myVar = null; if (!!myVar) { console.log('Variable is not null'); } else { console.log('Variable is null'); } Dans ce code, la variable maVar reçoit la valeur null. La variable est soumise à une double négation en utilisant le !! opérateur . Cette méthode de transformation d'une valeur en sa correspondance représentation booléenne est fréquemment utilisé.
Le double négation donnera vrai si la variable maVar est vrai . La double négation de null renverra false en JavaScript puisque null est considéré comme faux.
Suite à la double négation et avant de vérifier la booléen valeur de maVar , l'instruction if. Le code à l'intérieur du si bloquer sera effectué si la valeur de la variable, maVar , est vrai et ni nul ni faux.
caractère Java en chaîne
En revanche, si la valeur est faux, maVar est vide ou faux. La fonction du bloc else sera alors exécutée dans ce scénario. La variable est déclarée nulle dans le code fourni, qui enregistre 'La variable est nulle' à la console.
Le résultat sera :
Variable is null
Explication:
MaVar on donne la valeur nul , Ainsi, le double négation !! est utilisé, et la valeur de maVar est FAUX . En conséquence, le code du bloc else est exécuté et 'La variable est nulle' est imprimé sur la console.
5. Utilisation de l'opérateur ternaire :
Le opérateur ternaire est une façon abrégée d'écrire un déclaration 'si' . C'est une ligne unique qui peut être utilisée pour vérifier si une variable n'est pas nulle. Voici un exemple :
let myVar = null; myVar !== null ? console.log('myVar is not null') : console.log('myVar is null');
Dans ce code, la variable maVar on donne la valeur nul . La condition maVar!== null est vérifié à l'aide du opérateur ternaire ? : . MaVar n'est pas nul si l'état maVar!== null évalue à vrai . Dans cette situation, console.log('maVar n'est pas nulle') sera utilisé pour exécuter l’expression qui précède le ?.
En revanche, si le test de maVar!== null Retour FAUX , maVar est en fait nul . Dans cette situation, console.log('maVar est nulle') sera utilisé pour exécuter l’expression qui suit le :.
Le résultat sera :
myVar is null
Explication:
La condition maVar!== null évalue à FAUX car la valeur null a été attribuée à myVar. L'expression qui suit le : est donc exécutée, et 'maVar est nulle' est imprimé sur la console.
Conclusion:
Dans cet article, nous avons exploré différentes manières de vérifier si une variable n'est pas nulle en JavaScript. Que vous choisissiez d'utiliser le Opérateur '!== nul' , le opérateur 'typeof', le mot-clé « nul » , le double point d'exclamation , le opérateur ternaire , ou chaînage optionnel , il est important de toujours vérifier si une variable n'est pas nulle avant de l'utiliser pour éviter des erreurs dans votre code.
En comprenant ces différentes techniques, vous serez mieux équipé pour écrire du code JavaScript plus fiable et sans erreur. Ainsi, la prochaine fois que vous travaillerez avec des variables en JavaScript, n'oubliez pas de toujours vérifier si elles ne sont pas nulles avant de les utiliser.