一.复习

			var obj={} 		//定义一个新对象obj
			var a="xxx" 		//定义a变量为"xxx"
			var xxx="a"		//定义xxx变量为"a"
			obj[a]=xxx 		//obj["xxx"]=a;
			console.log(obj)

这道题考点在于方括号和点方法取对象的值,当方括号里的值不是字符串的时候,就会把括号里的值当做变量,然后查找变量所带有的字符串,作为属性名
2.

			逻辑||
			var c=(a=0)||(b=100)	//false /c=100
			console.log(a)//0
			console.log(c)//100
			console.log(b)//100

本题考点在于a=0这个语句布尔值是否为0,如果为0,c等于逻辑||后面的值.ez

二.for语句

1.基本用法:用于遍历数组中的数据
2.难点:多重嵌套
个人感觉目前阶段不是特别的难,和java和其他语言暂时相同,就是其中的读数据的方法不同,需要通过点函数和取数组下标来弄
eg:

		var arr=[[222,3,1111,42343234,2,34],[222,3,1111,42343234,2,34],[222,3,1111,42343234,2,34],[222,3,1111,42343234,2,34]]
			for(var i=0;i<arr.length;i++){
				console.log(arr[i])
				  for(var j=0;j<arr[i].length;j++){
					  console.log(arr[i][j])
				  }
			}

三.函数

函数有很多种:闭包,回调,构造函数,对象,数据…
函数是一个代码块,是一个复合语句,只有当调用或者事件触发的时候才会执行这段代码块
每一次调用都会重新执行代码块的所有代码,每次调用相互独立

function fn () {
				var a=20
				
				a++
				console.log(666);
				console.log(a)
			} 
			
			fn()
			fn()

这样打印出来两个都是21

函数里面分为实参和形参,都是参数,都为代码的运行提供数据,但是一个是固定的值,一个是可以随着代码的运行进行变化的值

function fn (n) {
				//隐式 var n= 
				var a=n*n
				console.log(a)
				
			}
			
			fn(100)//10000
			fn(200)//40000

当函数后面的变量为形参的时候,如果函数被调用或者触发了,会在运行函数的时候隐式的声明形参这个变量,然后将我们输入的数据赋值给形参
实参
实参可以是任何数据,包括是函数,达到函数的嵌套效果

			function fn (cb) {
							cb()		;					
						}						
			function fm () {
							console.log(666);
						}						
					fn(fm);

			function useTool(tool) {
				//var tool=add

				tool(100, 200)

			}

			function add(num1, num2) {
				//var num1=100
				//var num2=200
				console.log(num1 + num2)
			}
			// add(100,200)

			useTool(add())

函数可以传入数组,通过调用数组下标的方式进行调用函数

var fn=function() {
				console.log(666)
			}
			var a=200
			var b="hello"
			var arr=[fn,a,b]
			arr[0]()
			arr[0]()

求数组中的最大值:

var arr=[100,123,99999991,23,123,12,123999,1,23]
			var re=fn(arr)
			console.log(re)//123999
			function fn (data) {
				//var data=[100,123,1,23,123,12,123999,1,23]
				var temp=data[0]
				for(var i=0;i<data.length;i++){
					if(temp<arr[i]){
						temp=arr[i]
					}
				}
				return temp
			}

求数字的阶乘:

传入一个数字,返回!n  阶乘  123456789...n
			function fn (num) {
				//var num=10
				var sum=1;
				for(var i=1;i<=num;i++){
					sum = sum*i
				}
				
				return sum
			}
			
			var n=5
			var re=fn(n)
			console.log(re)

函数的声明:
函数会在最开始的时候进行声明,是整个代码块的提前声明而不是变量的那种只声明不赋值

			fn()
			
			function fn () {
				console.log(6666)
			}

但是如果是通过定义一个变量,让变量为一个函数这种则不会提前声明

			fn()
			var fn=function fm () {
				console.log(666)
			}
			//会报错  fn未定义

