JavaScript-Kenntnisse: Unboxing, Boxing und Typkonvertierung

Dieser Artikel vermittelt Ihnen relevantes Wissen über Javascript, das hauptsächlich Probleme im Zusammenhang mit Unboxing und Typkonvertierung vorstellt. Boxen bezieht sich auf den Vorgang der Konvertierung grundlegender Datentypen in entsprechende Referenztypen. Ich hoffe, dass dies der Fall ist allen hilfreich sein.

Verwandte Empfehlungen: Javascript-Tutorial

Grundlegende Datentypen: string, number, booleanstring、number、boolean

引用类型：object、function

不存在的类型：undefined

String、Number、Boolean分别属于string、number、boolean三个原始类型的包装类型，它们的对象属于引用类型。

装箱

装箱是指把基本数据类型转换为对应的引用类型的操作，该过程主要是指string、number、boolean类型的数据，通过String、Number、Boolean进行包装成为引用类型数据的过程。

// 隐式装箱var s1 = 'Hello World'; 
var s2 = s1.substring(2);

上面第二行代码的执行步骤其实是这样的：

1. 使用new String('Hello World')创建一个临时的实例对象；
2. 使用临时对象调用substring方法；
3. 将执行结果赋值给s2；销毁临时的实例对象。

上面的步骤转换为代码，如下：

// 显式装箱var s1 = 'Hello World'; 
var tempObj = new String('Hello World');
var s2 = tempObj.substring(2);

拆箱

拆箱是把引用类型转换为基本的数据类型。

关于拆箱过程中的ToPrimitive

类型转换

运算符对于两端的变量，都有一个期待类型，在javascript中，凡是不满足运算符期待类型的变量，都会做做隐式转换。

逻辑运算符

在进行逻辑运算时，隐式转换只有一个标准：只有 null 、undefined、 ''、 NaN、 0和 false 表示 false，其他的情况都是 true，比如 {} , []。

算术运算符

1. 如果算术运算符两端均为number类型的数据，直接进行计算；

2. 如果算术运算符两端存在非number的基本数据类型，则对非number的运算数使用Number()进行装箱，然后对返回值进行拆箱为number类型，参与计算；

3. 算术运算符两端存在引用数据类型，则先对引用类型进行拆箱操作，如果结果为非number类型，则根据条件2执行，否则执行条件1。

1 - true 
// 0， 首先 Number(true) 转换为数字 1， 然后执行 1 - 11 - null 
// 1,  首先把 Number(null) 转换为数字 0， 然后执行 1 - 01 * undefined 
//  NaN, Number(undefined) 转换为数字是 NaN , 然后执行 1 * NaN2 * ['5'] 
//  10， ['5'] 依照ToPrimitive规则进行拆箱会变成 '5', 然后通过 Number('5') 进行拆装箱再变成数字 5123 + {valueOf:()=>{return 10}}   
// 133  {valueOf:()=>{return 10}} 依照ToPrimitive规则会先调用valueOf，获得结果为10

当+作为单目运算符出现在变量的前面时，表示的意思是将变量转换为Number类型

+"10" 	
// 10  同 Number("10")+['5']  
// 5   ['5']依照ToPrimitive规则会变成 '5', 然后通过`Number`的拆箱操作再变成数字 5

字符串连接符

字符串连接符的符号同算术运算符的+ 。

1. 如果算术运算符两端均为string类型的数据，直接进行连接
2. 如果运算符的两端存在非string的基本类型，则对非string的基本类型数据使用String()进行装箱，然后对返回值进行拆箱为基本类型，参与字符串拼接。
3. 当+两端两端存在引用数据类型，则先对引用类型进行拆箱操作，如果结果为非string类型，则根据条件2执行，否则执行条件1。

关系运算符

• NaN和其他任何类型，做任何关系运算永远返回false（包括和他自己）。如果想判断一个变量是不是NaN ， 可以通过Number.isNaN()来判断。

