1.js内置类型分为基本数据类型和object.
基本数据类型有：null,undefined,string,boolean,number,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]
我的简单理解：tostring（数据）；作用：将数据转化为字符串。
推荐相关文章：2020年最全js面试题整理（最新）
2.类型转化类型转化：分为显示类型转化，和隐式类型转化。
1.number（数据）
如果数据内容式纯粹的数字，才可以转化为数字，否则式nan。
var str2="12px";//nanvar str2="1.2";//1.2var str2="1.2.3";//nanvar str2=null;//0console.log(number(str2));
2.nan
nan的数据类型书number。注意：nan和任何东西都不相等，包括自己。
3.isnan（数据）
会先把数据用number转化，转化完了之后在判断是不是nan，如果是nan则返回为true。否则返回为fasle。
console.log(isnan(1));//falseconsole.log(isnan("123"));//falseconsole.log(isnan("abc"));//true
4.parseint(数据)和parsefloat(数据)
parseint(数据)：把数据变成整数，舍去小数点，取整数。parsefloat(数据)：把数据转化为数字，可以是小数。注意:这两个方法会从左往右开始，除去空格，找到第一位非0数字，开始进行转换，直到转换到不是数字的那位为止，或者，转换出合适的值为止。
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
5.stirng( )和boolean（）也可以进行显示类型转化，这里不缀述
条件判断中，除了null,undefined,'',nan,false,0都转化为false，其余都转化为true。
6.隐式类型转化
只有当加法运算时，其中一方是字符串类型，就会把另一个也转为字符串类型。其他运算只要其中一方是数字，那么另一方就转为数字。并且加法运算会触发三种类型转换：将值转换为原始值，转换为数字，转换为字符串。
<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
3.运算符==和===
==： 1.如果类型相同的话，比较内容 类型不相同，类型转化在比较 1）一个是undefined,一个是null，则相等。 2）数字和字符串的的话，将字符串转化为数字再进行比较。===： 1.类型相同比教内容，类型不同则返回fasle。
4.原型，原型链，new1.new
1.新生成了一个对象2.链接到原型3.绑定this4.返回新对象
2.prototype 原型
prototype 原型 当一个函数被申明的时候，该函数下默认有一个属性：prototype，该属性的值是一个对象 当我们去调用一个对象的属性或者方法的时候，如果该对象自身没有该属性或方法， 则会调用到该对象 的 构造函数的prototype的属性或方法 把通过构造函数构造出来的对象，共有的方法或者属性，放在prototype身上__proto__ 当一个对象被创建的时候， 该对象会自动被添加上一个属性：__proto__， 他的值也是一个对象，并且该属性 就是 当前这个对象的构造函数的prototype 对象.__proto__ === 构造函数.prototype
3.原型链
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); //undefinedconsole.log(p.b); //b
解析：
会一直通过__proto__向上查找，最后当查找到object.prototype时找到，最后打印出b，向上查找过程中，得到的是object.prototype，而不是function.prototype，找不到a属性，所以结果为undefined，这就是原型链，通过__proto__向上进行查找，最终到null结束
//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，如果没有则返回undefined2.p.__proto__.constructor == function person(){}3.p.___proto__.__proto__== object.prototype4.p.___proto__.__proto__.__proto__== object.prototype.__proto__ == null 5.通过__proto__形成原型链而非protrotype
5.instanceof检测对象原型是否在要检测对象的原型链上，返回值为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
6.hasownproperty作用 用来判断某个对象是否含有 指定的 自身属性 语法 boolean object.hasownproperty(prop) 参数 object 要检测的对象 prop 要检测的属性名称。 注意：不会沿着原型链查找属性，只查找自身属性
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
8.call,bind,applycall,bind,apply的作用都是修改this指向。
区别:
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 3
9.组合式继承<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>
10.拷贝式继承<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>
11.class继承<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>
12.函数作用域，执行上下文，变量提升，闭包1.作用域
js作用域分为全局作用域和函数作用域，函数作用域可以访问全局作用域中的变量，对象，函数等。但是函数作用域外部访问不到函数内部的变量，对象，函数。但在es6中新增了块级作用域。let，const在块中声明的变量，函数等，外部都访问不到。
{ 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
2.执行上下文
这里有篇非常好的js执行上下文的文章，可以点击链接查看
总结：
1. 调用函数是会为其创建执行上下文，并压入执行环境栈的栈顶，执行完毕弹出，执行上下文被销毁，随之vo也被销毁 2. ec创建阶段分创建阶段和代码执行阶段 3. 创建阶段初始变量值为undefined，执行阶段才为变量赋值 4. 函数申明先于变量申明
3.变量提升（域解析）
关键：变量提升过程中函数优先级高于变量优先级
function foo() { console.log(f1); //f1() {} console.log(f2); //undefined var f1 = 'hosting'; var f2 = function() {} function f1() {} } foo();
4.闭包
闭包：函数 a 返回了一个函数 b，并且函数 b 中使用了函数 a 的变量，函数 b 就被称为闭包。
for ( var i=1; i<=5; i++) { settimeout( function timer() { console.log( i ); }, i*1000 );}
首先因为 settimeout 是个异步函数，所有会先把循环全部执行完毕，这时候 i 就是 6 了，所以会输出一堆 6。
解决方法一：
for (var i = 1; i <= 5; i++) { (function(j) { settimeout(function timer() { console.log(j); }, j * 1000); })(i);}
解决方法二：
for ( var i=1; i<=5; i++) { settimeout( function timer(j) { console.log( j ); }, i*1000, i);}
解决方法三：
for ( let i=1; i<=5; i++) { settimeout( function timer() { console.log( i ); }, i*1000 );}
点击这里，闭包进一步了解
13.深浅拷贝1.浅拷贝
首先可以通过 object.assign 来解决这个问题。
let a = { age: 1}let b = object.assign({}, a)a.age = 2console.log(b.age) // 1
当然我们也可以通过展开运算符（…）来解决
let a = { age: 1}let b = {...a}a.age = 2console.log(b.age) // 1
2.深拷贝
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;}
相关文章：
js的8个必须注意的基础知识
javascript基础知识整理
以上就是js基础知识必备—常见面试题目系统整理的详细内容。