Sortieren von Interview-Wissenspunkten in js

Schreiben Sie hier den Linkinhalt1. Welche Datentypen gibt JavaScript zurück? Zuallererst werden JavaScript-Datentypen in zwei Kategorien unterteilt: primitive Typen und Referenztypen. Ich hoffe, es kann jedem helfen.

Primitive Typen: null, undefiniert, Zahl, Zeichenfolge, Boolescher Wert
Referenztypen: Objekt, Symbol (ES6)
(Was den Unterschied zwischen primitiven Typen und Referenztypen betrifft, können Sie einen davon sehen meine Blog-Beiträge: Js grundlegende Syntax, Variablen, Datentypen)
Dann kann der Typeof-Operator alle primitiven Typen bestimmen. typeof gibt sieben mögliche Werte zurück: „Zahl“, „Zeichenfolge“, „boolean“, „Objekt“, „Symbol“, „Funktion“ und „undefiniert“.

2. Bitte schreiben Sie die folgenden Operationsergebnisse

alert(typeof null); //object 
alert(typeof undefined);//undefined 
alert(typeof NaN);//number 
alert(NaN == undefined);//false 
alert(NaN == NaN);//false 
var str = “123abc”; 
alert(typeof str++); 
alert(str);//string

3. Warum gibt es eine Instanz des Operators?

typeof ist eine unäre Operation, die vor einem Operanden platziert wird, und der Operand kann von jedem beliebigen Typ sein. Ein Problem tritt auf, wenn ein Referenztyp zum Speichern eines Werts verwendet wird, wenn der Operator „typeof“ verwendet wird, der „Objekt“ zurückgibt, unabhängig vom Typ des Objekts, auf das verwiesen wird. Bei speziellen Objekten wie Array und Null wird bei Verwendung von typeof immer ein Objekt zurückgegeben. Dies ist die Einschränkung von typeof.

instanceof wird verwendet, um zu bestimmen, ob eine Variable eine Instanz eines Objekts ist ,

wie zum Beispiel:

var a=new Array();
Alert(eine Instanz eines Arrays); gibt true zurück,
Gleichzeitig
Alert(eine Instanz von Object) gibt ebenfalls true zurück;

Ein weiteres Beispiel:

Funktionstest(){};
var a=new test();
Alert(eine Instanz von Test); gibt true zurück

Darüber hinaus ist der wichtigere Punkt, dass „Instanceof“ in Vererbungsbeziehungen verwendet werden kann, um zu bestimmen, ob eine Instanz zu ihrem übergeordneten Typ gehört. Beispiel:

function Aoo(){} 
function Foo(){} 
Foo.prototype = new Aoo();//JavaScript 原型继承var foo = new Foo(); 
console.log(foo instanceof Foo)//true console.log(foo instanceof Aoo)//true

Der obige Code bestimmt die übergeordnete Klasse in einer einstufigen Vererbungsbeziehung. In einer mehrstufigen Vererbungsbeziehung ist auch der Instanzoperator anwendbar.

console.log(Object instanceof Object);//true console.log(Function instanceof Function);//true console.log(Number instanceof Number);//false console.log(String instanceof String);//false console.log(Function instanceof Object);//true console.log(Foo instanceof Function);//true console.log(Foo instanceof Foo);//false

Sind Sie wieder verwirrt, nachdem Sie den obigen Code gelesen haben? Warum sind Objekt- und Funktionsinstanzen für sich selbst gleich wahr, aber Instanzen anderer Klassen sind nicht gleich wahr? Wie soll man es erklären? Um das Geheimnis von „instanceof“ grundsätzlich zu verstehen, müssen Sie von zwei Aspekten ausgehen:

1. Wie dieser Operator in der Sprachspezifikation definiert ist.
2. JavaScript-Prototyp-Vererbungsmechanismus.
JavaScript-Instanceof-Operatorcode:

