试试看 ？ 离奇古怪的javascript题目

typeof typeof(null)

答案"string"这个是10个中最简单的问题了
typeof typeof 的结果总是"string"测试结果
typeof({})
"object"typeof([])
"object"typeof(1)
"number"typeof(null)
"object"在本例中,typeof(null) 返回“object”

typeof foo == 'undefined'

typeof foo === 'undefined'

答案Yes 这里就是全等与==的区别了
==， 两边值类型不同的时候，要先进行类型转换，再比较。
===，不做类型转换，类型不同的一定不等一个决定性的因素，因为最终在每个比较来比较去的是两个字符串
当比较两个字符串,== 操作符不做任何类型的转化
,因此这两个比较将始终返回相同的结果。

100['toString']['length']

false.toString(); // 'false'
[1, 2, 3].toString(); // '1,2,3'

function Foo(){}
Foo.bar = 1;
Foo.bar; //

2.toString(); // 出错：SyntaxError

true.toString()
"true"false.toString()
"false"01.toString()
"1"0x20.toString()
"32"

2..toString(); // 第二个点号可以正常解析
2 .toString(); // 注意点号前面的空格
(2).toString(); // 2先被计算

(function(a,b){
//输出2
})['length']

fn = {
f : function(a,b,c){
//
}
};fn.f['length']

100['toString'].length

function toString( [radix : Number] ) : String

100..toString.length
1

var a = (1,5 - 1) * 2

j = 10;

for (i = 0; i <5; i++, j++) {
k = i + j;
}
i j k
0 10 10
1 11 12
2 12 14
3 13 16
4 14 18

var a = (1,2,3,4) //

var x = 10;
var foo = {
x: 20,
bar: function () {
var x = 30;
return this.x;
}
};console.log(
foo.bar(), // 1.
(foo.bar)(), // 2.
(foo.bar = foo.bar)(), // 3.
(foo.bar, foo.bar)() // 4.
);

11.1.6 The Grouping OperatorThe production PrimaryExpression : ( Expression ) is evaluated as follows: 1. Evaluate Expression. This may be of type Reference.
2. Return Result(1).NOTE This algorithm does not apply GetValue to Result(1). The principal
motivation for this is so that operators such as delete and typeof
may be applied to parenthesised expressions.

在一个函数上下文中，this由调用者提供，由调用函数的方式来决定。如果调用括号()的左边是引用类型的值，this将设为引用类型值的base对象（base object），在其他情况下（与引用类型不同的任何其它属性），这个值为null。不过，实际不存在this的值为null的情况，因为当this的值为null的时候，其值会被隐式转换为全局对象。注：第5版的ECMAScript中，已经不强迫转换成全局变量了，而是赋值为undefined。

alert( foo.bar === (foo.bar) ) //true

var foo = {
bar: function () {
alert(this);
alert(this === foo);
}
};

foo.bar(); // foo, true

var exampleFunc = foo.bar;

alert(exampleFunc === foo.bar); // true

// 再一次，同一个function的不同的调用表达式，this是不同的
exampleFunc(); // global, false

11.13.1 Simple Assignment (= )
The production AssignmentExpression : LeftHandSideExpression = AssignmentExpression is evaluated as follows:1. Evaluate LeftHandSideExpression.2. Evaluate AssignmentExpression.3.Call GetValue(Result(2)).4.Call PutValue(Result(1), Result(3)).5.Return Result(3).

8.7.2 PutValue(V, W)1. If Type(V) is not Reference, throw a
ReferenceError exception.
2. Call GetBase(V).
3. If Result(2) is null, go to step 6.
4. Call the [[Put]] method of Result(2), passing GetPropertyName(V)
for the property name and W for the value.
5. Return.
6. Call the [[Put]] method for the global object, passing
GetPropertyName(V) for the property name and W for the value.
7. Return.

...
6. If Type(Result(1)) is Reference, Result(6) is GetBase( Result(1)).
Otherwise, Result(6) is null.
7. If Result(6) is an activation object, Result(7) is null. Otherwise,
Result(7) is the same as Result(6).
8. Call the [[Call]] method on Result(3), providing Result(7) as
the this value and providing the list Result(2) as the
argument values.
…

(foo.bar = foo.bar)()

"" == "0" // false
0 == "" // true
0 == "0" // true
false == "false" // false
false == "0" // true
false == undefined // false
false == null // false
null == undefined // true
" \t\r\n" == 0 // true

"" === "0" // false
0 === "" // false
0 === "0" // false
false === "false" // false
false === "0" // false
false === undefined // false
false === null // false
null === undefined // false
" \t\r\n" === 0 // false