js学习

学习了 表严肃的视频
关于回调函数（回调函数有无名字都可以）：

这种情况我们就可以把我们想做的写到一个函数里，交给买()来执行：

function 买(一旦交易成功) {
  console.log('交易成功')

  /*检测是否有回调函数*/
  if(一旦交易成功) {
    /*如果有回调函数就触发它*/
    一旦交易成功();
  }
}

function 发货() {
  console.log('发货');
  console.log('短信通知买家已发货');
}
买（发货）;   //调用时传个函数名进去即可

或者在调用时接收匿名的回调函数：

function fun1(arr,fun2) {   //定义fun1
	console.log(arr);
	fun2(arr);
}  

fun1(12,function (data) {    //调用fun1时传入的函数是匿名函数
	if(data > 9)
	 console.log(data);
})；

如何动态的获取传参？（并不限制传参的个数）
使用arguments关键词

定义全局变量var a = 1;等价于 window.a = 1，定义的全局变量相当于给window对象增加一个属性，所以要谨慎定义全局变量，因为你定义的全局变量可能会覆盖window对象原生的同名属性。

闭包就是函数套函数，闭包当成getter/setter来用，如下：

function user(name) {
	var sex,age;
	return {     //return返回一个对象
		getName: function() {
			return name;
		},             //记得加逗号
		setName: function(newName) {
			name = newName;
		},         //记得加逗号
		getSex: function() {
			return sex;
		},
		setSex: function(newSex) {
			sex = newSex;
		},
		getAge: function() {
			return age;
		},
		setAge: function(newAge) {
			age = newAge;
		},
	}
}

var whh = user('wang hua hua');
whh.setAge(20);
whh.setSex('female');

var name = whh.getName();
var sex = whh.getSex();
var age = whh.getAge();
console.log(name,sex,age);

关于时间的函数：

var count = 0;
var timer1 = setInterval(function(){
	count++;
	if(count > 3) {
		clearInterval(timer1);  //清除定时器timer1，防止无限地打印
		return; // 要加return 的原因是就算clearInterval实行了清除定时器timer1，也会把当前的function执行完（也就是会输出4），所以要加return
	}
	console.log(count);
},1000);

匿名函数调用方法：

(function(){ 定义函数体 内部的this是undified })();

this 的三种情况，this不取决于它所在的位置，它取决于它所在的函数是怎样被调用的：
第一种：如果是以 对象.方法A（）（有点.） 的形式调用方法 ，那么方法A内的this就是父级对象
例如：

var person = {        //定义一个对象
	fname: 'hah',
	lname: 'li',
	fullname: function() {
		return this.fname + this.lname;   //此处的this等于父级对象也就是person对象
	}
}
person.fullname（）; //是以 对象.方法A（） 的形式调用，所以this等于父级对象也就是person对象

又或者：

 var person = {        //定义一个对象
    fname: 'hah',
    lname: 'li',
    a:{
	    fullname: function() {
	    	return this.fname + this.lname;   //此处的this等于父级对象也就是等于person里面的a对象
	    }
    },
}
  person.a.fullname（）; //是以 对象.方法A（） 的形式调用，所以this等于父级对象也就是a对象

第二种：如果是直接调用方法 方法B（） （没有点.），那么方法B内的this就是undified（严格模式）或者window对象（非严格模式）。

 var person = {        //定义一个对象
    	fname: 'hah',
    	lname: 'li',
    	fullname: function() {
    		return this.fname + this.lname;   //此处的this等于父级对象也就是person对象
    	}
    }
  var getFullname = person.fullname;     //还可以这么玩，此时 fullname 还没有被调用
   getFullname();      //是以 方法B（） 的形式调用（没有点），所以this等于undified或者window对象

第三种：如果用new的方式来定义，那么this 就是即将被创建的对象

function User() {
	this.name = 'whh';     //this 指得是 whh
	this.sex = 'girl';
}
var whh = new User();

这是this的程序：

function yo() {
	console.log('yo' + this.name);  //使用this可以动态赋值
}

var whh = {
	name: 'whh',
};

var lsd = {
	name: 'lsd',
};

whh.yo = yo;  //注意这里
lsd.yo = yo;
whh.yo(); //注意这里
lsd.yo();

调用函数 fun1()； 和 fun1.call( )； 是等同的，前者是后者的简写，使用call可以绑定对象到函数的this中：

 例子一： 
 function yo() {
    	console.log('yo :--' + this.name);
 }

var whh = {
	name: 'whh',
}; 
var lsd = {
	name: 'lsd',
};    
yo.call(whh);    //把whh对象绑定到yo函数的this中,直接执行yo函数
yo.call(lsd);  //把lsd对象绑定到yo函数的this中,直接执行yo函数



例子二
    function yo(kidname , age) {
    	console.log('yo :--' +kidname + age +this.name);
    }

var whh = {
	name: 'whh',
};

var lsd = {
	name: 'lsd',
};

yo.call(whh,'www',34);   //call函数的第一个参数是对象，后面的参数就一一对应
yo.call(lsd,'lll',23);
yo.apply(lxl,['lee',30]); //apply方式就是后面的参数以数组的形式传，直接执行apply函数
yo2 = yo.bind('whh');   //此时yo函数并没有执行，bind只是返回一个新函数
yo2('www',34);  //然后再执行新函数

触发函数执行的方法有4种：
1、

正常版

启动();

function 启动() {
  'use strict';
  // ...
}

2、

懒癌版

(function () {
  'use strict';
  // ...
})();

/*
可以这样理解
先用括号把这个匿名函数包起来：
(匿名函数)

然后执行：
(匿名函数)();
*/

3、

懒癌晚期版

!function () {  //注意前面有叹号！
  'use strict';
  // ...
}();

4、

懒癌领悟版

;(function () { // 行首的分号是干嘛的？
  'use strict';
  // ...
})();
那个分号是为了给前一个依赖文件擦屁股，js文件压缩时会依次将不同文件连接起来，然后去掉所有空格断行注释之类的东西，这样一来两个文件前后就黏一块了。压缩前好好的，压缩后就跑不起来了？卡了3天，没有任何头绪，难道代码需要呼吸？