function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
 var O = R.prototype;// 取 R 的显示原型
 L = L.__proto__;// 取 L 的隐式原型
 while (true) { 
   if (L === null) 
     return false; 
   if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
     return true; 
   L = L.__proto__; 
 } 
}

Informationen zur komplexen Verwendung von „Instanceof“ finden Sie unter folgendem Link:

Detaillierte Analyse des JavaScript-Instanceof-Operators

3.

Geben Sie als Beispiel mindestens 3 Arten erzwungener Typkonvertierungen und 2 Arten impliziter Typkonvertierungen an?

Sie können auf Ihren eigenen Blog-Beitrag verweisen: JS-Datentypkonvertierung

1. Erzwungene Typkonvertierung: Rufen Sie explizit eine integrierte Funktion auf, um die Konvertierung eines Werts eines Typs in einen anderen zu erzwingen. Zu den erzwungenen Typkonvertierungen gehören hauptsächlich: Boolean, Number, String, parseInt, parseFloat

2. Implizite Typkonvertierung: Bei Verwendung arithmetischer Operatoren können die Datentypen auf beiden Seiten des Operators beliebig sein Beispielsweise kann einer Zahl eine Zeichenfolge hinzugefügt werden. Der Grund, warum Operationen zwischen verschiedenen Datentypen ausgeführt werden können, liegt darin, dass die JavaScript-Engine stillschweigend implizite Typkonvertierungen durchführt, bevor sie Operationen ausführt. Implizite Typkonvertierungen umfassen hauptsächlich: +, –, ==, !

5. Was sind die Ereignisflussmodelle von JavaScript?

Der Ereignisfluss beschreibt die Reihenfolge, in der Ereignisse von der Seite empfangen werden. Die DOM-Struktur ist eine Baumstruktur. Wenn ein Element auf der Seite ein Ereignis auslöst, beginnt das Ereignis beim Fensterobjekt der obersten Ebene und breitet sich nach unten zum Zielelement aus. Die Vorgängerknoten im Pfad lösen das entsprechende Ereignis aus Wenn das aktuelle Ereignis des Knotens an eine Ereignisbehandlungsfunktion gebunden ist, wird die Funktion ausgeführt. Wenn das Ereignis das Zielelement erreicht und die Bindungsfunktion ausgeführt wird (sofern eine Bindung vorhanden ist), wird das Ereignis nach oben weitergegeben Das Fensterelement und die Vorgängerknoten des Pfads lösen das entsprechende Ereignis aus.

Der Ereignisfluss enthält drei Phasen:

Ereigniserfassungsphase

In der Zielphase

<br/>

Ereignisblasenphase

Ereigniserfassungsphase: Das Ereignis wird zunächst durch das Objekt der obersten Ebene ausgelöst und breitet sich dann schrittweise nach unten aus Schritt für Schritt bis zum Zielelement;

In der Zielphase: Auf dem an das Ereignis gebundenen Ereignis: Das Ereignis wird zuerst vom spezifischen Element empfangen und dann Schritt für Schritt nach oben weitergegeben, bis es unspezifisch ist Element;

6.

Was sind die Stücklistenobjekte?

1. Das Fensterobjekt ist das Objekt der obersten Ebene von JS.

2

3. Standortobjekt, aktuelle URL-Informationen

4 . Verlaufsobjekt, Browser-Zugriffsverlaufsinformationen

7. Bitte beschreiben Sie kurz AJAX.

Siehe meinen Blogbeitrag: Ajax

Referenzantwort:

Kurze Beschreibung von AJAX: AJAX steht für „Asynchronous Javascript And XML“ (Asynchronous JavaScript and XML) und bezieht sich auf eine Webentwicklungstechnologie zum Erstellen interaktiver Webanwendungen. AJAX ermöglicht die asynchrone Aktualisierung von Webseiten, indem im Hintergrund kleine Datenmengen mit dem Server ausgetauscht werden. Das bedeutet, dass Teile einer Webseite aktualisiert werden können, ohne dass die gesamte Seite neu geladen werden muss.

