In diesem Tutorial lernen wir die Methode kennen, mit der überprüft werden kann, ob ein bestimmter Datentyp vorhanden ist
Original oder nicht.
Datentypen in JavaScript 1. Primitive Datentypen 2. Nicht-primitive Datentypen
Primitive Datentypen – Zeichenfolge, Zahl, undefiniert, Boolescher Wert, Null, Symbol, Bigint.
Nicht-primitiver Datentyp – Objekt
Primitiver Datentyp/-wert ist kein Objekt, sondern wird als dargestellt
Die unterste Ebene der Sprachimplementierung. Alle primitiven Werte sind unveränderlich
Das bedeutet, dass Sie ihren Typ nicht ändern können, aber den neuen Wert von v neu zuweisen können
Variable.
Um zu überprüfen, ob der Wert ein primitiver Wert ist, prüfen wir, ob der angegebene Wert ein Objekt ist
Der von uns bereitgestellte Wert ist ein Objekt, was bedeutet, dass es sich nicht um einen primitiven Datentyp handelt, der einige verwendet
Verfahren.
Methode 1: Verwenden Sie Object()
Wir prüfen mithilfe des strikten Gleichheitsoperators, ob der angegebene Wert vom Objekttyp ist
Denn es überprüft auch den Datentyp und -wert. Es konvertiert zunächst den Wert in
Objekt, da wir den Wert als Parameter über das Objekt übergeben. Wenn unser Wert ist
ein Objekt, dann gibt die Objektfunktion dasselbe Objekt zurück und es wird als behandelt
Objekt, andernfalls prüft der strikte Gleichheitsoperator und gibt false zurück, da dies beim Typ nicht der Fall ist
Es ist das Gleiche.
Grammatik
inputValue !== Object(inputValue);
Nach dem Login kopieren
Lassen Sie uns eine Funktion definieren, um zu prüfen, ob der Eingabewert vom primitiven Typ ist.
function isPrimitive(inputValue){
if(inputValue===Object(inputValue)){
return "Value is not primitive";
}
else{
return "Value is primitive";
}
}
Nach dem Login kopieren
Beispiel
Im folgenden Beispiel prüfen wir die folgenden Werte, ob sie primitiv sind.
leer
Zahlen
String
String-Objekt
Boolean
Array
leeres Array
Objekttext
<!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>
Nach dem Login kopieren
Methode 2: Typoperator verwenden
In dieser Methode überprüfen wir den Datentyp mit dem Operator typeof und wissen, dass nicht-primitive Datentypen immer Objekttypen sind, also prüfen wir, ob unser Wert vom folgenden Typ ist
Objekt oder nicht.
Wenn unser Wert nicht vom Typ Objekt oder Funktion ist, dann ist er ein Primitiv; andernfalls ist er kein Primitiv.
Wir müssen auch den Null-Fall behandeln, da null ein primitiver Typwert ist, aber typeof wird dies tun
Wenn wir typeof(null) überprüfen, wird die Ausgabe als Objekt angezeigt.
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"
}
}
Nach dem Login kopieren
Beispiel
Im folgenden Beispiel prüfen wir, ob es sich bei den unterschiedlichen Werten um Originalwerte handelt. Überprüfen Sie, ob
Unabhängig davon, ob es sich bei dem Wert um einen primitiven Wert handelt, verwenden wir den Operator „typeof“. Wir prüfen, ob der Typ vorhanden ist
Funktion oder Objekt. Wenn der Typ eine Funktion oder ein Objekt ist, ist der Wert kein Grundelement
Typ; andernfalls ist es primitiv.
<!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>
Nach dem Login kopieren
Wir müssen also wissen, wie wir überprüfen können, ob ein gegebener Wert ein Wert vom primitiven Typ oder ein nicht-primitiver Wert ist.
Das obige ist der detaillierte Inhalt vonWie überprüfe ich, ob ein Wert in JavaScript primitiv ist?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