• null == undefined比较结果是true，除此之外，null、undefined和其他的（不包括它们自身）任何结果的比较值都为false。

  这里是规则定义的，null 为 object 的类型，可是调用valueOf或者toString

  Referenztypen: object, function

Nicht vorhandene Typen: undefiniert

• String, Number , Boolean gehören jeweils zu den Verpackungstypen der drei primitiven Typen: string, number und boolean code>. Das Objekt ist vom Referenztyp.

  🎜

  Boxing

  🎜Boxing bezieht sich auf den Vorgang der Konvertierung grundlegender Datentypen in entsprechende Referenztypen. Dieser Prozess bezieht sich hauptsächlich auf string, number, boolean“ werden über String, Number, Boolean in Referenztypdaten gepackt. 🎜

  {} == !{}  
  // false   Number({}.valueOf().toString())==> NaN , 所以题目等同于 NaN == false , NaN 和 任何类型比较都是 false[] == []  
  // false  内存地址不同![] == 0  
  // true   ![]==>false , 所以题目等同于 false==0 , Number(false)==>0 ,  所以结果为 true

  🎜Die Ausführungsschritte des obigen Codes in der zweiten Zeile lauten tatsächlich wie folgt: 🎜

  🎜Verwenden Sie new String('Hello World'), um eine temporäre Instanz zu erstellen Objekt ;🎜🎜Verwenden Sie das temporäre Objekt, um die Methode substring aufzurufen. 🎜🎜Weisen Sie das Ausführungsergebnis s2 zu. Zerstören Sie das temporäre Instanzobjekt. 🎜

  🎜Die obigen Schritte werden wie folgt in Code umgewandelt: 🎜

      - 第一步，![] 会变成 false
      - 第二步，[]的valueOf是[]，[]是引用类型，继续调用toString，题目变成： "" == false
      - 第三步，符号两端转换为Number， 得到 0==0
      - 所以， 答案是 true

  Unboxing

  🎜Unboxing dient dazu, den Referenztyp in einen Basisdatentyp umzuwandeln. 🎜🎜Über ToPrimitive während des Unboxing-Prozesses🎜

  Typkonvertierung

  🎜Der Operator hat einen erwarteten Typ für die Variablen an beiden Enden. In javascript alles, was nicht den Erwartungen des Operators entspricht Typvariablen werden implizit konvertiert. 🎜

  Logische Operatoren

  🎜Bei der Durchführung logischer Operationen gibt es nur einen Standard für die implizite Konvertierung: nur null, undefiniert, '', NaN, 0 und false stellen false dar, andernfalls sind sie true , wie etwa {}, []. 🎜

  Arithmetischer Operator

  🎜🎜Wenn beide Enden des arithmetischen Operators Daten vom Typ Nummer sind, wird die Berechnung direkt durchgeführt 🎜🎜🎜🎜Wenn Arithmetik Wenn an beiden Enden des Operators Nicht-Zahl-Basisdatentypen vorhanden sind, verwenden Sie Number(), um die Nicht-Zahl-Operanden einzuschließen. und dann Der Rückgabewert wird in den Typ number entpackt und nimmt an der Berechnung teil 🎜🎜🎜🎜Wenn an beiden Enden des arithmetischen Operators Referenzdatentypen vorhanden sind, wird der Referenztyp zuerst entpackt. Wenn das Ergebnis nicht vom Typ Zahl ist, wird es gemäß Bedingung 2 ausgeführt, andernfalls wird Bedingung 1 ausgeführt. 🎜🎜

      - 第一步，[undefined]的valueOf结果为 [undefined]，然后[undefined]通过toString变成 '' ，所以题目变成  '' == false
      - 第二步，符号两端转换为Number， 得到 0==0
      - 所以， 答案是 true ！

  🎜Wenn + vor einer Variablen als unärer Operator erscheint, bedeutet dies, dass die Variable in den Typ Number konvertiert wird🎜

  var a = {
      value: 0,
      valueOf: function() {
          this.value += 1;
          return this.value    }};console.log(a == 1 && a == 2 && a == 3) // true

  String Verkettungsoperator

  🎜Das Symbol des String-Verkettungsoperators ist das gleiche wie der arithmetische Operator +. 🎜

  🎜Wenn beide Enden des arithmetischen Operators Daten vom Typ string sind, verbinden Sie sich direkt. 🎜🎜Wenn es an beiden Enden des Operators andere Grundtypen als string gibt Verwenden Sie dann String(), um die Nicht-string-Basistypdaten zu boxen, und entpacken Sie dann den Rückgabewert in einen Basistyp, um am String-Spleißen teilzunehmen. 🎜🎜Wenn an beiden Enden von + Referenzdatentypen vorhanden sind, wird der Referenztyp zuerst entpackt. Wenn das Ergebnis kein string-Typ ist, wird dies der Referenztyp sein entsprechend der Bedingung 2 entpackt werden, wird ausgeführt, andernfalls wird Bedingung 1 ausgeführt. 🎜

  Relationale Operatoren

  🎜🎜NaN und alle anderen Typen, jede relationale Operation gibt immer false zurück (einschließlich und er selbst). ). Wenn Sie feststellen möchten, ob eine Variable NaN ist, können Sie zur Bestimmung Number.isNaN() verwenden. 🎜🎜🎜🎜null == undefiniert Das Vergleichsergebnis ist wahr, außerdem null, undefiniert und Beliebig Andere Ergebnisse (ohne sich selbst) haben einen Vergleichswert von false. 🎜

  🎜Dies wird durch die Regeln definiert. null ist der Objekttyp. Beim Aufruf von valueOf oder toString treten jedoch Syntaxfehler auf. Code>. Hier ist es direkt. Merken Sie sich einfach das Ergebnis. 🎜🎜🎜🎜🎜Allgemeine Situation: 🎜<ol> <li>如果算术运算符两端均为<code>number类型的数据，直接进行计算；

  如果算术运算符两端存在非number的基本数据类型，则对非number的运算数使用Number()进行装箱，然后对返回值进行拆箱为number类型，参与计算；

  算术运算符两端存在引用数据类型，则先对引用类型进行拆箱操作，如果结果为非number类型，则根据条件2执行，否则执行条件1。

