var length = 9;
var foo = {bar: function() {return this.length;},length: 0
};
(function f(a, b) {f.length = 3;console.log(f.length);//①console.log(arguments[0]());//②console.log(a());//③console.log((foo.bar)());//④arguments[1]="XXX";console.log(b);//⑤
})(foo.bar ,33,11);

function A(){alert(this);eval('alert(this)');(function(){alert(this);eval('alert(this)');})()
}
new A()
分别弹出什么？

function A(){this.x=1;}
function B(){this.y=2;return "OK";}
function C(){this.z=3;return Object("OK");}
问：
new A();
new B();
new C();
三者分别是什么类型对象?(即用Object.getPrototypeOf(obj)获得的值)可参考另一篇文章《JS中用new 创建对象及在构造函数中return的使用》

<script>//①if (!("a" in window)) {var a = 1;}alert(a);
//②function f(){if (!("b" in window)) {var b = 1;}alert(b);}f();
</script>

　　全局变量是window的属性

　　执行上下文分为进入执行上下文和执行代码两部分。变量声明和函数声明在进入执行上下文阶段就已完成。

　要注意的一点是 ①和②答案的不同原因在于 a 声明的是全局变量 而b因为是在函数中，所以是局部变量。

var a = 1;
alert(b);var b = function a(x) {x && a(--x);
}
alert(a);①这里的Function b 不是函数声明 而是函数表达式。所以只能在执行到代码的时候才会赋值。
②Function b 中的 a 只是匿名函数的别名，而且是个只能在 Function b里使用的局部变量。也就是说跟变量a没有关系，不会发生覆盖。

var a = 1;
function a() { }
function b() { }
var b;
console.log(a);
console.log(b);//这里考察的是变量声明，变量赋值，函数声明的顺序:
//进入执行上下文后先进行函数声明，然后是变量声明，最后进行变量赋值。并且如果函数或变量已经存在，将不会重新声明。//也就是说，即使把变量声明并赋值写到函数声明前面，也还是会按照上面的顺序进行。

上面的代码等同于function a() { }function b() { }var a, b;a = 1;

function A() {function m(){console.log(this);}this.test = function() {m.call(this);m.call(null);};
}
(new A()).test();//this值的定义：当一个方法在对象上调用的时候，this就指向到了该对象上
//m.call(this)的结果肯定是没问题的
//当call和apply的第一个参数是null或undefined时，参数将替换成window对象

var arr = [3,5,2,7,10,8];
①Math.max.apply([],arr);
②eval("(Math.max("+arr+"))");
这是目前看到的最好最简洁两种方案了，活用apply和eval
题外话:大家初学的时候都被告诫要“远离”eval，实际上，如果合理使用的话，eval绝对是把利器。

var a = [2,4,6,3];
var b =a.map(function(i,o){return function(){return console.log(i);};
});

var arr = [{A:32,B:2,C:5},{A:32},{A:32,B:2,C:5,D:7},{A:32,B:2,C:5}
];
arr.sort(function(m,n){function getPropCount(obj){var i=0;if(typeof obj == "object"){for(var p in obj){++i;}}return i;}return getPropCount(m) - getPropCount(n);
});

Number.prototype.plus = function(num) {return this + num;
};
Number.prototype.minus = function(num) {return this - num;
};
console.log((5).plus(3).minus(6));这里 (5).plus(3).minus(6) 可以用 5..plus(3).minus(6)代替
但不可以用 5.plus(3).minus(6)
数字后面的第一个小数点是属于数字部分的，相当于 5.0.plus(3)，第二个才是调用方法。
所以 5.plus()是会出错 而 5..plus()却可以

function add(x) {function fn(m) {fn.pValue = m + (fn.pValue || 0);return fn;};fn.pValue = x;fn.toString = fn.valueOf = function() {return fn.pValue;}return fn;
}
这里主要考察的是toString的重载。例如下面的例子
var arr = [1,3,5]
console.log(arr+""); // "1,3,5"
Array.prototype.toString=function(){return this.join("--");
}
console.log(arr+""); // "1--3--5"

var x = 1;
(function() {var x = 2;function funcA() {console.log(this.x);}with ({funcB: function() { console.log(this.x); }, x: 3}) {function funcC() {console.log(this.x);}funcA();//?funcB();//?funcC();//?};
} ())

var A = true;
setTimeout(function(){A = false;
},1000);while(A){}alert("End");
//问：大约过多久会alert?

(function(){return typeof arguments;})();1.“object”2.“array”3.“arguments”4.“undefined”

考点：arguments是类似于数组的对象，访问方式与数组相同

var f = function g(){ return 23; };typeof g();“number”“undefined”
 “function”Error

g是f方法的别用，且只能在f方法的内部使用

(function(x){delete x;return x;})(3);3 nullundefinedError

delete 只用于删除某个对象的属性，如果没有指定对象的话，则默认是window而这里面的形参x显然不是属性

var y = 1, x = y = typeof x;
console.log(x);1“number”undefined“undefined”

考点：变量声明与赋值的时机

 (function f(f){return typeof f();})(function(){ return 1; });“number”“undefined”“function”Error

var foo = {bar: function() { return this.baz; },baz: 1
};
(function(){return typeof arguments[0]();
})(foo.bar);“undefined”“object”“number”“function”

var foo = {bar: function(){ return this.baz; },baz: 1}
typeof (f = foo.bar)();“undefined”“object”“number”“function”

var f = (function f(){ return "1"; }, function g(){ return 2; })();
typeof f;“string”“number”“function”“undefined”

var x = 1;
if (function f(){}) {x += typeof f;
}
x;1“1function”“1undefined”NaN

这个答案在浏览器间存在差异

var x = [typeof x, typeof y][1];
typeof typeof x;“number”“string”“undefined”“object”

(function(foo){return typeof foo.bar;})({ foo: { bar: 1 } });“undefined”“object”“number”Error

这个问题是考眼力的。。。匿名函数的实参相当于 var arg = {foo:{bar:1}};所以在函数执行的时候 相当于

var arg = {foo:{bar:1}};return arg.bar;

 (function f(){function f(){ return 1; }return f();function f(){ return 2; }
})();12Error (e.g. “Too much recursion”)undefined

考点：函数的声明与赋值时机

function f(){ return f; }
new f() instanceof f;truefalse

相当于 f instanceof f;

with (function(x, undefined){}) length;12undefinedError

乍看好像有点蒙  分解一下就好了

var f = function(x,undefined){};with(f){ length; } //这句再恢复一下就是 with(f){ return f.length;}

console.log(Function instanceof Object);
var arr = [];
console.log(arr.constructor === Array.prototype.constructor);var num = new Number(2);
console.log(typeof num);

(function(){var a=b=1;
})();
console.log(a);console.log(b);

(function(){'use strict';var a = window.b=1;
})();