JS逗号运算符，apply和call调用模式，匿名函数，arguments，字面量创建【诗书画唱】
可能的面试部分：apply和call调用模式的区别是什么？我个人给出的答案：
apply后面要传的参数要以数组的形式框起来，而call后面要传的参数只要用逗号隔开就可以了，他们的效果是差不多的，就是后面传的参数的写法不同，一般我可能选择call，因为更简化。
test.apply(param,[1,2,3]);
test.call(param,1,2,3);
个人想法：有时先确定节奏后考试，写代码，做项目，创作游戏，创作音乐，创作视频，创作动漫，创作专栏等等的话就是更加的高效，有时追求简化而不缺失等等，是很好的方法。
概括：
个人对逗号运算符的理解和记忆规则等的方法
0、解释以下的语法现象：
var arr1 = [[true,2,'one'][3],[1,{"num":47}][1]['num']];
var i = 3;
var arr2 = [(i -= 2,[true,'abc'][i]['length']),[[],[][0]][1]];
1、定义一个函数，他有两个参数，一个是执行次数，一个是需要执行的函数，调用这个函数。
2、定义一个函数，它的返回值是另外一个函数，另外这个函数有一个打印语句，请调用函数运行这个打印语句。
3、同时定义和运行一个匿名的函数，计算1到100之间的整数和
4、创建一个猫Cat对象，包含一个体重weight属性和吃饭eat的方法，每调用一次eat方法，体重就加1，调用3次eat方法后，在控制台打印出猫的体重。
5、创建一个Car对象，包含一个花费属性cost和run方法，run方法中包含一个参数公里数kl，每跑1公里，花费就增加0.8元，调用run方法后，打印出花费。
6、创建一个Dog对象，包含一个摇尾巴shake的方法，该方法有一个参数name，当name等于'Tom'时，在控制台打印‘主人回来了’，其他的值不执行任何代码。
7、创建一个函数，包含一个参数a，当a是函数时，执行a，否则打印出a的值。
8、在页面创建三个按钮，通过js脚本循环给这三个按钮绑定一个点击事件，当点击第一个按钮弹出数字0，第二个按钮弹出数字1，第三个按钮弹出数字2。。。
字面量创建
我试过，这里如果不使用“声明函数，
for循环中调用传参的函数”的方法，
那么在for循环中直接绑定传要弹出的值i，
会击按钮就都是弹出3，是不对的
fn6()();
参数是函数的函数
返回值是函数的函数
逗号运算符最后返回的是（）里面用逗号运算符隔开的式子的最后一个式子的结果。
定义声明函数
在函数中自己调用自己
函数的内置对象
arguments
调用匿名函数
函数的四种调用模式
方法调用模式:调用对象中的一个方法
函数调用模式
构造器调用模式
apply和call调用模式
如果是构造器调用模式调用的函数首字母必须是大写
构造函数Function
自己写的代码笔记注释的部分CTRL+F等等（前面的“概括”等等也可以CTRL+F......）：
声明函数
调用函数
调用函数返回函数
传alter弹出框功能到函数中
代入法理解调用函数中的函数（参数是函数的函数）
常用的不命名的匿名函数的调用
函数的4种调用模式
个人对逗号运算符的理解和记忆规则等的方法 START
逗号运算符最后返回的是（）里面用逗号运算符隔开的式子的最后一个式子的结果。
个人对逗号运算符的理解和记忆规则等的方法 END
作业的题目和自己写出的自己理解的答案 START
0、解释以下的语法现象：
var arr1 = [[true,2,'one'][3],[1,{"num":47}][1]['num']];
var i = 3;
var arr2 = [(i -= 2,[true,'abc'][i]['length']),[[],[][0]][1]];
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
//现象1
var arr1 = [[true,2,'one'][3],[1,{"num":47}][1]['num']];
for(var i=0;i<arr1.length;i++){
console.log("arr1的对象："+arr1[i])
}
//打印结果：arr1的对象：undefined arr1的对象：47
//现象2
var i = 3;
var arr2 = [(i -= 2,[true,'abc'][i]['length']),[[],[][0]][1]];
for(var i=0;i<arr2.length;i++){
console.log("arr2的对象："+arr2[i])}
//打印结果：arr2的对象：3 arr2的对象：undefined
</script>
<body>
现象1：
按F12看控制台的打印的结果可以知道arr1是个数组，
是由[true,2,'one'][3]和[1,{"num":47}][1]['num']这2个对象构成，
[true,2,'one'][3]的意思是获取[true,2,'one']数组中的下标为3的对象，因为
true,2,'one']数组中不存在下标为3的对象，所以就是打印出undefined，
[1,{"num":47}][1]['num']]的意思是先从[1,{"num":47}]数组中
获取下标为1的对象，即为{"num":47}，之后从下标为1的对象中获取名为
num属性的对应的值，就是47.
现象2： 按F12看控制台的打印的结果可以知道arr2是个数组，
是由(i -= 2,[true,'abc'][i]['length'])和[[],[][0]][1]这2个对象构成，
因为开始var i = 3;，
(i -= 2,[true,'abc'][i]['length'])中是逗号运算符，
（）里面用逗号运算符隔开的对象都会执行，如果都进行赋值，就都会变
，i-=2的结果是1，那么[true,'abc'][1]['length']的结果是3，
逗号运算符最后返回的是（）里面用逗号运算符隔开的式子的最后一个式子的结果。
[[],[][0]][1]就是取出[[],[][0]]数组中下标为1的对象[][0]，而[][0]
是取出[]中下标为0的对象，因为不存在，所以打印出来时会是undefined
</body>
</html>
1、定义一个函数，他有两个参数，一个是执行次数，一个是需要执行的函数，调用这个函数。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
function f(a,b){
for(i=1;i<=a;i++){
b();}
}
f(3,function(){document.write(" 执行a这个函数了")})
</script>
<body>
</body>
</html>
2、定义一个函数，它的返回值是另外一个函数，另外这个函数有一个打印语句，请调用函数运行这个打印语句。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
function f5(){
return function()
{console.log("三连！看到这句话说明成功用f5()()"
+"调用了函数中return的函数中的控制台打印语句")}
}
f5()();
</script>
<body>
</body>
</html>
3、同时定义和运行一个匿名的函数，计算1到100之间的整数和
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
(function(a){
var h=0;
for (var i=1;i<=100;i++) {
h=h+i;
}
a.write(h)
})(document)
</script>
<body>
</body>
</html>
4、创建一个猫Cat对象，包含一个体重weight属性和吃饭eat的方法，每调用一次eat方法，体重就加1，调用3次eat方法后，在控制台打印出猫的体重。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
var Cat={
weight:100,
eat:function(){
this.weight=this.weight+1;
console.log(this.weight+"g")
}
}
Cat.eat();
Cat.eat();
Cat.eat();
</script>
<body>
</body>
</html>
5、创建一个Car对象，包含一个花费属性cost和run方法，run方法中包含一个参数公里数kl，每跑1公里，花费就增加0.8元，调用run方法后，打印出花费。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
var Car={
cost:0.8,
run:function(kl){
//消费指的是总消费还是每公里的单价消费？这题没说得明确。所以我说这题有歧义。
console.log("这题其实有歧义，这题我简化理解为每跑1公里，"+
"总消费就是加0.8元，所以cost为0.8元/公里。"+"跑了"+kl+"公里，"+
"累计花费为："+0.8*kl+"元")
}
}
Car.run(1);
</script>
<body>
</body>
</html>
6、创建一个Dog对象，包含一个摇尾巴shake的方法，该方法有一个参数name，当name等于'Tom'时，在控制台打印‘主人回来了’，其他的值不执行任何代码。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
var Dog={
shake:function(name){
name=='Tom'?console.log("主人我回来了"):false;
}
}
Dog.shake('Tom');
Dog.shake('Jerry');
</script>
<body>
</body>
</html>
7、创建一个函数，包含一个参数a，当a是函数时，执行a，否则打印出a的值。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
function fn7(a,msg){
if(typeof a === 'function') {
a(msg);
}else {
console.log(a);
}
}
fn7(function(str){
alert(str);
},'诗书画唱叫你三连和关注！看到这句话说明，调用时传的是传参数的函数！');
fn7("看到这句话说明，调用时，传的不是函数！",'诗书画唱叫你三连和关注！');
</script>
<body>
</body>
</html>
8、在页面创建三个按钮，通过js脚本循环给这三个按钮绑定一个点击事件，当点击第一个按钮弹出数字0，第二个按钮弹出数字1，第三个按钮弹出数字2。。。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
window.onload=function(){
var arr=document.getElementsByTagName("button");
function f(i){
arr[i].addEventListener('click',function(){
alert(i);/*——>我试过，这里如果不使用“声明函数，
for循环中调用传参的函数”的方法，
那么在for循环中直接绑定传要弹出的值i，
会击按钮就都是弹出3，是不对的*/
});
}
for(var i=0;i<arr.length;i++){
f(i);
}}
</script>
<body>
<button>按钮1</button>
<button>按钮2</button>
<button>按钮3</button>
</body>
</html>
作业的题目和自己写出的自己理解的答案 END
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script>
//定义声明函数
//1函数声明
function fn1(){
console.log('Hello world');
}
//2字面量创建
//var o = {};
//var arr = [];
//将一个没有名字的函数赋值给了变量fn2
var fn2 = function(){
}
//3构造函数Function
var fn3 = new Function('alert("Hello world");');
//调用一个函数：在需要被调用的函数名后面加上一对括号
//fn1();
//fn2();
//fn3();
//函数的参数
function fn4(a,b,c){
console.log(a,b,c);
}
//调用函数时,如果参数的个数和函数的参数列表的个数不一样,
//那么调用这个函数时是不会报错的,参数的值会对号入座,不够的值就用undefined代替
//fn4(1,5);//1,5,undefined
//fn4(1,5,6,7);//1,5,6
//JS函数的返回值类型是可以变化的
function fn5(b){
if(b) {
return {name:'Tome'};
} else {
return 'Hello';
}
}
//console.log(fn5(true).name);
//返回值是函数的函数
function fn6(){
return function(){
alert('Hehe');
}
}
//var f = fn6();
//f();
//fn6()();
//参数是函数的函数
function fn7(a,msg){
if(typeof a === 'function') {
a(msg);
}else {
console.log('a不是一个函数');
}
}
// fn7(function(str){
// alert(str);
// },'你好');
//调用匿名函数
(function(doc){
doc.write('Hello world');
})(document);
//函数的四种调用模式:
//1方法调用模式:调用对象中的一个方法
var stu = {
score: 60,
study: function(){
//console.log(this == stu);
this.score += 5;
}
};
stu.study();
stu.study();
//console.log(stu.score);
var cat = {
name: '咪咪',
eat: function(){
console.log(this == cat);
console.log(this.name);
}
};
//cat.eat();
//2函数调用模式
function add(a,b){
console.log(this == window);
return a + b;
}
add(1,2);
//3构造器调用模式
//如果是构造器调用模式调用的函数首字母必须是大写
var Stu = function(n){
this.name = n;
}
var s1 = new Stu('小明');//this == s1
console.log(s1.name);
var s2 = new Stu('小红');//this == s2
console.log(s2.name);
var Cat = function(a){
this.age = a;
}
var c1 = new Cat(2);//this == c1
console.log(c1.age);
//4apply和call调用模式
function test(x,y,z){
console.log(this.flag);
console.log(x,y,z);
}
//var flag = 'abc';
//test();
// var param = {
// flag: 'phoniex'
// };
//改变了test函数中this的指向,this == param
// test.apply(param,[1,2,3]);
// test.call(param,1,2,3);
function perform(str){
console.log(str + this.name);
}
var p = {
name: '张三'
};
perform.call(p,'你好');
//函数的内置对象
function show(){
for(var i = 0;i < arguments.length;i ++) {
console.log(arguments[i]);
}
}
show(1,2,3,'one','mee');
// function (){
// //在函数中自己调用自己
// arguments.callee();
// }
</script>
</head>
<body>
</body>
</html>
<!--
CTRL+F：
声明函数
调用函数
调用函数返回函数
传alter弹出框功能到函数中
代入法理解调用函数中的函数（参数是函数的函数）
常用的不命名的匿名函数的调用
函数的4种调用模式
-->
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<script>
//声明函数 START
var f1=function(){}
//var f2=new function()
function f3(a,b,c){
console.log(a,b,c);
}
function f4(b){
if(b){
return {name:'诗书画唱'}
}
else{
return "三连"
}
}
//声明函数 END
// 调用函数 START
//f2();
f3("三连","关注","诗书画唱")
console.log(f4(true).name)
// 调用函数 END
//调用函数返回函数 START
function f5(){
return function(){alert("三连！")}
}
f5()();
//调用函数返回函数 END
//传alter弹出框功能到函数中 START
function f6(a){
a("三连！")
}
f6(alert);
//传alter弹出框功能到函数中 END
//代入法理解调用函数中的函数（参数是函数的函数） START
function f7(a,msg)
{
if(typeof a==="function"){
a(msg)
}
else{
console.log("看到这句话，说明传过来的a参数不是function函数")
}
}
f7(function(str){alert(str);},"给诗书画唱三连！看到这句话说明msg被赋值了！");
//代入法理解调用函数中的函数（参数是函数的函数） END
//常用的不命名的匿名函数的调用 START
(function(a){a.write("诗书画唱提醒你！看到这句话说明成功调用了匿名函数中的方法！");})(document)
//常用的不命名的匿名函数的调用 END
//函数的4种调用模式 START
//1.方法调用模式
var a={
score:100,
do:function(){
console.log("三连！看到这句话说明成功调用了a对象中的do方法！")
console.log(this===a)//————>（这里的this等价于当前a对象）
console.log(this.score+"分")//————>（这里的this表示当前a对象）
}
}
a.do();
//2.函数调用模式
function f(a,b){
console.log(this)//——>这里打印出的内容是Window，这里的this代表的是Window
return a+b;
}
f("关注"+"诗书画唱")
//3.构造器调用模式
var F=function(n){
this.name=n;//——>this是调用时，new出来的对象，比如下面的f1
}
var f1=new F("点赞！");
var f2=new F("关注！");
console.log(f1.name)
console.log(f2.name)
//函数的4种调用模式 END
</script>
<body>
</body>
</html>