参数
参数为顺序赋值,第一个值只会传给第一个变量,以此赋值,如果参数传多了,不会影响程序的执行,多的数据会保存在arguments中,可以通过读数组的方式将其读出来,如果参数传少了,那么没有被定义的形参所在的位置的值通过arguments读出来则是undefined,为了不让程序中出现undefined,可以通过代码语句将其赋值为0

					num1=num1||0
					num2=num2||0

如果传入的值为非0的数,那么这段没有任何用,如果没有传入值,导致num为undefined,那么通过逻辑||运算将其变为0,不影响结果,但是这样会导致有些我不想让他变为0的值变为0,有一定的局限性
函数.length代表的是形参的个数.

四.方法

在对象中存在的函数,则为方法.可以通过调用对象中的方法名来运行函数,方法只能被对象访问,方法的访问者只能是方法的持有者,但是可以通过将其方法通过变量的方式让其他变量指向这段方法的空间进行使用

五.this

		系统为我们提供了很多关键字  this
		this代表的是一个对象
		this代表的是代码执行环境对象
		函数调用的对象是谁,this就是谁
		函数一定有一个对象调用

这是一个较复杂的点,难点在于通过多重嵌套后,不知道是什么对象进行的调用

function fn () {
			console.log(this)
		}
		var obj={}
		obj.say=fn		//将fn中的函数地址赋给了obj.say,这样就可以通过obj.say来调用这个函数
		obj.say()			//调用,调用这个函数的为obj

每一个函数的调用都是有对象的,如果没有显式的对象,那么则是window对象进行调用的

function fn () {
			console.log(this)
		}
		
		fn()//window.fn()

var obj1={name:"obj1",say:function fn () {console.log(this)}}
		var obj2={name:"obj2",say:obj1.say}		//只是函数的地址共享给了obj2中的say,进行访问还是通过obj2进行访问的
		
		
		obj1.say()//obj1
		obj2.say()//obj2

function fn () {
							//arguments=[fm]
			arguments[0]()		
		}		
		function fm () {
			console.log(this)
		}
		fn(fm,200)

本题将fm函数作为参数传入fn,这个时候fm的地址则被传入了argument[0],然后通过argument加下标的方式,进行调用函数,所以是argument进行的调用

function  fn(num1,num2) {
			console.log(this)		//win
			console.log(num1)		//100
			console.log(num2)		//obj1
		}						
		var obj1={name:"obj1"}
		obj1.say=function(cb) {
			var obj2={name:"obj2"}
			obj2.say=cb
			cb(100,this)			//cb(100,obj1)
		}									
		obj1.say(fn)

本题思考方向为第一段代码块是函数,可以先不用看,因为它不会执行,第二段代码,先定义一个obj1对象,有一个name属性,为obj1.再在下方进行赋属性,给obj1赋一个方法say,形参为cb,这个方法会定义一个obj2对象,有一个name为obj2的属性,赋一个say方法为cb,然后进行cb().然后看执行代码obj1.say(fn),执行这个方法,通过的是obj1来执行的这串代码所以其中的this是obj1,然后通过cb(100,this)来调用fn方法,这个方法是没有显式的对象进行引用的,所以其中的this为window

总结:
离this最近的function(嵌套)这个单词(没有这个单词直接就是wind),是哪个对象让它的代码跑起来的,this就是那个对象

六.new

new 后面跟的是一个函数名
用new来调用函数
1.创建一个空对象
2.用这个空对象去调用new后面的函数(构造函数)
3.表达式的结果:
如果函数的返回值是数据基本数据类型,表达的结果就是这个’构造过’后对象
如果函数的返回值是引用数据类型,表达式的结果就是函数的返回值,创建过的对象就消失了

function fn () {
			this.name="karen"
			this.say=function () {
				console.log("666")
				console.log(this)
			}
			return 1
		}
		var re=new fn()
		//var re={} ;  re.fn() 
		console.log(re)//{name:"karen",say:func}
		var fm=re.say
		
		console.log(fm());  //666  window
		
		console.log(re.say());  //666  "re" 	
		
		re:{
			var arr = [10, 20, 304]
				obj1.count = 200;			
				return {
					count: arr[0]			
				}
		}