Grundschritte von AJAX:

Ajax-Objekt initialisieren
Adresse verbinden, Daten vorbereiten
Anfrage senden
Daten empfangen (Empfang, noch nicht abgeschlossen)
Daten empfangen abgeschlossen
//Initialisieren Sie das Ajax-Objekt
var xhr = new XMLHttpRequest();
//Verbinden Sie die Adresse und bereiten Sie die Daten vor
xhr.open("method", "address", if it ist asynchron);
//Ereignisse werden ausgelöst, wenn der Datenempfang abgeschlossen ist
xhr.onload =function(){}
//Senden von Daten
xhr.send();

8. HTTP Was bedeuten die Statusmeldungen 200 302 304 403 404 500?

200: Die Anfrage war erfolgreich und der von der Anfrage erwartete Antwortheader oder Datenkörper wird mit dieser Antwort zurückgegeben.
302: Die angeforderte Ressource hat vorübergehend auf die Anfrage von einem anderen URI geantwortet. Da solche Weiterleitungen temporär sind, sollte der Client künftige Anfragen weiterhin an die ursprüngliche Adresse senden. Diese Antwort kann nur zwischengespeichert werden, wenn sie in Cache-Control oder Expires angegeben ist.
304: Wenn der Client eine bedingte GET-Anfrage sendet und die Anfrage zulässig ist, sich der Inhalt des Dokuments jedoch nicht geändert hat (seit dem letzten Zugriff oder gemäß den Bedingungen der Anfrage), sollte der Server diesen Statuscode zurückgeben . Eine 304-Antwort DARF KEINEN Nachrichtentext enthalten und endet daher immer mit der ersten Leerzeile nach dem Nachrichtenkopf.
403: Der Server hat die Anfrage verstanden, weigerte sich jedoch, sie auszuführen.
404: Die Anfrage ist fehlgeschlagen. Die angeforderte Ressource wurde nicht auf dem Server gefunden.
500: Der Server ist auf einen unerwarteten Zustand gestoßen, der den Abschluss der Verarbeitung der Anfrage verhindert hat. Im Allgemeinen tritt dieses Problem auf, wenn im serverseitigen Quellcode ein Fehler vorliegt.

9. Was ist der Unterschied zwischen synchron und asynchron?

Synchron und asynchron haben nichts mit Blockieren und Nichtblockieren zu tun. Synchronisation und Asynchronität konzentrieren sich hauptsächlich darauf, wie Dinge verarbeitet werden, nachdem sie erledigt sind, oder auf einen Nachrichtenkommunikationsmechanismus.

Synchronisation und Asynchronität können für die angeforderte Partei als die Methode bezeichnet werden, mit der die angeforderte Partei die Verarbeitungsergebnisse mitteilt.

Im Fall der Synchronisierung wartet der Nachrichtenhandler auf das Auslösen der Nachricht.
Im Fall der Asynchronität benachrichtigt der Auslösemechanismus den Nachrichtenhandler.

Blockiert nicht Die Sperrung erfolgt hauptsächlich für den Antragsteller.
Blockierung: Stellen Sie eine Anfrage und warten Sie, bis das Ergebnis zurückgegeben wird, und verarbeiten Sie dann die folgenden Aktionen.
Nicht blockierend: Stellen Sie eine Anfrage, ohne auf die Rückgabe des Ergebnisses zu warten, und Sie können mit den folgenden Aktionen fortfahren ;

10. Was ist der Unterschied zwischen POST und der Verwendung von POST?

GET: Wird im Allgemeinen zum Abfragen von Daten verwendet, wobei die URL zum Übergeben von Parametern verwendet wird. Da der Browser Einschränkungen hinsichtlich der Länge der Adressleiste hat, ist die Menge der mit der Get-Methode gesendeten Informationen begrenzt , und der Browser speichert die Informationen über die angeforderte Adresse, einschließlich der Daten hinter der Adresse (Verlauf, Cache). get kann Daten nur im Klarformat (URL-codiertes Format) senden.

