Beim Typzwang wird der Wert von einem Typ in einen anderen konvertiert (z. B. Zeichenfolge in Zahl, Objekt in Boolescher Wert usw.). Jeder Typ, sei es primitiv oder ein Objekt, ist ein gültiges Subjekt für Typenzwang. Um sich zu erinnern, sind Grundelemente: Zahl, Zeichenfolge, Boolescher Wert, Null, undefiniert + Symbol (in ES6 hinzugefügt).
Impliziter oder expliziter Zwang
Typ-Zwang kann explizit und implizit sein.
Wenn ein Entwickler die Absicht zum Ausdruck bringt, zwischen Typen zu konvertieren, indem er den entsprechenden Code schreibt, spricht Number(value)man von explizitem Typenzwang (oder Typumwandlung).
Da JavaScript eine schwach typisierte Sprache ist, können Werte auch automatisch zwischen verschiedenen Typen konvertiert werden. Dies wird als impliziter Typenzwang bezeichnet. Es geschieht in der Regel , wenn Sie Operatoren auf Werte verschiedenen Typen gelten, wie
1 == null, 2/’5', null + new Date()oder es kann durch den umgebenden Kontext ausgelöst werden, wie mit if (value) {…}, wo Wert auf boolean wird dazu gezwungen.
Ein Operator, der keinen impliziten Typzwang auslöst ===, ist der Operator für strikte Gleichheit. Der lose Gleichheitsoperator ==hingegen führt bei Bedarf sowohl Vergleiche als auch Typzwang durch.
Impliziter Typenzwang ist ein zweischneidiges Schwert: Es ist eine große Quelle für Frustration und Fehler, aber auch ein nützlicher Mechanismus, mit dem wir weniger Code schreiben können, ohne die Lesbarkeit zu verlieren.
Drei Arten der Konvertierung
Die erste Regel, die Sie kennen sollten, ist, dass es in JavaScript nur drei Arten der Konvertierung gibt:
- zu bespannen
- zu boolesch
- zu nummerieren
Zweitens funktioniert die Konvertierungslogik für Grundelemente und Objekte unterschiedlich, aber sowohl Grundelemente als auch Objekte können nur auf diese drei Arten konvertiert werden.
Beginnen wir zuerst mit Primitiven.
String-Konvertierung
Um Werte explizit in einen String zu konvertieren, wenden Sie die Funktion String () an. Impliziter Zwang wird vom binären + Operator ausgelöst, wenn ein Operand eine Zeichenfolge ist:
String(123) // explicit
123 + '' // implicit
Alle primitiven Werte werden natürlich wie erwartet in Zeichenfolgen konvertiert:
String(123) // '123'
String(-12.3) // '-12.3'
String(null) // 'null'
String(undefined) // 'undefined'
String(true) // 'true'
String(false) // 'false'
Die Symbolkonvertierung ist etwas schwierig, da sie nur explizit, aber nicht implizit konvertiert werden kann.
String(Symbol('my symbol')) // 'Symbol(my symbol)'
'' + Symbol('my symbol') // TypeError is thrown
Boolesche Konvertierung
Um einen Wert explizit in einen Booleschen Wert zu konvertieren, wenden Sie die Boolean()Funktion an. Die implizite Konvertierung erfolgt im logischen Kontext oder wird von logischen Operatoren ( || && !) ausgelöst .
Boolean(2) // explicit
if (2) { ... } // implicit due to logical context
!!2 // implicit due to logical operator
2 || 'hello' // implicit due to logical operator
Hinweis: Logische Operatoren führen beispielsweise || and &&intern boolesche Konvertierungen durch, geben jedoch den Wert der ursprünglichen Operanden zurück, auch wenn sie nicht boolesch sind.
// returns number 123, instead of returning true
// 'hello' and 123 are still coerced to boolean internally to calculate the expression
let x = 'hello' && 123; // x === 123
Sobald es nur zwei mögliche Ergebnisse der Booleschen Konvertierung gibt: wahr oder falsch, ist es einfacher, sich die Liste der falschen Werte zu merken.
Boolean('') // false
Boolean(0) // false
Boolean(-0) // false
Boolean(NaN) // false
Boolean(null) // false
Boolean(undefined) // false
Boolean(false) // false
Jeder Wert, der nicht in der Liste enthalten ist umgewandelt wird true, einschließlich object, function, Array, Date, benutzerdefinierter Typ, und so weiter. Symbole sind wahrheitsgemäße Werte. Leere Objekte und Arrays sind ebenfalls wahrheitsgemäße Werte:
Boolean({}) // true
Boolean([]) // true
Boolean(Symbol()) // true
!!Symbol() // true
Boolean(function() {}) // true
Numerische Konvertierung
Wenden Sie für eine explizite Konvertierung einfach die Number()Funktion an, genau wie Sie es mit Boolean()und getan haben String().
Die implizite Konvertierung ist schwierig, da sie in mehreren Fällen ausgelöst wird:
Vergleichsoperatoren (>, <, <=,> =)
bitweise Operatoren (| & ^ ~)
arithmetische Operatoren (- + * /%). Beachten Sie, dass binäres + keine numerische Konvertierung auslöst, wenn ein Operand eine Zeichenfolge ist.
unär + Operator
loser Gleichheitsoperator == (inkl.! =).
Beachten Sie, dass == keine numerische Konvertierung auslöst, wenn beide Operanden Zeichenfolgen sind.
Zahl ('123') // explizit + '123' // implizit 123! = '456' // implizit 4> '5' // implizit 5 / null // implizit wahr | 0 // implizit
So werden primitive Werte in Zahlen umgewandelt:
Number(null) // 0
Number(undefined) // NaN
Number(true) // 1
Number(false) // 0
Number(" 12 ") // 12
Number("-12.34") // -12.34
Number("\n") // 0
Number(" 12s ") // NaN
Number(123) // 123
(true == 1) => true/(true === 1) => false.