Maison > Article > interface Web > Comment vérifier si une valeur est primitive en JavaScript ?
Comment vérifier si une valeur est primitive en JavaScript ?
- 王林avant
- 2023-08-26 16:33:16803parcourir
Dans ce tutoriel, nous découvrirons la méthode pour vérifier si un type de données donné est Original ou pas.
Types de données en JavaScript 1. Types de données primitifs 2. Types de données non primitifs
Types de données primitifs - chaîne, nombre, non défini, booléen, nul, symbole, bigint.
Type de données non primitif - Objet
Le type/valeur de données primitives n'est pas un objet, il est représenté comme La couche inférieure de l’implémentation du langage. Toutes les valeurs primitives sont immuables Cela signifie que vous ne pouvez pas modifier leur type, mais que vous pouvez réaffecter la nouvelle valeur de v à variable.
Pour vérifier si la valeur est une valeur primitive, on vérifie si la valeur donnée est un objet if ; La valeur que nous fournissons est un objet, ce qui signifie qu'il ne s'agit pas d'un type de données primitif utilisant certains méthode.
Méthode 1 : utiliser Object()
Nous vérifierons si la valeur donnée est de type objet en utilisant l'opérateur d'égalité stricte Parce qu'il vérifie également le type et la valeur des données. Il convertit d'abord la valeur en Objet puisque nous passerons la valeur en paramètre via objet. Si notre valeur est un objet, alors la fonction objet renverra le même objet et il sera traité comme un objet, sinon l'opérateur d'égalité stricte vérifiera et retournera false car le type ne C'est pareil.
Grammaire
inputValue !== Object(inputValue);
Définissons une fonction pour vérifier si la valeur d'entrée est de type primitif.
function isPrimitive(inputValue){
if(inputValue===Object(inputValue)){
return "Value is not primitive";
}
else{
return "Value is primitive";
}
}
Exemple
Dans l'exemple ci-dessous, on vérifie les valeurs suivantes si elles sont primitives.
vide
Nombres
Chaîne
Objet chaîne
Booléen
tableau
tableau vide
Texte de l'objet
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h2>Check if the value is primitive or not</h2>
<p id="result"></p>
</body>
<script type="text/javascript">
function isPrimitive(inputValue) {
if (inputValue === Object(inputValue)) {
console.log("Value is not primitive")
document.getElementById("result").innerHTML += inputValue +": not primitive <br>"
} else {
console.log("Value is primitive")
document.getElementById("result").innerHTML += inputValue +": primitive <br>"
}
}
isPrimitive(null)
isPrimitive(12)
isPrimitive("This is simple string")
isPrimitive(new String("This is string object"))
isPrimitive(false)
isPrimitive([1, 2, 3])
isPrimitive([])
isPrimitive({})
</script>
</html>
Méthode 2 : Utiliser le type d'opérateur
Dans cette méthode, nous vérifierons le type de données à l'aide de l'opérateur typeof et nous savons que les types de données non primitifs sont toujours des types d'objet, nous vérifierons donc si notre valeur est du type suivant Objet ou pas.
Si notre valeur n'est pas de type objet ou fonction, alors c'est une primitive sinon elle n'est pas primitive. Nous devons également gérer le cas nul, puisque null est une valeur de type primitif, mais typeof le fera Si nous vérifions typeof(null) alors la sortie est affichée sous forme d'objet.
function isPrimitive(inputValue){
if(inputValue==null)
{
return "Value is primitive";
}
if(typeof(inputValue)=="function" || typeof(inputValue)=="object"){
return "Value is not primitive"
}
else{
return "Value is not primitive"
}
}
Exemple
Dans l'exemple ci-dessous, on vérifie si les différentes valeurs sont des valeurs d'origine. Vérifiez si Que la valeur soit une valeur primitive, nous utilisons l'opérateur typeof. Nous vérifions si le type est fonction ou objet. Si le type est une fonction ou un objet, la valeur n'est pas une primitive tapez ; sinon, c’est primitif.
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h2>Check if the value is primitive or not</h2>
<div id="result"></div>
</body>
<script type="text/javascript">
function isPrimitive(inputValue){
if(inputValue==null)
{
return `primitive <br>`;
}
if(typeof(inputValue)=="function" || typeof(inputValue)=="object"){
return `not primitive <br>`;
}
else{
return `primitive <br>`;
}
}
let resultDiv = document.getElementById("result");
resultDiv.innerHTML += "12: " + isPrimitive(12);
resultDiv.innerHTML += "null: " + isPrimitive(null);
resultDiv.innerHTML += "false: " + isPrimitive(false);
resultDiv.innerHTML += "[1,2,3]: " + isPrimitive([1,2,3]);
resultDiv.innerHTML += `"This is simple string": ` + isPrimitive("This is simple string");
resultDiv.innerHTML += "new String(): " + isPrimitive(new String("This is string object"));
resultDiv.innerHTML += "[]: " + isPrimitive([]);
resultDiv.innerHTML += "{}: " + isPrimitive({});
resultDiv.innerHTML += "new Date(): " + isPrimitive(new Date());
</script>
</html>
Nous devons donc savoir comment vérifier si une valeur donnée est une valeur de type primitif ou une valeur non primitive.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!