-
函数声明和函数表达式有什么区别
函数声明：
使用function关键字可以声明一个函数
function sayHello() {
console.log('hello')
}
// 函数调用
sayHello()
- 声明不必放到调用的前面（可以放在全局作用域里面的任何位置）例如：
sayHello() //hello jirengu
sayHello() //hello jirengu
//调用了两次
var a = 1;
function sayHello() {
console.log('hello')
console.log('jirengu')
}
函数表达式
//把命名函数function()赋值给了变量sayHello
var sayHello = function() {
console.log('hello');
} // 这就是函数表达式，相当于把functions(){console.log('hello');} 这个值赋值给sayName。
sayHello()
声明必须要放到调用的前面
-
什么是声明前置
变量声明前置——指的是解析器将当前作用域内声明的所有变量放到作用域的开始处，但是，只有变量的声明被前置了，而赋值操作被保留在原处，
console.log(name); // undefined;
var name="wmsj100";
console.log(name); // "wmsj100";
因为变量的声明被前置了，但是赋值操作被保留在原处，所以这段代码和下面的效果是一样的：
var name;
console.log(name); //已经被声明但未赋值的变量会被自动赋值undefinde;
name = "wmsj100"; // 进行赋值操作
console.log(name); //"wmsj100"
- 函数声明前置——JavaScript解释器允许在函数声明之前使用函数，此时不仅仅是函数名被前置了，整个函数定义也被前置了，所以就可以直接调用函数：
sayHi(); //"hello world"
function sayHi(){
console.log("hello world");
}
和下面这段代码是等效的：
function sayHi(){
console.log("hello world");
}
sayHi(); //因为函数sayHi已经声明，所以此时直接输出"hello world"
-
求n!，用递归来实现
function factor(n) {
if(n === 1) {
return 1
}
return n* factor(n-1)
}
-
什么是立即执行的函数表达式？有什么作用？
立即执行函数描述：
- 立即执行函数是一种语法，可以让函数在定义后立即被执行，
(function(){
console.log(1);
}()); // 1
- 这种模式本质上就是函数表达式（命名的或者匿名的），在创建后立即执行；
- 立即执行函数术语不是在ECMAScript标准中定义的，但它很短有助于描述和讨论模式，这种模式由以下几部分组成：
- 使用函数表达式定义一个函数（函数声明不能起作用）；
- 在结尾加上一对括号，让函数立即执行；
- 将整个函数包裹在一对括号中（只有在不将函数赋值给变量的时候才需要）；
- 立即执行函数可以包含参数；
(function(name,age){
console.log("姓名："+name+" ; "+"年龄："+age+"!");
}("wmsj100",28));
// 姓名：wmsj100 ; 年龄：28!
- 像其它任何函数一样，立即执行函数也可以返回值并且把值赋给其它变量；
var infor=function(){
return "wmsj100";
}(); //把函数的返回值"wmsj100"赋值给infor；
console.log(infor); //"wmsj100";
立即执行函数作用；
- 立即执行函数模式被广泛使用，它可以封装大量的工作而不会在背后遗留任何全局变量；定义的所有变量都会成为立即执行函数的局部变量，所以不必担心这些临时变量会污染全局空间；
- 这种模式也可以将独立的功能封装在自包含模块中。假如页面是稳定的并且在没有JS情况下能正常工作，然后本着逐步加强的想法，你加入了一些代码加强页面某个方面；你可以将这些代码封装进一个立即执行函数中，并且确保页面在没有它们的时候也可以正常工作。
参考文献——立即执行函数
-
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo() // 输出什么
}
输出结果为10.
作用域链查找过程伪代码:
globalContext = {
AO : {
x = 10
foo : function
bar : function
}
scope: null
}
// 当调用bar()时进入bar的执行上下文
barContext = {
AO : {
x : 30
}
scope : bar.[[scope]] //globalContext.AO
}
// 找到var x = 30 之后，它调用foo(),这时进入foo()的执行上下文
fooContext = {
AO : {}
scope : foo.[[scope]] //globalContext.AO
}
// 因为fooContext中的AO为空，这时我们就去scope里面找，在globalContext中的AO里我们得到x : 10;
所以最终输出结果为10.
-
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar() // 输出什么
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
// 输出结果为10
// 作用域链查找过程伪代码
globalContext = {
AO: {
x: 10
bar : function
}
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
foo: function
}
scope: bar.[[scope]] = globalContext.AO
}
foo.[[scope]] = barContext.AO
fooContext = {
AO: {}
scope: foo.[[scope]] = barContext.AO
}
// 所以console.log(x) 输出结果为30.
-
一下代码输出什么? 写错作用域链的查找过程伪代码
var x = 10;
bar() // 输出什么
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
-
以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a); // undefined
var a = 5;
console.log(a); //5
a++;
var a;
fn3(); //1
fn2(); //6
console.log(a);//20
function fn2(){
console.log(a);
a = 20;
}
}
function fn3(){
console.log(a)
a = 200;
}
fn();
console.log(a); 200
执行：
1.
globalContext = {
AO: {
a: 200,//变化顺序是undefined, 1，200
fn: function(){},
fn3: function(){}
}
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;
2.
fnContext = {
AO: {
a: 20,//变化顺序是undefined,5,6,20
fn2: function(){},
},
scope: fn.[[scope]]
}
fn2.[[scope]] = fnContext.AO;
3.
fn3Context = {
AO: {},
scope: fn3.[[scope]]
}
4.
fn2Context = {
AO: {},
scope: fn2.[[scope]]
}
控制台输出结果顺序为：undefined 5 1 6 20 200
邮件待看：
// 函数声明和函数表达式有什么区别
function a() {
} // 函数表达式(函数声明是和var类似会被前置的哦)
var aa = function () {
}; // 函数声明(不会被前置)
// 3. 求n!，用递归来实现
function factorial(n) {
if (n === 1) {
return 1;
} else if (n > 1) {
return n * factorial(n - 1)
} else {
return 'No result.';
}
}
/*
* 什么是立即执行的函数表达式？有什么作用？
* 匿名，立刻执行自己
*/
var x = 10;
bar() ;// 输出30
function bar(){
var x = 30;
(function (){
console.log(x); // 当前作用域没有，查找上一级作用域，找到x = 30;
})()
}
var a = 1;
function fn() {
console.log(a); // undefined,下面声明的a前置上去
var a = 5;
console.log(a); //5 正常获得当前作用域的5
a++; // 当前作用域的a变成2了
var a; // 无视这个，顶最顶上面去了
fn3(); //1
fn2(); //6
console.log(a);//20
function fn2() {
console.log(a); // 上一级是fn函数，所以是6
a = 20;
}
}
function fn3() {
console.log(a); // 上一级是全局作用域，拿全局作用域的a
a = 200; // 不会被前置，拿不到,但是不写 var意味着等同于 window.a = 200;
}
fn();
console.log(a); // 200
文章著作权归饥人谷_sunny和饥人谷所有，转载须说明来源
