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