这很面试题

JS中typeof与instanceof的区别

JavaScript 中 typeof 和 instanceof 常用来判断一个变量是否为空，或者是什么类型的。但它们之间还是有区别的：

typeof：typeof 是一个一元运算，放在一个运算数之前，运算数可以是任意类型。
它返回值是一个字符串，该字符串说明运算数的类型。typeof 一般只能返回如下几个结果：
number,boolean,string,function,object,undefined。我们可以使用 typeof 来获取一个变量是否存在，如 if(typeof a!=”undefined”){alert(“ok”)}，而不要去使用 if(a) 因为如果 a 不存在（未声明）则会出错，对于 Array,Null 等特殊对象使用 typeof 一律返回 object，这正是 typeof 的局限性。

instanceof的语法结构：a instanceof b ，其中a是要判断的变量，b是数据的基本类型；

a instanceof b?alert(“true”):alert(“false”); //a是b的实例？真:假
instanceof 用于判断一个变量是否某个对象的实例，如 var a=new Array();alert(a instanceof Array); 会返回 true，同时 alert(a instanceof Object) 也会返回 true;这是因为 Array 是 object 的子类。再如：function test(){};var a=new test();alert(a instanceof test) 会返回true;

谈到 instanceof 我们要多插入一个问题，就是 function 的 arguments，我们大家也许都认为 arguments 是一个 Array，但如果使用 instaceof 去测试会发现 arguments 不是一个 Array 对象，尽管看起来很像。

测试 var a=new Array();if (a instanceof Object) alert(‘Y’);else alert(‘N’);得’Y’

但 if (window instanceof Object) alert(‘Y’);else alert(‘N’);得’N’

所以，这里的 instanceof 测试的 object 是指 js 语法中的 object，不是指 dom 模型对象。

使用 typeof 会有些区别 alert(typeof(window)) 会得 object。

面试题：

(function () {  //arruments是对象
return typeof arguments;  
})();  
A. "object"
B. "array"
C. "arguments"
D. "undefined"
答案：A

var f = function g() {    //没有这种写法
    return 23;
};
typeof g();
A. "number"
B. "undefined"
C. "function"
D. Eorror
答案：D

(function (x) {
delete x;    //delete可以删除对象的属性,删除不了变量,函数 
return x;
})(1);
A. 1
B. null
C. undefined
D. Error
答案：A

var y = 1,
x = y = typeof x;    
x;    //要把浏览器页面关闭再打开，要不会出现干扰

typeof打印出来的console不带""，实际上typeof的输出值是字符串形象，如"number","undefined"
A. 1
B. "number"
C. undefined
D. "undefined" 
答案： D

(function f(f) {
return typeof f();
})(function () {
return 1;
});

理解：
(function f(f){
console.log(typeof f()) //这里的f()实际上就是调用了下面的匿名函数
})(function(){return 1});//这里的function作为整体看就是(f)里地f，当参数传入

A. "number"
B. "undefined"
C. "function"    
D. Error
答案：A

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

理解：
var foo = {
bar: function () {
     return this.baz;
    console.log(this.baz) ;    //此时返回的时undefined
},
baz: 1
};

console.log(foo.bar())//foo.barfunction函数加()可以读取到1
console.log((foo.bar)());和上面等同
console.log(foo.baz)    //在外部才可以读取1

(function () {
return typeof arguments[0]();
})(foo.bar) 

A. "undefined"
B. "object"
C. "number"
D. "function"
答案：A

var foo = {
bar: function () {
    return this.baz;
},
baz: 1
};
typeof (f=foo.bar)();

理解：
var foo = {
bar: function () {
    return this.baz;
},
baz: 1
};

f=foo.bar();
console.log(f)//得到1
f=foo.bar;
console.log(f())//undefined

console.log(typeof (f=foo.bar)() )//输出结果undefined
console.log(typeof(f=foo.bar()))//输出结果是number

A. "undefined"
B. "object"
C. "number"
D. "function"
答案：A

var f = (function f() {
return "1";
}, function g() {
return 2;
})();

理解：    //后面的把前面的覆盖掉了
var f = 
console.log(typeof (function f() {
return "1";
})())    
console.log(typeof (function g() {
return 2;
})())
typeof f;
A. "string"
B. "number"
C. "function"
D. "undefined"
答案： B

var x = 1;
if (function f() {}) {
x += typeof f;
}
x;
A. 1
B. "1function"    
C. "1undefined"    //if中的参数只作为判断条件；
D. NaN
答案： C

var x = [typeof x, typeof y][1];
typeof typeof x;
A. "number"
B. "string"    //typeof x是字符串所以就是字符串
C. "undefined"
D. "object"
答案： B

(function (foo) {
return typeof foo.bar;
})({
foo: {
    bar: 1
}
});

理解：
(function (f) {
return typeof f.foo.bar;
})(f={foo: { bar: 1}});

A、“undefined” 
B、“object” 
C、“number” 
D、Error
答案： A

(function f() {
function f() {
    return 1;
}
return f();
function f() {    //第一公民优先解析漂到js最上面
    return 2;
}
})();
A、1 
B、2 
C、Error (e.g. “Too much recursion”) 
D、undefined
答案：B

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

console.log(new f() instanceof f)//false  return f 是一个死循环
如果return f 变成return 'f'或者1等等,就是true; //此时f是一个函数，new f() 就是衍生出来的它的子类，就是true;
A、true 
B、false
答案：B