8.11 学习日志

一.复习

			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)

全局污染问题,全局变量 局部也能访问 变量重名了也是正确的语法,所有全局变量容易写出污染的代码,闭包可以解决全局污染的问题,尽量一个业务是一个闭包 ,自己的作用域内部的变量自己用,不会污染全局变量