POST: Wird im Allgemeinen zum Senden von Daten an den Server verwendet. Es gibt theoretisch keine Begrenzung für die Größe der gesendeten Daten. Der Browser speichert die Adresse im Cache und zeichnet die per Post übermittelten Daten auf. Post kann Zeichenfolgen im Klartext, im URL-codierten Format und im Binärformat in verschiedenen Formen senden.

Bitte verwenden Sie die POST-Anfrage in den folgenden Situationen:

Anfrage zur Übermittlung (ähnliche Semantik, Get bedeutet Anforderung, Post bedeutet Übermittlung);
Senden Sie private Daten (Benutzername, Passwort) (fällig zu Browser-Cache-Aufzeichnungseigenschaften);
Senden einer großen Datenmenge an den Server (Unterschied in der Datengrößenbeschränkung);
Beim Hochladen von Dateibildern (Unterschied im Datentyp); 11. Einschränkungen von AJAX?

1. AJAX unterstützt die Zurück-Schaltfläche des Browsers nicht. 2. Sicherheitsprobleme AJAX legt die Details der Interaktion mit dem Server offen.

3. Die Unterstützung für Suchmaschinen ist relativ schwach. Es führt Ihr JS-Skript nicht aus, sondern bedient nur den Quellcode Ihrer Webseite.

4 Es gibt bestimmte Einschränkungen für domänenübergreifende Anfragen. Lösung: jsonp;


12. Was genau macht der neue Operator? (Geltungsbereich) zeigt auf das Objekt

3. Führen Sie den Code aus und fügen Sie dem neuen Objekt Attribute oder Methoden hinzu

13. null Was ist der Unterschied zwischen undefiniert und undefiniert?

null: null stellt einen Nullwert dar, der 0 ist, wenn er in einen numerischen Wert umgewandelt wird;

undefiniert: undefiniert stellt einen „fehlenden Wert“ dar, das heißt, es sollte einen Wert geben hier, aber es wurde noch nicht definiert.

Wenn eine Variable deklariert, aber kein Wert zugewiesen wird, ist sie gleich undefiniert. Dem Objekt ist kein Attribut zugewiesen und der Wert dieses Attributs ist undefiniert. Wenn die Funktion keinen Wert zurückgibt, gibt sie standardmäßig undefiniert zurück.

Weitere Informationen finden Sie in meinem Blog-Beitrag: JS bestimmt den Unterschied zwischen Datentyp, null und undefiniert?

14. JavaScript-Prototyp, Prototypkette? Scope-Kette?

作用域链的理解：
   当执行一段JavaScript代码（全局代码或函数）时，JavaScript引擎会创建为其创建一个作用域又称为执行上下文（Execution Context），在页面加载后会首先创建一个全局的作用域，然后每执行一个函数，会建立一个对应的作用域，从而形成了一条作用域链。每个作用域都有一条对应的作用域链，链头是全局作用域，链尾是当前函数作用域。
    作用域链的作用是用于解析标识符，当函数被创建时（不是执行），会将this、arguments、命名参数和该函数中的所有局部变量添加到该当前作用域中，当JavaScript需要查找变量X的时候（这个过程称为变量解析），它首先会从作用域链中的链尾也就是当前作用域进行查找是否有X属性，如果没有找到就顺着作用域链继续查找，直到查找到链头，也就是全局作用域链，仍未找到该变量的话，就认为这段代码的作用域链上不存在x变量，并抛出一个引用错误（ReferenceError）的异常。

JavaScript 原型： 每创建一个函数，函数上都有一个属性为 prototype，它的值是一个对象。 这个对象的作用在于当使用函数创建实例的时候，那么这些实例都会共享原型上的属性和方法。

