js易错小题整理

var a = (function f() {
    function f() {
        return 1;
    }
    return f();
    function f() {
        return 2;
    }
})();
console.log(a);    //2

函数声明提升，同一作用域下用函数声明创建的同名函数，后面的会覆盖前面的，所以输出为：2

var f = function g() {
    return 23;
};
console.log(typeof g())； //报错
console.log(typeof g)；   //undefined

创建一个函数有三种方式：(1)函数声明 (2)函数表达式 (3)new Function()

函数声明：例如 function a () {return b;}; 存在着函数声明提升的现象（即解析时优先处理）。
函数表达式：例如 var a = function () {returnb;}; 因为右边部分已经成为一个表达式的一部分，所以无法再被正常访问。
所以typeof g输出为undefined,而typeof g()会报错。

var a = (function (x) {
    console.log(delete x);   //false
    return x;
})(1);
console.log(a);   //1
console.log(delete aaaa);   //true

delete用来删除对象的属性，删除成功或删除的属性不存在都返回true;
当删除的是函数或用var声明的变量或压根不是对象的属性时返回false.

所以上面把 1 传给了匿名函数，而delete x并没卵用，返回false；而a函数最终返回的还是1，因而console.log(a); //1，由于全局window对象里并没有aaaa这个变量，所以console.log(delete aaaa); //true

var a = (function f(f) {
    return typeof f();
})(function () {
    return 1;
});
console.log(a);   //“number”

执行匿名函数function f(f) {return typeof f();} ，其中其参数f为 function () { return 1;} ，因而f()得 1, 所以typeof f()得number

var a = (function f(f) {
    typeof f();    
})(function () {
    return 1;
});
console.log(a);   //undefined

当函数没有写return语句，或只写了return；函数默认返回undefined

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

首先将 foo.bar（即function () {return this.baz;}）传给匿名函数，此时arguments[0]即foo.bar，而在普通函数中运行foo.bar()，this会指向为window对象，而全局对象中并未声明baz，所以foo.bar()（即arguments[0] ()）输出undefined，所以匿名函数的return值也为undefined

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

console.log(typeof f);   //"number"
console.log(a);          //4

此处是一个立即执行函数，但是在前面的包含函数的圆括号（命名空间）中出现了2个函数，并用逗号分隔。这种形式，最终圆括号返回的是最后的一个值，变量也是一样。

var x = 1;
if (function f() {}) {
    x += typeof f;
}
console.log(x); //1undefined

首先在if判定中，函数f的布尔值是true；所以判定条件成立，可以执行if中的语句；但这里由于 f函数只是if的判定条件，只会当作表达式处理，因而f函数并没有经过声明；所以typeof f返回"undefined"。
最后结果为：1undefined

var x = 1;
if (f = function f() {}) {
    x += typeof f;
}
console.log(x); //1function

道理同上，但这回if里的函数虽然还是表达式，但它赋给了变量f，所以此时typeof f值为function
最后结果为：1function

var a = (function (foo) {
    return typeof foo.bar;
})({
    foo: {
        bar: 1
    }
});
console.log(a); //"undefined"

没啥说头儿，理清思路，就是undefined了

function old(num){
	return num%2 === 1;
}
function old2(num){
	return num%2 === 0;
}
function issame(num){
	return old(num) || old2(num);
}
var val = [7,4,'13',-9,Infinity]; 
console.log(val.map(issame)); //[true, true, true, false, false]

console.log(-9%2)  //-1
console.log(Infinity%2)  //NaN

没啥说的，不解释了

var a = 5;
(function(){
	var a = b =3;
})();
console.log(a,b)  //5 3

var a = b =3;相当于执行了这两句话 b = 3;var a = b，所以执行后全局变量b为3，而由于此a和全局a不在同一作用域，所以全局a仍未5
输出：5 3

//首先没有返回值，没有问题
function a(){}
console.log(new a());    //a {}
console.log(new a() instanceof a); //true

//这是返回非引用类型，也是true
function a(){return true}
console.log(new a()) //a {}
console.log(new a() instanceof a) //true

//这是返回引用类型，这个就是false了，因为new出来的东西被返回值覆盖
function a(){return {a:1}}
console.log(new a()) //Object {a: 1}
console.log(new a() instanceof a) //false


//类似的，这种也是引用的类型
function f() {return f;}
console.log(new f()) //function f(){return f} 
    //new出来的东西被返回值强行指向原本的函数本身，而不是其实例化对象，当然原型也无从谈起
console.log(new f() instanceof f); //false


//这里的this指向了new f()的实例对象，所以最后返回true
function f() { return this;}
console.log(new f() instanceof f); //true

这题很经典~ 务必搞会

function Foo() {
    getName = function () { alert (1); };
    return this;
}
Foo.getName = function () { alert (2);};
Foo.prototype.getName = function () { alert (3);};
var getName = function () { alert (4);};
function getName() { alert (5);}


Foo.getName();//2
getName();//4
Foo().getName();//1
getName();//1
new Foo.getName();//2
new Foo().getName();//3
new new Foo().getName();//3

参考：http://www.cnblogs.com/xxcanghai/p/5189353.html

猜你喜欢