Sortieren der JavaScript-Grunddaten

Der Inhalt dieses Artikels befasst sich mit dem Sortieren der Grunddaten von JavaScript. Er hat einen gewissen Referenzwert. Ich hoffe, dass er für Sie hilfreich ist.

Nachdem ich einige Informationen in Kombination mit ES6, Elevation und MDN gelesen hatte, habe ich die Kernwissenspunkte von JS geklärt. Aus Platzgründen stelle ich hier nur das Wissen vor, das ich für wichtig halte. Für einige Dinge des gesunden Menschenverstandes können Sie auf Elevation verweisen, und für die Erweiterung einiger Kernwissenspunkte können Sie auf meine anderen Artikel verweisen. Dieser Artikel eignet sich zur Überprüfung/Überraschung der Verwendung von JS-Wissenspunkten und kann auch als Leitfaden für Front-End-Interviews verwendet werden.

7 Datentypen

Grundlegender Datentyp: im Stapelspeicher gespeichert, auf Wert angewendet

null: Nullzeiger, also Typ von null ==>Objekt

undefiniert: Nicht zugewiesen ist definiert

Zahl: Zahl

Zeichenfolge: Zeichenfolge

Symbol: Eine Instanz ist ein eindeutiger und unveränderlicher Datentyp.

Boolescher Wert: Boolescher Wert

Referenzdatentyp: im Heap-Speicher gespeichert, arbeitet mit Raumadresse

Objekt: Insbesondere kann es sich um Array, Funktion, RegExp, Datum handeln

Beurteilen Sie den Datentyp (Methode, Vor- und Nachteile)

typeof: Kann nur Nicht-Null im Basistyp beurteilen, aber nicht den Referenzdatentyp beurteilen (da alle Objekte sind)它是操作符

typeof ''  // ==> string
typeof 1  //==> number
typeof true  //==>boolean
typeof undefined  //==>undefined
let b = Symbol() ; typeof b //==>symbol
-----------------下面的判断不了实际类型了-----------------------
typeof function fn(){} //==>function
typeof null //==>object
typeof [1,2,3] //==>object
typeof {} //==>object

instanceof: Wird verwendet, um zu testen, ob das Prototypattribut des Konstruktors irgendwo in der Prototypenkette des Objekts vorkommt. Es kann zur Beurteilung des Arrays verwendet werden, ist jedoch nicht elegant genug und birgt gewisse Risiken

let arr = [1,2,3]
arr instanceof Array //==>true
arr instanceof Object //==>true

Probleme mit dem Instanzoperator Das Problem besteht darin, dass er nur eine globale Ausführungsumgebung hat. Wenn eine Webseite mehrere Frames hat, gibt es tatsächlich mehr als zwei verschiedene globale Ausführungsumgebungen und damit mehr als zwei verschiedene Versionen des Arrays Konstrukteur. Wenn ein Array von einem Frame an einen anderen übergeben wird, haben das eingehende Array und das nativ im zweiten Frame erstellte Array unterschiedliche Konstruktoren ----height page88 (Umgangssprachliche Übersetzung des Autors:

) 风险来至原型链的重写

Konstruktor : Das Prinzip basiert auch auf der Prototypenkette. Das Risiko entsteht auch durch das Umschreiben der Prototypenkette. Wenn Sie beispielsweise zwischen mehreren Frames hin und her wechseln, stehen diese beiden Methoden im Konflikt. Da jeder Iframe über eine eigene Ausführungsumgebung verfügt, teilen sich die instanziierten Objekte nicht die Prototypenkette untereinander, daher schlägt der obige Erkennungscode fehl:

isNaN:

, also ist er nicht sehr nützlich 这个方法会先调用Number

   console.log(isNaN("1px"));   //先调用Number('1px')，返回NaN，然后再调用isNaN(NaN)返回true
   //燃鹅 '1px'客观并不是NaN

rrree---------------------------------------------------------- - ----Bessere Methode--------------------------------

Object.prototype .call()

    [1,2,3,1].constructor === Array; // true

----------------------------------------------------- -- ----------Elegante Methode-------

Wenn Sie Array beurteilen müssen

    Object.prototype.toString.call(null) // ==> [object Null]
    Object.prototype.toString.call([]) // ==> [object Array]

separat Wenn Sie null separat beurteilen müssen

Array.isArray([]) //==>true

6 Möglichkeiten, Variablen zu deklarieren

ES5 bietet nur zwei Möglichkeiten, Variablen zu deklarieren: den Befehl var und den Befehl function. Zusätzlich zum Hinzufügen der Befehle let und const wird ES6 in späteren Kapiteln auch zwei weitere Methoden zum Deklarieren von Variablen erwähnen: den Importbefehl und den Klassenbefehl. Daher verfügt ES6 über insgesamt 6 Möglichkeiten, Variablen zu deklarieren. --es6

var: Variablenförderung, kein Bereich auf Blockebene

Wenn es um var geht, muss die Variablenförderung erwähnt werden: der aktuelle Bereich, bevor js (Funktion) ausgeführt wird Der Browser bringt es dazu, dass Variablen oder Funktionen im Voraus deklariert und definiert werden

