JS那些奇怪的题目（2）

摘要：属性返回所属函数的函数名称。正确字符串如果格式错误构造函数返回的仍是一个的实例所以结果为第题解析一个的属性就是参数的个数。的结果中国标准时间，获得当前时间是个对象，是获得当前时间是个字符串。

[1 < 2 < 3, 3 < 2 < 1]

解析：如果加上括号就清楚了许多。
(1 < 2) < 3 => (true) < 3 => 1 < 3 => true
(3 < 2) < 1 => (false) < 1 => 0 < 3 => true

所以结果为 [true, true]

2 == [[[2]]] //是真还是假？

解析：让我们来看看类型转换。

引用类型转换为基本类型(所有的引用类型转换为布尔值都是true)

引用类型转换为字符串

1.优先调用toString方法（如果有），看其返回结果是否是原始类型，如果是，转化为字符串，返回。 2.否则，调用valueOf方法（如果有），看其返回结果是否是原始类型，如果是，转化为字符串，返回。 3.其他报错。

引用类型转化为数字

1.优先调用valueOf方法（如果有），看其返回结果是否是基本类型，如果是，转化为数字，返回。 2.否则，调用toString方法（如果有），看其返回结果是否是基本类型，如果是，转化为数字，返回。 3.其他报错。

valueOf()得到的都是对象本身，toString()方法转为字符串就不用说了.

以下来自犀牛书：

1，null和undefined，相等。 
2，数字和字符串，转化为数字再比较。 
3，如果有true或false，转换为1或0，再比较。 
4，如果有引用类型，优先调用valueOf。 
5，其余都不相等。

回到本题，调用valueOf()返回的是本身不是基本类型，然后调用toString()得到"2"，然后变成了字符串和数字（"2" == 2）进行比较。

所以结果为 true

3.toString();
3..toString();
3...toString();

解析：.在JS里是方法的调用的一种写法，但是数字也是可以有小数点的。你用3.toString()会将其解析为一个带小数点的数字，不会调用。

以下可以成功转换

(3).toString(); 
3..toString(); 
"" + 3; 
String(3);

所以结果为 error "3" error

(function () {
    var x = y =1;
    })();
 console.log(y);
 console.log(x);   

解析：此时x是局部变量但是y是全局变量。在外部试图访问内部变量x时会出现错误。

所以结果为 1 error

var a = /123/,
    b = /123/;
a == b;
a === b;

解析：ab都是正则，正则也是对象。

2个引用的是同一个对象、函数、数组，则它们相等，如果引用的不是同一个对象、函数、数组，则不相同，即使这2个对象、函数、数组可以转换成完全相等的原始值。

所以结果为 false false

var a = [1, 2, 3],
    b = [1, 2, 3],
    c = [1, 2, 4];
a ==  b
a === b
a >   c
a <   c

解析：同上题。比较大小时，就按照字典序比较。

所以结果为 false false false true

var a = {}, b = Object.prototype;
[a.prototype === b, Object.getPrototypeOf(a) === b]

解析：只有函数才会有prototype属性，所以a.prototype为udnefined。Object.getPrototypeOf(obj)返回一个具体对象的原型(该对象的内部[[prototype]]值)

所以结果为 false true

function f() {}
var a = f.prototype,
    b = Object.getPrototypeOf(f);
a === b;

解析：var f1 = new f()此时f1是一个从f.prototype继承而来的对象（f1是一个实例对象），f.prototype是使用new创建的实例（f1）的原型。所以a是实例的原型，而b是f的原型。所以a不同于b。

参考：继承与原型链

var o = {a: 1}; //o这个对象继承了Object.prototype上面的所有属性
//原型链如下o > Object.prototype > null
var a  = ["uo", "waht"]; //数组都继承Array.prototype
//原型链如下a > Array.prototype > Object.prototype > null
function f() {} //函数都继承Function.prototype
//原型链如下f > Function.prototype > Object.prototype > null

所以结果为 false

function foo() { }
var oldName = foo.name;
foo.name = "bar";
[oldName, foo.name] //输出什么？

解析：(╯‵□′)╯︵┻━┻。name属性返回所属函数的函数名称。Bloody Hell!

参考Function.name

var object = {
    firstMethod: function first() {},
    secondMethod: function () {}
};
console.log(object.firstMethod.name); //first
console.log(object.secondMethod.name); //""

另外函数的name属性不能被更改，因为它是只读的。

所以结果为 ["foo", "foo"]

"1 2 3".replace(/d/g, parseInt)

解析：和第一题还是很类似的。

str.replace(/d/g, function ($0, $1, $2.. , index, string) { }) //$0匹配的子串 $1第一个括号匹配的字符串 。。。类推

由于没有分组，所以相当于

parseInt("1", 0); //1
parseInt("2", 2); //NaN
parseInt("3", 4); //3

所以结果为 [1, NaN, 3]

function f() {}
var parent = Object.getPrototypeOf(f);
f.name // ?
parent.name // ?
typeof eval(f.name) // ?
typeof eval(parent.name) //  ?

解析：由30题和31题，可以得到答案。parent === Function.prototype

所以答案为 "f", "", "function", error

var lowerCaseOnly =  /^[a-z]+$/;
[lowerCaseOnly.test(null), lowerCaseOnly.test()]

解析：test函数会将参数转换为字符串。"null"和"undefined"。

所以结果为 [true, true]

[,,,].join(", ")

解析：真恶心还允许最后一个元素后跟一个,！长度为3的稀疏数组，但是并没有属性。

所以结果为 [, , ]

var a = {class: "Animal", name: "Fido"};
a.class

解析：与浏览器有关。Chrome下结果为"Animal"

var a = new Date("epoch")

解析：Date()可以接受一个字符串，该字符串应该能被Date.parse()方法识别。

//正确字符串
Date.parse("Wed, 09 Aug 1995 00:00:00")
//如果格式错误 构造函数返回的仍是一个Date 的实例 Invalid Date.

所以结果为 Invalid Date

var a = Function.length,
    b = new Function().length;
a === b; //?

解析：一个function的length属性就是参数的个数。另外Function.length定义为1

所以结果为 false

var a = Date(0);
var b = new Date(0);
var c = new Date();
[a === b, b === c, a === c]

解析：不传入参数获得当前时间。b的结果Thu Jan 01 1970 08:00:00 GMT+0800 (中国标准时间)，c获得当前时间是个对象，a是获得当前时间是个字符串。

所以结果为 [false, false, false]

var min = Math.min(), max = Math.max()
min < max //？

解析：Math.min()不传参数返回Infinity，Math.max()不传参数返回-Infinity

所以结果为 false

终于结尾了。