原型链： 在 JavaScript 中，每个对象都有一个指向它的原型（prototype）对象的内部链接（proto）。这个原型对象又有自己的原型，直到某个对象的原型为 null 为止（也就是不再有原型指向）。这种一级一级的链结构就称为原型链（prototype chain）。 当查找一个对象的属性时，JavaScript 会向上遍历原型链，直到找到给定名称的属性为止;到查找到达原型链的顶部（Object.prototype），仍然没有找到指定的属性，就会返回 undefined。

十五、JavaScript代理
当我们需要对很多元素添加事件的时候，可以通过将事件添加到它们的父节点而将事件委托给父节点来触发处理函数。

比如我们需要向一个ul中动态添加很多个li，需要遍历li逐个添加点击事件

<ul id=&#39;list&#39;></ul> var count = 100; var ulList = document.getElementById("list"); //动态构建节点
 for(var i = count;i--;){  var liDom = document.createElement(&#39;li&#39;);
  ulList.appendChild(liDom);
 } //绑定点击事件
 var liNode = ulList.getElementByTagName("li"); for(var i=0, l = liNodes.length; i < l; i++){
  liNode[i].onClick = function(){
   //li点击事件
  }
 }

众所周知，DOM操作是十分消耗性能的。所以重复的事件绑定简直是性能杀手。而事件代理的核心思想，就是通过尽量少的绑定，去监听尽量多的事件。如何做呢？答案是利用事件冒泡机制,对其父节点ul进行事件绑定（Event Bubble),然后通过event.target来判断是哪个节点触发的事件，从而减少很多EventHandler的绑定。