1. Variablen werden nur deklariert, Funktionen werden deklariert + zugewiesen und die Definition und Ausführung selbstausführender Funktionen wird zusammen abgeschlossen

2. Nicht von logischen Beurteilungsbedingungen betroffen

3. Die unter „Rückkehr“ aufgeführten werden ebenfalls gefördert, die unter „Rückgabe“ aufgeführten jedoch nicht.

4. Doppelte Anweisungen können neu zugewiesen werden. Das war's, aber die Variablen- und Methodennamen können nicht in Konflikt geraten

const: konstant, die Adresse bleibt unverändert, aber die Attribute können geändert werden

let: Blockbereich, temporäre Totzone (TDZ), keine Variablenförderung, wiederholte Deklarationen sind nicht zulässig

let a = null
Object.is(a , null) //==>true

import:es6 modulare Lösung

Klasse:es6-Vererbungslösung

Typkonvertierung

Dieser Abschnitt enthält zu viel Inhalt und ist zu kompliziert. Tatsächlich möchte ich ihn nicht wirklich schreiben, da nur wenige Leute solchen Code schreiben können. Aber das ist so wichtig und muss in Vorstellungsgesprächen getestet werden. Es wird empfohlen, dass jeder die Kerninhalte und Prinzipien dieses Bereichs beherrscht und nicht auf seltsame Tricks achtet.

1. Automatische Verpackung

Drei Verpackungstypen: Zahl, Boolescher Wert, Zeichenfolge

//只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。所以下面代码不报错，外层作用域和里层作用域都有一个tmp
let tmp = 123;
    if (true) {
      let tmp =123;    
    }
//ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。
    let tmp = 123;
    if (true) {
      tmp = 'abc'; // ReferenceError
      let tmp;    
    }

这些类型（构造函数）基本都重写了它们的tostring方法

2. Zwangsumwandlung in Zahl

• Zahl: Konvertieren Sie Werte anderer Datentypen in Zahlentypen.

let s1 = '123'
let s2 = s1.slice(2)         // a是基本类型，它是没有slice方法的这里实际上后台完成了一个自动装包
---下面是实际发生的事---------
let s1 = new string('123')
let s2 = s1.slice(2)     
s1 = null      //注意这里用完就销毁了

//所以如果添加某个属性后面是调用不出来的
let s1 = '123'
s1.color = 'red'
console.log(s1.color) // ==> undefind

• parseInt: Wird häufig für Zeichen verwendet. Methode für Extrahieren von Zahlen aus einer Zeichenfolge; Identifizieren Sie die Zeichenfolge von links nach rechts, bis eine ungültige Zahl gefunden wird, und geben Sie die gefundene Zahl zurück

toFixed : Die Methode zur Beibehaltung der Anzahl der Dezimalstellen,

;

•     console.log(Number({}));//NaN
      console.log(Number(null));// 0
      console.log(Number(undefined));// NaN
      console.log(Number([]));// 0
      console.log(Number(""));// 0
      console.log(Number(true));// 1
      console.log(Number(false));

  返回值是一个字符串3.-Conversion
wandelt zunächst die Zeichenfolge in eine Zahl um (

) und dann berechnen,

  console.log(parseInt("12px12"));// 12
  console.log(parseInt("12.666.777px12"));// 12
  console.log(parseInt("px12.666px12"));// NaN
  console.log(parseInt(""));// NaN
  console.log(parseInt(true));// NaN
  console.log(parseInt({}));// NaN
  console.log(parseInt([]));// NaN
  console.log(parseInt(null));// NaN
  console.log(parseInt(undefined));// NaN

Number注意NaN,undifined参与的任何计算都是NaN

Bitte sehen Sie in der Tabelle unten nach, ob eine Zeichenfolge oder eine Nummer aufgerufen werden soll

            || undefined | null   | boolean | number | string | object |
=========================================================================
 undefined  || number    | number | number  | number | string | string | 
 null       || number    | number | number  | number | string | string | 
 boolean    || number    | number | number  | number | string | string | 
 number     || number    | number | number  | number | string | string | 
 string     || string    | string | string  | string | string | string | 
 object     || string    | string | string  | string | string | string |

    //字符串和任何类型相加都是调用String
    var  a = typeof 10 + true + [] + null + undefined+{};
    console.log(a); //==>numbertruenullundefined[object Object]，{}
    console.log("6px"+undefined); ==> 6pxundefined
    console.log(NaN+"undefined");==> NaNundefined
    //经典面试题
    [1,2]+[2,1]  //==>都调用toString '1,2'+'2,1'===>'1,22,1'

5.布尔值Boolean

其他数据类型转布尔类型是false有且只有五个值： 0  ""  NaN null  undefined  
所以boolean({}) 或者boolean([]) 都是真

6.==和===

===是全等，==是类型转化后再判断，规则比较复杂。这里我认为除了准备面试需要看看，平时基本不会用，所以这个知识性价比非常低，学了用不到也会忘，大家自己把握，详细规则可以搜我其他文章
平时除了判断a是否是undefined或者是null(jq源码里面都用法)都时候其他情况下都用===

console.log(null==undefined) // true
console.log(undefined==undefined) // true

Das obige ist der detaillierte Inhalt vonSortieren der JavaScript-Grunddaten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!