一.复习
function Person(name) {
this.name = name
this.life = 1
this.say=function() {
console.log(this.name,this.life,this.rank)
}
}
var p1 = new Person("jack")// p1={life:1,say:func,name:"jack"}
var p2 = new Person("karen")// p2={life:1,say:func,name:"karen"}
function Student(rank, name) {
this.name = name
this.rank = rank
}
//这行代码执行完毕以后:只要Student函数创建对象,创建出来的对象 的原型对象就是p1对象 跟p2没关系
Student.prototype = p1
//s1={__proto__:p1,name:unde,rank:"581"}
var s1 = new Student("581")
//s2={__proto__:p1,name:unde,rank:"600"}
var s2 = new Student("600")
p1.say();p2.say();s1.say();s2.say()
jack 1 unde
karen 1 und
un 1 581
unde 1 600
同一个作用域内部:
提前的顺序: 变量声明 参数声明 参数赋值 函数声明
console.log(a)
a(300)
var a=100
function a (a) { //var a var a =300 function a
console.log(a) // function a
var a=200 // a=200
console.log(a)
function a () {}
}
a(300)
this 函数的调用者: 找代码中this最近的function 这个函数的调用者
fn()== > wind
函数放在某个容器中 通过容器取出了函数 然后调用
xxx.xx2.xx3.xx4[10].xx5() ==>xxx.xx2.xx3.xx4[10]
arguments[1]()==>arguments
new
prototype
__proto__
1.创建一个空对象,给对象添加一个原型属性__proto__:值是构造函数的prototype指向的对象
2.使用创建的对象调用构造函数
3.整个new表达式产生结果:基本==>创建的对象 引用==>创建的对象销毁,返回这个函数的返回值
原型链
所有对象(包括函数)都有原型对象:都有__proto__
原型对象也有原型对象:也有__proto__
每个对象一直往上访问最终会得到null,这个像链条一样的访问称为原型链
注: (1.两个对象有可能不在一个原型链上,但是他们的原型链一定交叉 2.typeof检测返回’object’,它是基本数据没有原型对象)
作用域
1.es5:
作用域针对函数体
2.声明提升顺序: 变量声明==>形参参数声明==>实参给形参参数赋值==>函数声明
变量
全局变量相当于 window的属性 全局函数相当于window的方法
访问一个变量:
取数据作用域链上都没有 就报错
存数据 作用域链上都没有 就在全局作用域下隐式声明这个变量:注意 要运行到这个代码时才会去全局
var a=200
//window.a=a
console.log(b)
function fn () {
var a=100
// console.log(a)
console.log(xxxxx)
}
二.回调函数
function fn (tool) {
var a=100
tool(a)
}
使用回调函数 fn不是回调函数,tool函数才是回调函数
使用:回调函数一般在使用的地方生成的
callback
fn(200)
fn(function(num) {
console.log(num)
})
function fm (n) {
console.log(n)
}
fn(fm)
var obj={name:"karen",say:function(xx) {
console.log(xx)
}}
fn(obj.say)
function tool (obj) {
//10000
obj.say(100)
}
tool({name:"jack",say:function(n){console.log(n)}})
简单的工具
var re=fn(arr)
console.log(re)
var arr=[10,123,222,123,12,3,1,223,99999]
fn(arr,function(re) {
console.log(re)
})
function fn (arg1,arg2) {
var temp=arg1[0]
for(var i=0;i<arg1.length;i++){
if(temp<arg1[i]){temp=arg1[i]}
}
arg2(temp)
}
三.闭包
function alipay (pwd) {
var money=500
function tool (n) {
money-=n
}
function tool2 () {
console.log("pwd err")
}
if(pwd=123){
return tool
}
else{
return tool2
}
}
function meituan () {
// money-=20
var tool=alipay(123)
tool(20)
}
meituan()
函数体内的局部变量,外部不能访问==>
函数调用返回一个函数,返回的函数外部能够使用,间接访问了函数内部的变量
var arr=[{name:"jack1"},
{name:"jack2"},
{name:"jack3"},
{name:"jack4"},
{name:"jack5"}
]
for(var i=0;i<4;i++){
// arr[i].say=function(){console.log(arr[i].name)}
// fn(i)
(function(index) {
arr[index].say=function(){console.log(arr[index].name)}
})(i)
}
< var index=0;xxxx index >
< var index=1;xxxx index >
function fn (index) {
//var index=0
arr[index].say=function(){console.log(arr[index].name)}
}
var jack1=arr
console.log(jack1)
console.log(i)
arr[1].say()
console.log(i)
全局污染问题,全局变量 局部也能访问 变量重名了也是正确的语法,所有全局变量容易写出污染的代码,闭包可以解决全局污染的问题,尽量一个业务是一个闭包 ,自己的作用域内部的变量自己用,不会污染全局变量