javascript面试题，二

24.

function foo() { }
var oldName = foo.name;
foo.name = "bar";
[oldName, foo.name]
// [foo,foo]

　　函数实例会有一个内置的name属性,这个函数使只读的不可修改,所以两个都是foo

25.

var ary = Array(3);
ary[0]=2;
ary.map(function(elem) {
    return '1';
});
// logs [1, , ]

　　设置一个空数组var ary = [ , , , ],然后更改ary里的索引为0 的数为2,则为ary = [2, , ],然后用数组方法map循环数组,返回1,map循环时只会循环有数据的内容,所以只会把2改为1,当后面为空时,map不会继续执行.

26

[1 < 2 < 3, 3 < 2 < 1]
//logs[true,true]

　　true 1; false -1

数据运算会按顺序运算,1<2<3,运算时,先比比较1<2,然后返回true,true和3比较,true转换为数组类型,为1,1<3所以为true

　　3<2<1,先比较3<2,返回false,然后false和1比较,会转换为数据类型,false转化为-1,-1<1所以返回true

27.

var a = 111111111111111110000,
    b = 1111;
a + b;
//

111111111111111110000;

　　js中数值的取值范围为-2^53-2^53,a的范围已经超过了2^53,超过最大值,和其他数做加减法,都为这个最大值

28

var val = 'c';
var str = 'Value is' + (val === 'c') ? 'a':'b';
console.log(str);       // a;

　　这道题考得是运算的先后顺序,先运算 val === "c",返回true,然后 + 的运算符大于其他运算符,,即最后的结果Value is true? 'a' : 'b';,布尔值为true,所以返回a

29.

var a = /123/, b = /123/;
console.log(a == b);        //false
console.log(a === b);　　　　//false

　 /123/是一个正则表达式,所以比较的是两个的引用地址,a和b显然不同,所以返回false

第二个 === 全等比较,与第一个相似,所以说地址不同返回仍为false

30

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

　　lowerCase.text(null)的内容为null,null转为字符串"null",以n开头,符合正则表达式,所以为true

lowerCase.text()的内容为undefined,转为字符串"undefined",以u开头,符合正则表达式,所以为true

31

[typeof null, null instanceof Object]
//logs [object , false ]

　　typeof会返回简单的数据类型,null会返回object

instanceof是基于原型链的比较,null并不是object原型上创建出来的,null._propto_最终指向null,所以会返回false

32

var ary = [0,1,2];
ary[10] = 10;
ary.filter(function(x) { 
    return x === undefined;
});
//logs []

　　filter的意思是过滤掉通过函数的元素,然后返回未通过的数据,这道题,ary = [0,1,3];然后添加了ary[10] = 10;添加后的数组变为了ary = [0,1,2,empty*7,10],过滤条件为x=undefined,所以会把数组全部过滤掉,剩下的只有空数组,所以结果为[];

33

var ary = Array(3);
ary[0] = 2;
ary.map(function(elem) { 
    return '1';
});
// logs [1, , ]

　　这题考的是map,创建一数组,ary= [ , , ];然后给ary[0] = 2,数组变为ary= [2 , , ],map循环时,只会循环有索引且赋值的数据,而且会按原来的顺序依次进行,当循环完ary[0]后不会继续循环,所以返回的数据为ary =[1,empty*2]

34

function effect(ary) {
    ary[0] = ary[2];
}
function run(a,b,c) {
    c = 10;
    effect(arguments);
    return a + b + c;
}
run(1,1,1);
//logs [21]

　　在非严格模式下,arguments的值会跟踪参数的值,无论修改arguments[i]本身还是修改的响应的参数本身,两个值都会同步,所以当调用run时,数组为ary= [1,1,10];当执行到effect时,把ary[2]的值赋值给ary[0],

即数组变为ary = [10,1,10]相加为10+10+1=21;但是在严格模式下arguments参数的值不会跟踪参数的值,ary = [1,1,10].最后的结果为1+1+10=12

35

var min = Math.min();
var max = Math.max();
min < max
// logs false

　　Math.min()如果传入数组就会返回数组中的最小值;

　　Math.max()如果传入数组就会返回数组的最大值;

但是如果比较非数字时会自动转化toString或value of方法为字符串后比较,如果不传数组的话,Math.min()会出现infinite(无穷大),Math,max()会出现(-infinite)即无穷小,所以Math.min()>Math.max();

36

function foo(a) {
    var a;
    return a;
}
function bar(a) {
    var a = 'bye';
    return a;
}
[foo('hello'), bar('hello')]
// logs  [hellow, bye ]

　　函数提升,会转化成如下效果

function foo (a)  {
          return a;
}
function bar(a) {
           a  =  'bye';
           return  a;
}
[foo('hellow'),bar('hellow')]

　 var申明提升,所以var a = undefined;参数会赋值给a,bar()时,修改了a的值所以为'bye',所以最后返回 ['hellow','bye']

37

function f() {}
var a = f.prototype;
var b = Object.getPrototypeOf(f);
a === b
// logs  false

　　函数的原型与它的prototype无关,所以互不相等