Heim > Artikel > Web-Frontend > Grundlegende JS-Grundkenntnisse – Systematische Zusammenstellung häufiger Interviewfragen
sind in Basisdatentypen und Objekt unterteilt.
Grundlegende Datentypen sind: null, undefiniert, string, boolean, Zahl, Symbol .
console.log(typeof null);//object console.log(typeof []);//object console.log(typeof {});//object
如果想要区分null,数组,对象,应该怎么办?
console.log(Object.prototype.toString.call(null));//[object Null] console.log(Object.prototype.toString.call([]));//[object Array] console.log(Object.prototype.toString.call({}));//[object Object]
Mein einfaches Verständnis: toString (Daten); Funktion: Daten in einen String konvertieren.
Empfohlene verwandte Artikel: Die umfassendste Sammlung von js-Interviewfragen im Jahr 2020 (aktuell)
Typkonvertierung: unterteilt in explizite Typkonvertierung und implizite Typkonvertierung.
1.Anzahl (Daten)
如果数据内容式纯粹的数字,才可以转化为数字,否则式NaN。rrree
2.NaN
var str2="12px";//NaN var str2="1.2";//1.2 var str2="1.2.3";//NaN var str2=null;//0 console.log(Number(str2));
3.isNaN (Daten)
NaN的数据类型书Number。注意:NaN和任何东西都不相等,包括自己。
会先把数据用Number转化,转化完了之后在判断是不是NaN,如果是NaN则返回为true。否则返回为fasle。
4.parseInt(data) und parseFloat(data)
console.log(isNaN(1));//false console.log(isNaN("123"));//false console.log(isNaN("abc"));//true
parseInt(数据):把数据变成整数,舍去小数点,取整数。 parseFloat(数据):把数据转化为数字,可以是小数。 注意:这两个方法会从左往右开始,除去空格,找到第一位非0数字,开始进行转换,直到转换到不是数字的那位为止,或者,转换出合适的值为止。
5.Stirng() und Boolean() können ebenfalls angezeigt werden Typkonvertierung, hier nicht erwähnt
console.log( parseInt( "1" ) );//1 console.log( parseInt( "1.9" ) );//1 console.log( parseInt( "20px" ) );//20 console.log( parseInt( " 25px" ) );//25 console.log( parseInt( " 0.0026px" ) );//0 console.log( parseFloat( " 0.0026px" ) );//0.0026
6. Implizite Typkonvertierung
条件判断中,除了null,undefined,'',NaN,false,0都转化为false,其余都转化为true。
只有当加法运算时,其中一方是字符串类型,就会把另一个也转为字符串类型。其他运算只要其中一方是数字,那么另一方就转为数字。并且加法运算会触发三种类型转换:将值转换为原始值,转换为数字,转换为字符串。
== und = ==
<script> console.log( "abc"-1 );//NaN console.log( NaN-1 );//NaN console.log( NaN+1 );//NaN console.log( NaN+"1" );//NaN1 //------------------------------------------ console.log( "3"-1 );//转成数字2 console.log( "345" - 0 );//转成数字345 console.log( "345" * 1 );//转成数字345 console.log( "345" / 1 );//转成数字345 console.log( "345px" - 0 );//NaN //------------------------------------------ console.log( 123 + "" );//转成字符串 "123" //------------------------------------------ console.log( !!234 );//转成boolean类型 true console.log( !!0 );//转成boolean类型 false console.log( !!{} );//转成boolean类型 true console.log( !!null );//转成boolean类型 false
1.new
==: 1.如果类型相同的话,比较内容 类型不相同,类型转化在比较 1)一个是undefined,一个是null,则相等。 2)数字和字符串的的话,将字符串转化为数字再进行比较。 ===: 1.类型相同比教内容,类型不同则返回fasle。
2.prototype 原型
1.新生成了一个对象 2.链接到原型 3.绑定this 4.返回新对象
3.原型链
prototype 原型 当一个函数被申明的时候,该函数下默认有一个属性:prototype,该属性的值是一个对象 当我们去调用一个对象的属性或者方法的时候,如果该对象自身没有该属性或方法, 则会调用到该对象 的 构造函数的prototype的属性或方法 把通过构造函数构造出来的对象,共有的方法或者属性,放在prototype身上 __proto__ 当一个对象被创建的时候, 该对象会自动被添加上一个属性:__proto__, 他的值也是一个对象,并且该属性 就是 当前这个对象的构造函数的prototype 对象.__proto__ === 构造函数.prototype
Analyse:
Function.prototype.a = "a"; Object.prototype.b = "b"; function Person(){} console.log(Person); //function Person() let p = new Person(); console.log(p); //Person {} 对象 console.log(p.a); //undefined console.log(p.b); //b
会一直通过__proto__向上查找,最后当查找到Object.prototype时找到,最后打印出b,向上查找过程中,得到的是Object.prototype,而不是Function.prototype,找不到a属性,所以结果为undefined,这就是原型链,通过__proto__向上进行查找,最终到null结束
Zusammenfassung:
//Function function Function(){} console.log(Function); //Function() console.log(Function.prototype.constructor); //Function() console.log(Function.prototype.__proto__); //Object.prototype console.log(Function.prototype.__proto__.__proto__); //NULL console.log(Function.prototype.__proto__.constructor); //Object() console.log(Function.prototype.__proto__ === Object.prototype); //true
1.查找属性,如果本身没有,则会去__proto__中查找,也就是构造函数的显式原型中查找,如果构造函数中也没有该属性,因为构造函数也是对象,也有__proto__,那么会去它的显式原型中查找,一直到null,如果没有则返回undefined 2.p.__proto__.constructor == function Person(){} 3.p.___proto__.__proto__== Object.prototype 4.p.___proto__.__proto__.__proto__== Object.prototype.__proto__ == null 5.通过__proto__形成原型链而非protrotype
检测对象原型是否在要检测对象的原型链上,返回值为true或者false 使用:object instanceof constructor
function Fn () {} var f = new Fn(); console.log( f instanceof Fn );//true console.log( f instanceof Object );//true
// //str是字面量生成的,是由JS内部的String构造函数new出来的。 // //但是str会立刻"压扁"自己,让自己不是对象。 // //所以str都不是对象了,自然instanceof String 的得到的值为fasle // //但str.indexOf(),str还是可以调用indexOf()方法的原因是,当它调用方法的时候,会重新将自己包装成对象。 // //使用结束后会重新"压扁"自己,让自己不是对象。 var str = "123"; console.log( str instanceof Array );//false console.log( str instanceof String);//false console.log( str instanceof Object);//false // var obj = {}; console.log( obj instanceof Array );//false console.log( obj instanceof Object);//true
作用 用来判断某个对象是否含有 指定的 自身属性 语法 boolean object.hasOwnProperty(prop) 参数 object 要检测的对象 prop 要检测的属性名称。 注意:不会沿着原型链查找属性,只查找自身属性
Die Funktionen von call, bind und apply dienen dazu, diesen Zeiger zu ändern.
Unterschied:
function Fn(name,gender){ this.name = name; this.gender = gender; } Fn.prototype.kind = "human"; Fn.prototype.say = function(){ console.log(1); }; var f = new Fn("kimoo","男"); console.log( f.hasOwnProperty("name") ); //true console.log( f.hasOwnProperty("kind") ); //false console.log( f.hasOwnProperty("say") ); //false
1.call:函数会立即执行,括号中的内容 第一个参数 就是 函数执行时候 ,内部的this指向。后面的参数就是函数内部的实参。
function foo (a,b) { console.log( this ); console.log( a,b ); } foo.call( document,2,3 );//运行结果:#document 2,3
2.apply:函数会立即执行,括号中的内容 第一个参数 就是 函数执行时候 ,内部的this指向。不过第二个参数接受数组。
function foo (a,b) { console.log( this ); console.log( a,b ); } foo.apply( document,[2,3] ); // 和call 相似 直接调用 , 不过第二个参数接受数组。运行结果:#document 2,3
3.bind:函数 不会 立刻执行,返回的是 修改了 this指向的新函数.第二个参数是参数列表。
function foo (a,b) { console.log( this ); console.log( a,b ); } var fn = foo.bind( document,2,3);// 函数 不会 立刻执行,返回的是 修改了 this指向的新函数 fn(); //运行结果: //#document //2 3rree
2 .Ausführungskontext
Hier ist ein sehr guter Artikel über den JS-Ausführungskontext. Sie können auf den Link klicken, um ihn anzuzeigenZusammenfassung:
<script> function Person(){ this.arr = [1,2,3]; this.age = 10; } Person.prototype.say = function(){ console.log( "我会说话" ); }; // 父类构造函数中的方法,使用借用构造函数的方式继承 function Coder(name,money) { Person.call(this); this.name = name; this.money = money; } // 父类构造函数原型上的方法,使用原型链继承 Coder.prototype = new Person(); Coder.prototype.constructor = Coder; // 重新修改 constructor Coder.prototype.say = function(){ console.log( "我是程序员,我叫" + this.name +",我一个月:"+ this.money ); } var p = new Person(); console.log( p.age ); console.log( p.arr ); console.log( p.kind ); p.say(); var c1 = new Coder("a",10000); console.log( c1.age ); c1.say(); c1.arr.push(4); console.log( c1.arr ); console.log( c1.name ); console.log( c1.money ); var c2 = new Coder("b",30000); c2.say(); console.log( c2.age ); console.log( c2.arr ); console.log( c2.name ); console.log( c2.money ); console.log(Coder.prototype.constructor); </script>
3 .Variable Förderung (Domänenauflösung)
Schlüssel: Während des Variablenhochstufungsprozesses
Funktionspriorität ist höher als Variablenpriorität<script>
function Person(){
this.arr = [1,2,3];
this.age = 10;
}
Person.prototype.say = function(){
console.log( "我会说话" );
}
function Coder(){
Person.call(this);
}
Coder.prototype = cloneFn( Person.prototype );
Coder.prototype.constructor = Coder;
Coder.prototype.say = function(){
console.log( "我是程序员" );
}
var p = new Person();
console.log( p.age );
console.log( p.arr );
p.say();
console.log( "----------------" );
var c1 = new Coder();
console.log( c1.age );
c1.say();
c1.arr.push(4);
console.log( c1.arr );
console.log( "----------------" );
var c2 = new Coder();
console.log( c2.age );
console.log( c2.arr );
c2.say();
//------------------------------------------
function cloneFn( sourse ){
var o = Object.prototype.toString.call(sourse).toLowerCase().indexOf("array")!==-1 ? [] : {};
for( var attr in sourse ){
if( (typeof sourse[attr] === "object") && sourse[attr] !== null ){
o[attr] = cloneFn( sourse[attr] ) ;
}else{
o[attr] = sourse[attr];
}
}
return o;
}
</script>
4.闭包
Abschluss: Funktion A gibt eine Funktion B zurück, und Funktion B verwendet die Variablen von Funktion A, Funktion B wird als Abschluss bezeichnet.
<script> class Person { constructor(name){ this.name = name; } say(){ console.log( '我的名字叫 ${this.name}'); } } class Coder extends Person{ // constructor( name,money ){ // super(name); // 相当于 调用 父类的 构造函数,修改内部的this, //// 一定要先调用 super 再使用 this // this.money = money; // } say(){ console.log( `我的名字叫 ${this.name}` ); } eat(){ console.log( "我会吃" ); } } var p = new Person("kimoo"); // console.log( p ); // p.say(); // p.eat(); // 报错: p.eat is not a function var c = new Coder("zm"); console.log( c ); c.say(); c.eat(); </script>
Da setTimeout eine asynchrone Funktion ist, werden zunächst alle Schleifen ausgeführt. Zu diesem Zeitpunkt ist i 6, sodass eine Reihe von 6 ausgegeben werden. Lösung eins:
JS作用域分为全局作用域和函数作用域,函数作用域可以访问全局作用域中的变量,对象,函数等。但是函数作用域外部访问不到函数内部的变量,对象,函数。 但在ES6中新增了块级作用域。let,const在块中声明的变量,函数等,外部都访问不到。
Lösung zwei:
{ var a=1; let b=2; console.log(b);//2 { console.log(b);//2 } } console.log(a);//1 console.log(b);//报错,b is not defined
Lösung drei:
1. 调用函数是会为其创建执行上下文,并压入执行环境栈的栈顶,执行完毕弹出,执行上下文被销毁,随之VO也被销毁 2. EC创建阶段分创建阶段和代码执行阶段 3. 创建阶段初始变量值为undefined,执行阶段才为变量赋值 4. 函数申明先于变量申明
Klicken Sie hier, um mehr über Schließungen zu erfahren
13 . Tiefe und flache Kopie
1. Flache KopieZuerst können Sie dieses Problem durch Object.assign lösen. function foo() {
console.log(f1); //f1() {}
console.log(f2); //undefined
var f1 = 'hosting';
var f2 = function() {}
function f1() {}
}
foo();
Natürlich können wir auch den Spread-Operator (...) verwenden, um
for ( var i=1; i<=5; i++) { setTimeout( function timer() { console.log( i ); }, i*1000 ); }Deep Copy
for (var i = 1; i <= 5; i++) { (function(j) { setTimeout(function timer() { console.log(j); }, j * 1000); })(i); }
Verwandte Artikel:
8 JS-Grundkenntnisse, auf die geachtet werden muss
Zusammenstellung von Grundkenntnissen in Javascript
Das obige ist der detaillierte Inhalt vonGrundlegende JS-Grundkenntnisse – Systematische Zusammenstellung häufiger Interviewfragen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!