函数是在外部声明的，作用域绑定外层，所以foo函数会在外层找x
标识符
第一个字符，可以是任意Unicode字母（包括英文字母和其他语言的字母），以及美元符号（$）和下划线（_）。
变量不能包含* + - ,不能使用保留字，开头不能是数字
下面4个表达式中，结果为NaN的是？
100 / 0 //这个是Infinity其余是 NaN
0 / 0
parseInt('爱前端')
'asd' - 'qwe'
可以连续使用赋值语句
var a=b=c=d=3
//a,b,c,d都为3
变量的重新声明如果不赋值则无效
var a=2;
var a;
a // 2
function fn(){console.log(2)};
var fn;
fn // function fn(){console.log(2)}
变量赋值的时候，忘了写var命令，这条语句也是有效的。
a = 3;
a // 3
如果该变量是在函数内部，则变量被视为全局变量
function q(){ t=1;console.log(t)};
q() //必须执行函数，函数内部的语句才会执行
t // 1
函数内部的同名变量会覆盖，函数外部的同名变量
var a = 10;
function test() {
a = 5;
alert(a);
alert(this.a);
var a; //此a非彼a
alert(this.a); 函数在window下调用，this指向window
alert(a);
}
test()
new 会将
今天是题目是
1.输出结果和原因
console.log(a);
console.log(b);
window.b = 10;
var a = 20;
2.函数表达式和函数声明的特点。
答案：
1.
undefined 报错
由于变量提示，console.log(a);返回undefined
window.b = 10;是属性赋值动作，console.log(b);找不到b
2.
采用function命令声明函数时，变量提升会提升整个函数
如果采用赋值语句定义函数，变量提升只是变量名
a();
function a(){console.log(1)}
b();
var b=function(){console.log(2)}
//1, b is not a function
如下代码输出什么：
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
答案：10
//函数是在外部声明的，作用域绑定外层，所以foo函数会在外层找x
如下代码输出什么：
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
答案：30
立即执行函数表达式：定义函数之后，立即调用该函数
在函数内部声明的，作用域绑定函数内部
如下代码输出什么：
var a=1;
var a;
console.log(a)
答案：1,如果使用var重复声明一个已经存在的变量，是无效的，但是如果第二次声明的时候还赋值了，他就会覆盖掉前面的值
function fn(){
var a=1
function fb(){
var a;
console.log(a)
}
return fb
}
var result=fn()
result()
var a=100;
function a(){}
console.log(a)
//相当于执行：
先把变量提升剪切上去
var a;
function a(){};
a=100;
console.log(a)
三元条件运算符用问号（?）和冒号（:），分隔三个表达式。如果第一个表达式的布尔值为true，则返回第二个表达式的值，否则返回第三个表达式的值。
true ? 'hello' : 'world' // 'helo'
function fn(a,b,c){
console.log(arguments.length) //函数调用时的实参
console.log(arguments.callee.length) // 函数调用时的形参
}
fn(2,3,4,5,6)
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
return function(){
return this.name;
};
}
};
alert(object.getNameFunc()()); 函数圆括号执行：函数的上下文是window
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
var that = this;
return function(){
return that.name;
};
}
};
alert(object.getNameFunc()());
var m=1;
var obj={
fn1:function(){
console.log(this)
return this.fn2(); //obj.fn2(),fn2里的this指向obj
},
fn2:fn2,
m:2
};
function fn2(){
console.log(this)
return this.m
}
var result = obj.fn1(); //fn1里的this指向obj
console.log(result)
var length = 5;
var arr=[fn1,fn2];
function fn1(){
return this.length;
}
function fn2(){
return this[0] //fun
}
var a = arr[0](); 函数作为数组的元素，被索引出来执行，函数的上下文是这个数组。
var b = arr[1]()(); 当从对象、数组中已经枚举出一个函数，此时再次圆括号调用，等同于window调用它。
console.log(a)
console.log(b)
function sum(a, b, c, d) {
console.log(typeof arguments);//Object
console.log(arguments);
//arguments.callee它指向的是这个sum函数，打点length是这个函数的形参个数
console.log(arguments.callee.length);
//arguments.length它是sum函数的实参个数
console.log(arguments.length);
}
sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "J");
//函数有一个属性.length->形参个数
alert(sum.length); //arguments.callee.length
function fn(){
alert(this.a)//红色的对象：因此this.a==3;
}
var obj = {
"a":1,
"b":2,
"c":[{
"a":3,
"b":4,
"c":fn
}]
}
var a = 5;
obj.c[0].c() //作为对象的方法被调用，指向最后调用它的方法,指向 obj.c[0]
function fun(m,n,o,p,q,r){
alert(this.callee.length):这里的this就是Arguments（类数组对象），他的callee指向的是f函数打点length是形参的个数，因此答案为2
大招5：可以解决
};
function f(a,b){
/*var array =[fun,5,6,7]
Array[0](9,10,11,12,13);
*/
arguments[0](9,10,11,12,13);
}
f(fun,5,6,7);
var a = 4;
function b(x,y,a){//x=1，y=2，a=3
alert(a); //3
arguments[2] = 10; //var array = [1,2,3]; array[2]=10
alert(a);
}
a = b(1,2,3);//传进了三个实参 b(1,2,3);它没有返回值//a是undefined
alert(a);
var obj = {
"a":function(){
return this.b;//obj.b:this(函数上下文是obj)
},
"b":function(){
return this.c;
},
"c":1
};
var result = obj.a()();//函数圆括号执行：函数的上下文是window
console.log(result);//undefiend：因为window对象没有c这个属性。
