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（数据）；作用：将数据转化为字符串。
2.范例转化
范例转化：分为显现范例转化，和隐式范例转化。
1.Number（数据）
假如数据内容式地道的数字，才能够转化为数字，不然式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));2.NaN
NaN的数据范例书Number。注重：NaN和任何东西都不相称，包含自身。
3.isNaN（数据）
会先把数据用Number转化，转化完了以后在推断是不是是NaN，假如是NaN则返回为true。不然返回为fasle。console.log(isNaN(1));//false
console.log(isNaN("123"));//false
console.log(isNaN("abc"));//true4.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.00265.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范例 false3.运算符
==和===
==：
1.假如范例雷同的话，比较内容
范例不雷同，范例转化在比较
1）一个是undefined,一个是null，则相称。
2）数字和字符串的的话，将字符串转化为数字再举行比较。
===：
1.范例雷同比教内容，范例差别则返回fasle。
4.原型，原型链，new
1.new
1.重天生了一个对象
2.链接到原型
3.绑定this
4.返回新对象
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); //undefined
console.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，假如没有则返回undefined
2.p.__proto__.constructor == function Person(){}
3.p.___proto__.__proto__== Object.prototype
4.p.___proto__.__proto__.__proto__== Object.prototype.__proto__ == null
5.经由过程__proto__构成原型链而非protrotype5.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") ); //false8.call,bind,apply
call,bind,apply的作用都是修正this指向。
区分:
1.call:函数会马上实行,括号中的内容 第一个参数 就是 函数实行时刻 ,内部的this指向。背面的参数就是函数内部的实参。
function foo (a,b) {
console.log( this );
console.log( a,b );
}
foo.call( document,2,3 );//运转效果：#document 2，32.apply:函数会马上实行,括号中的内容 第一个参数 就是 函数实行时刻 ,内部的this指向。不过第二个参数接收数组。
function foo (a,b) {
console.log( this );
console.log( a,b );
}
foo.apply( document,[2,3] ); // 和call 类似 直接挪用 , 不过第二个参数接收数组。运转效果：#document 2，33.bind:函数 不会 马上实行,返回的是 修正了 this指向的新函数.第二个参数是参数列表。 function foo (a,b) {
console.log( this );
console.log( a,b );
}
var fn = foo.bind( document,2,3);// 函数 不会 马上实行,返回的是 修正了 this指向的新函数
fn();
//运转效果:
//#document
//2 39.组合式继续
<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 defined2.实行上下文
这里有篇非常好的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 = 2
console.log(b.age) // 1固然我们也能够经由过程睁开运算符（…）来处理
let a = {
age: 1
}
let b = {...a}
a.age = 2
console.log(b.age) // 12.深拷贝
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;
}