“` 
var count = 100; 
var ulList = document.getElementById(“list”); 
//动态构建节点 
for(var i = count;i–;){ 

 var liDom = document.createElement(‘li’); 

 ulList.appendChild(liDom); 
} 
//绑定点击事件 
var liNode = ulList.getElementByTagName(“li”); 
liNode.onClick = function(e){ 

 if(e.target && e.target.nodeName.toUpperCase == “LI”) { 

  // li点击事件 

 } 
}

十六、如何理解闭包？
闭包

十七、call和apply的作用是什么？区别是什么？
call和apply的功能基本相同，都是实现继承或者转换对象指针的作用；
唯一不通的是前者参数是罗列出来的，后者是存到数组中的；
call或apply功能就是实现继承的；与面向对象的继承extends功能相似；但写法不同；
语法：
.call(对象[,参数1，参数2,….]);//此地参数是指的是对象的参数，非方法的参数；
.apply(对象,参数数组)//参数数组的形式:[参数1，参数2,……]

十八、JavaScript 如何实现继承？

(1)构造继承 (2)原型继承 (3)实例继承 (4)拷贝继承
 //原型prototype机制或apply和call方法去实现较简单，建议使用构造函数与原型混合方式。 function Parent()
 {  
     this.name = ‘song’; } function Child() {
     this.age = 28; } Child.prototype = new Parent(); //通过原型,继承了Parent var demo = new Child(); alert(demo.age); alert(demo.name); //得到被继承的属性

十九、JavaScript 有哪几种创建对象的方式？

Um es einfach auszudrücken: Das Erstellen von Objekten in JavaScript ist nichts anderes als die Verwendung integrierter Objekte oder verschiedener benutzerdefinierter Objekte. Natürlich können Sie auch JSON verwenden, aber es gibt viele Möglichkeiten, sie zu schreiben auch gemischt werden. //
(1) Objektliteralmethode
person={Vorname:“Mark“,Nachname:“Yun“,Alter:25,Augenfarbe:“Schwarz“}; (2) Verwenden Sie die Funktion, um die Parameterlose Konstruktorfunktion Person(){} var person = new Person(
) zu simulieren //Definieren Sie eine Funktion. Wenn Sie die neue „Instantiierung“ verwenden, kann die Funktion als Klasse person.name =
betrachtet werden „Xiaosong“; person.age = „23“; person.work = function() {
warning(„Hallo“ + person.name); } person.work(); (3) Verwenden Sie die Funktion, um den Parameterkonstruktor zu simulieren (verwenden Sie dieses Schlüsselwort, um das Kontextattribut des Konstrukts zu definieren). Person(Name,Alter,Hobby) {
This.name = name; //dieser Bereich: aktuelles Objekt
This.age = Alter;
This.work = Arbeit;
This.info = function() {
Alert("mein Name" + dieser.Name + "dieses Jahr" + dieses.Alter + "Jahr alt" +
} } var Xiaosong = new Person("WooKong",23,"Programmer"); //Instanziieren und erstellen Sie das Objekt Xiaosong.info(); //Rufen Sie die info()-Methode (4) auf, um es mit der Factory-Methode zu erstellen (eingebautes Objekt) var jsCreater = new
Object(); jsCreater.name = „Brendan Eich“; //Erfinder von JavaScript
jsCreater.work = „JavaScript“; jsCreater.info = function() {
Alert("Ich bin der Erfinder von "+this.work+""+this.name); } jsCreater.info(); (5) Verwenden Sie die Prototyp-Methode, um die Funktion Standard(){} Standard.prototype.name = "ECMAScript"; Standard.prototype.event = function() {
Alert(this.name+"ist die Standardspezifikation der Skriptsprache"); var jiaoben = new Standard(); (6) Verwenden Sie eine gemischte Methode, um die Funktion iPhone(name, event) {
zu erstellen This.name = name;
This.event = event; } iPhone.prototype.sell = function() {
warning("Ich bin "+this.name+", ich bin iPhone5s "+this.event+"~ haha!"); var SE = neues iPhone("iPhone SE","Official Refurbished Machine"); );

20. In JavaScript gibt es eine Funktion, die bei der Objektsuche niemals nach dem Prototyp sucht.

hasOwnProperty // hasOwnProperty in JavaScript

Die Funktionsmethode gibt einen booleschen Wert zurück, der angibt, ob ein Objekt eine Eigenschaft mit dem angegebenen Namen hat. Diese Methode kann nicht prüfen, ob sich die Eigenschaft in der Prototypenkette des Objekts befindet; die Eigenschaft muss ein Mitglied des Objekts selbst sein.

//

Verwendung: object.hasOwnProperty(proName) wobei das Parameterobjekt eine erforderliche Option ist, eine Instanz eines Objekts. proName ist erforderlich, ein Zeichenfolgenwert des Attributnamens.
// Wenn das Objekt eine Eigenschaft mit dem angegebenen Namen hat, gibt die Funktionsmethode hasOwnProperty in JavaScript true zurück, andernfalls gibt sie
zurück FALSCH.

21. Was ist Ajax? Wie erstelle ich ein Ajax?

Der vollständige Name von Ajax: Asynchrones Javascript und XML, asynchrone Übertragung + js + xml.

Das sogenannte Asynchrone ist hier eine einfache Erklärung: Wenn wir eine Anfrage an den Server senden, müssen wir nicht auf das Ergebnis warten, sondern können gleichzeitig andere Dinge tun. Wenn das Ergebnis verfügbar ist, wird es anschließend ausgeführt Gleichzeitig wird die Seite nicht vollständig aktualisiert, was die Benutzererfahrung verbessert.

(1) Erstellen Sie ein XMLHttpRequest-Objekt, dh ein asynchron aufrufendes Objekt

(2) Erstellen Sie eine neue HTTP-Anfrage und geben Sie die Methode, URL und Verifizierungsinformationen der HTTP-Anfrage an
(3) Legen Sie eine Funktion fest, um auf Statusänderungen von HTTP-Anfragen zu reagieren
(4) Rufen Sie die vom asynchronen Aufruf
zurückgegebenen Daten ab (5) Verwenden Sie JavaScript und DOM, um eine teilweise Aktualisierung zu implementieren

Das obige ist der detaillierte Inhalt vonSortieren von Interview-Wissenspunkten in js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!