javascript 高级

开启严格模式

1.为整个script标签开启

<script>

"use strict" 为整个script开启严格模式

</script>

2.为某个函数开启严格模式

fuction fn（）{

"use strict"；

}

严格模式的行为

1.全局变量必须显示声明

2.禁止this指向window对象

3.禁止重名

4.进制使用8进制

值类型和引用类型

1.基本数据类型（简单数据类型，值类型）

2.复杂数据类型 （引用类型）

值类型，在内存中存储的是值本身。引用类型，会在内存中随机开辟一个空间，把数据存储到这个空间中，然后把空间的地址给变量

例图

var num=11

var obj={

name:"zs",

age:18

}

下图值类型和引用类型存储

var xm={

name:"小明"，

age：28，

car：{

type：“mobile”，

color:"orange"

}

}

例题：

var obj1 = {

name:"zs",

age:18

}

var obj2 = obj1;

obj2.name = "ls";

console.log(obj1.name);；ls

console.log(obj2.name); ls

解释：在内存中随机开辟一个空间，创建的对象放到这个空间中，并把这个地址给obj1，obj1赋值给obj2的是地址，obj2也指向这个地址，所以在空间中只有一个对象，obj2的name属性改变，obj1也会改变，因为它们指向的是同一个对象。

值类型和引用类型参数传递问题

var obj={

name:"ls",

age:18

}

function fn(a){

a.name="zs"

a={

name:"ww",

age:20

}

console.log(a.name) ww

}

fn(obj)

console.log(obj.name) zs

分析：变量obj 存的是对象地址0x01, fn(obj)在调用的时候obj把地址给了变量a，所以a也指向了这个对象，函数中a={......} ，又开辟了一个空间，存了一个对象，把0x02地址给了a,所以a指向当前对象，不指向以前的对象了，

深拷贝与潜拷贝

潜拷贝：将对象中的各个属性依次进行复制，潜拷贝只复制一层对象，如果对象中还有对象，那么复制仅仅是地址。

深拷贝：如果对象属性中还有对象，深拷贝会递归赋值所有层对象的属性，如果对象属性中还有对象，会继续拷贝，这样拷贝出来的对象完全独立

function cloneObj(obj) {

//如果不是对象，不拷贝

if (typeof obj !== "object") {

return;

}

var temp = {};

for (var k in obj) {

//如果对象的属性是复杂类型，递归复制

//如果对象的属性是简单类型，直接复制

temp[k] = typeof obj[k] === "object" ? cloneObj(obj[k]) : obj[k];

}

return temp;

}

面向对象

面向对象是一种编程开发思想

面向对象的特点 1.封装性，将功能封装到对象中，外界使用对象时，只需要关注对象的方法。

2.继承性，一个对象中没有属性和方法，另一个对象中有，拿过来用，就实现了继承

3.动态性，js属于弱类型语言，所以js不支持多态

创建对象的方式

1.内置构造函数的创建 var person=new Object()

2.对象字面量创建 var person={}

3.工厂函数 function createPerson(name){ return { name：'jack'} } 然后生成实例对象

var p=createPerson(jack)

4.构造函数 必须用new操作符 在构造函数中用this对象

function Person (name, age) {

this.name = name

this.age = age

this.type = 'human'

this.sayHello = sayHello

}

var p1 = new Person('lpz', 18)

缺点：会暴露很多方法，容易造成全局变量污染

原型

javascript规定，每一个构造函数都有一个prototype属性，指向另一个对象

获取原型对象

1.通过构造函数 .prototype可以获取（显示原型）

2.通过实例 ._ _proto _ _可以获取（隐式原型）

3.它们指向同一个对象 构造函数.prototype==实例._ _proto_ _

注意：__proto__是浏览器的一个隐藏的（私有）属性，早器的ie浏览器是不支持的，如果想修改原型上的内容，就用构造函数的.prototype去修改

原型链

任何一个对象，都有原型对象，原型对象本身又是一个对象，原型对象也有自己的原型对象，这样一环扣着一环就形成链式结构，这中链式结构称为原型链

总结：Object.prototype是原型链的尽头，Object.prototype的原型是null

js采用的是词法作用域，所以变量在声明的时候，作用域就确定了，而不是在调用的时候

预解析

• 提升以作用域为单位。

• 优先提升函数function，然后才提升变量var。
• 重复的var提升会被忽略。
• 重复的function声明会被覆盖。

//属性搜索原则：

//1. 想要获取一个对象的属性，首先找自己的属性，如果有，直接返回

//2. 如果没有，沿着原型链，一直找到Object.prototype

//3. 如果整个原型链都没有，返回undefined。

//二、Object.prototype的成员

// obj.hasOwnProperty(prop) :判断prop属性是否是obj自己提供

// obj.propertyIsEnumerable(prop) : 判断prop是否是自己的属性， prop属性可否遍历

// obj1.isPrototypeOf(obj2): 判断obj1是否在obj2原型链上。

// toString() : Object.prototype.toString() [object type] 将对象转换成字符串

// toLocaleString() :跟本地化有关，

// valueOf() : 将对象转换成简单类型（数值、布尔）

沙箱

;(function(window){

})(window);

给原型对象加属性和方法

function Person(name){

this.name=ame

}

Person.prototype={

car:"劳斯莱斯幻影"，

monery：100000

}

混公式继承

var obj={

name：'jack'，

extend:function(temp){

for(k in temp){

this[k]=temp[k]

}

}

}

var obj1={

car:'宾尼'，

hourse'海景房'

}

obj.extend(obj1)

混公式继承，就是把别人的方法复制过来

经典继承

es5提供了一个方法 Object.create(obj)

返回值：一个新的对象

参数：一个对象，这个对象成为新对象的原型对象

var newObject=Object.create(lw)

原型继承

Person.prototype = {

constructor:Person,

name:"zs",

sayHi:function () {

}

}

直接在原型对象上添加属性和方法

混公式和原型继承

//把所有的东西都混入到原型对象

Person.prototype.extend = function (obj) {

for(var k in obj){

this[k] = obj[k];

}

}

Person.prototype.extend(lw);

Person.prototype.extend(ll);

Person.prototype.extend(lx);

//需求：所有创建出来的对象既能用lw的属性，也能用老李的属性。

var p = new Person("屌丝");

eval的作用

//eval的作用：将一段字符串当成代码来执行。

//eval("alert(1+2)");

//eval 让一个json字符串转换成js对象。

//json:一种通过的数据交换的格式 说白了 json就是一个字符串，只不过这个字符串有一定的规则。

//var json = '{"name": "zs", "age": 18, "sex": "男"}';

//如何把json字符串转换成js对象

//参数：json字符串

//返回值：js对象

//var obj = JSON.parse(json);

//console.log(obj);

//js有一个对象的话， JSON.stringify(obj)转换成json字符串，传递给后台

//后台返回的也是json字符串，通过JSON.parse(json),转换成js对象，操作js对象就非常的方便。

转载于:https://juejin.im/post/5b028bd4518825428452583e