{} == !{}  
// false   Number({}.valueOf().toString())==> NaN , 所以题目等同于 NaN == false , NaN 和 任何类型比较都是 false[] == []  
// false  内存地址不同![] == 0  
// true   ![]==>false , 所以题目等同于 false==0 , Number(false)==>0 ,  所以结果为 true

一些题目

1. [] == ![]

       - 第一步，![] 会变成 false
       - 第二步，[]的valueOf是[]，[]是引用类型，继续调用toString，题目变成： "" == false
       - 第三步，符号两端转换为Number， 得到 0==0
       - 所以， 答案是 true

2. [undefined] == false

       - 第一步，[undefined]的valueOf结果为 [undefined]，然后[undefined]通过toString变成 '' ，所以题目变成  '' == false
       - 第二步，符号两端转换为Number， 得到 0==0
       - 所以， 答案是 true ！

3. 如何使a==1 && a==2 && a==3的结果为 true

   var a = {
       value: 0,
       valueOf: function() {
           this.value += 1;
           return this.value    }};console.log(a == 1 && a == 2 && a == 3) // true

4. 如何使a===1&&a===2&&a===3的结果为 true

   // 使用 defineProperty 进行数据劫持var value = 0;Object.defineProperty(window,"a",{
       get(){
           return ++value;
       }})console.log(a===1&&a===2&&a===3)  //true

5. 实现一个无限累加函数

6. 柯里化实现多参累加

相关推荐：javascript学习教程

Das obige ist der detaillierte Inhalt vonJavaScript-Kenntnisse: Unboxing, Boxing und Typkonvertierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!