进阶3作业

1、函数声明和函数表达式有什么区别

函数声明: 使用function关键字可以声明一个函数

function sayHello() {
    console.log('hello');
}
sayHello()

声明不必放到调用前面。

var sayHello = function() {
    console.log('hello');
}
sayHello();

声明必须放到调用的前面。

2、什么是变量的声明前置？什么是函数的声明前置？

在一个作用域下，var声明的变量和funciton声明的函数会前置。
举列说明

console.log(a);            
var a = 3;           
console.log(a);             
sayHello();                 
function sayHello() {
    console.log('hello');
}

在JS实际执行的时候，是如下面这样。

var a;                              // 变量声明前置
function sayHello() {       // 函数声明前置
    console.log('hello');
}
console.log(a); 
a = 3;
console.log(a);
sayHello();
3、arguments 是什么?

在函数内部，你可以使用arguments对象获取到该函数的所有传入参数。
arguments 叫做类数组对象。 但是它表示数组，可以通过下标的方式获取到值，也有length属性。
举列说明

function printPersonInfo() {
    console.log(arguments[0]);
    console.log(arguments[1]);
    console.log(arguments[2]);
    console.log(arguments.length);
} 
printPersonInfo('Ty', 22, 'female');
4、函数的"重载"怎样实现?

在其他语言中的重载，就是可以多个同名函数，但是参数和返回值类型都不同，但是调用的时候我们可以根据，调用时传参的方式，自动匹配相对应的函数。
在JS中没有重载，同名函数会覆盖，但可以在函数体针对不同的参数调用执行相应的逻辑。
在JS中模拟重载。

function printPersonInfo(name, age, sex) {
    if(name) {
        console.log(name);
    }
    if (age) {
        console.log(age);
    }
    if(sex) {
        console.log(sex);
    }
} 
printPersonInfo('HR', 22);
printPersonInfo('Ty', 22, 'female');

重载就是根据传递的参数不同，做什么样的事情。

5、立即执行函数表达式是什么？有什么作用

是一个立即执行的匿名函数表达式，两对括号包裹着一个匿名函数，使匿名函数变成了一个函数表达式。
(function() { var a = 1;})(); 作用: 隔离作用域 举列

(function b() {
      var a = 2
} ) 
console.log(a)   // a is not defined
6、求n!，用递归来实现
function fctoril(n) {
    if(n == 1) { 
        return 1;
    }else {
        return n * fctoril(n-1);
    }   
}
7、以下代码输出什么？
function getInfo(name, age, sex){
        console.log('name:',name);
        console.log('age:', age);
        console.log('sex:', sex);
        console.log(arguments);
        arguments[0] = 'valley';
        console.log('name', name);
    }

    getInfo('饥人谷', 2, '男');
getInfo('小谷', 3);
getInfo('男');

name: 饥人谷
age: 2
sex: 男
["饥人谷", 2, "男"]
name valley
name: 小谷
age: 3
sex: undefined
["小谷",3]
name valley
name:男
age: undefined
sex: undefined
["男"]
name valley

8. 写一个函数，返回参数的平方和
 function sumOfSquares(){
   }
   var result = sumOfSquares(2,3,4)
   var result2 = sumOfSquares(1,3)
   console.log(result)  //29
   console.log(result2)  //10

function sumOfSquares(){
    var sum = 0;
    for(var i = 0; i < arguments.length; i++) {
        sum = sum + arguments[i] * arguments[i];
    }
    return sum;
}
9、如下代码的输出？为什么
console.log(a);
    var a = 1;
    console.log(b);

变量声明前置

var a;
console.log(a);
a = 1;
console.log(b);

输出结果：
undefined
Uncaught ReferenceError: b is not defined
a 先声明了，而b没有声明。

10、如下代码的输出？为什么
sayName('world');
    sayAge(10);
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };

Uncaught TypeError: sayAge is not a function
函数声明不需要放在调用调用的前面。
函数表达式需要放在调用的前面

11、如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar() 
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
  foo()
}

输出结果：10

// 对应的作用域链
globalContext = {
    AO: {
        x: 10,
        bar: function() {}
        foo: function() {}
    }
    Scope: null
}
bar.[[scope]] = globalContext.AO;
foo.[[scope]] = globalContext.AO;
barContext = {
    AO: {
        x: 30,
    }
    Scope: globalContext.AO;
}
fooContext = {
    AO: {},
    Scope: globalContext.AO;
}
12、如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}

输出结果：30

//  对应的作用域链
globalContext = {
    AO: {
        x: 10,
        bar: function() {}
    }
    Scope: null
}
bar.[[scope]] = globalContext.AO;
barContext = {
    AO: {
        x: 30,
        foo: function() {}
    }
    Scope: globalContext.AO;
}
foo.[[scope]] = barContext.AO;
fooContext = {
    AO: {},
    Scope: barContext.AO;
}
13、如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}

输出结果：30

// 作用域链
globalContext = {
    AO: {
        x: 10,
        bar: function() {};
    }
    Scope: null
}
bar.[[scope]] = globalContext.AO;

barContext = {
    AO: {
        x: 30,
         anonymity ：function() {}
    }
    Scope：globalContext.AO;
}
anonymity.[[scope]] = barContext.AO;
14、如下代码输出什么? 写出作用域链查找过程伪代码
var a = 1;

function fn(){
  console.log(a)         // (1)
  var a = 5
  console.log(a)         //  (2)
  a++
  var a
  fn3()                         // (3)
  fn2()                         // (4)
  console.log(a)          // (5)      

  function fn2(){
    console.log(a)
    a = 20
  }
}

function fn3(){
  console.log(a)
  a = 200
}

fn()
console.log(a)                    // (6)

在上面标注了输出时代码的序号。

// 执行到(1)时对应的作用域链
globalContext = {
    AO:{
        a:1,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: undefined,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

此时输出 undefined

// 执行到(2)时对应的作用链
globalContext = {
    AO:{
        a:1,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: 5,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

(2)此时结果：undefined 5

// 执行到(3)时对应的作用域链
globalContext = {
    AO:{
        a:1,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: 6,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

fn3Content = {
    AO:{}
    scope: fn3.[[scope]] = globalContext.AO;
}

（3）此时结果：undefined 5 1

// 执行到(4)对应......
globalContext = {
    AO:{
        a:200,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: 6,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

fn3Content = {
    AO:{}
    scope: fn3.[[scope]] = globalContext.AO;
}

fn2Content = {
    AO: {}
    scope: fn2.[[scope]] = fnContext.AO;
}

（4）此时结果为 undefined 5 1 6

// (5)对应的作用链
globalContext = {
    AO:{
        a:200,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: 20,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

fn3Content = {
    AO:{}
    scope: fn3.[[scope]] = globalContext.AO;
}

fn2Content = {
    AO: {}
    scope: fn2.[[scope]] = fnContext.AO;
}

（5）此时结果为undefined 5 1 6 20

//  (6)
globalContext = {
    AO:{
        a:200,
        fn: function() {},
        fn3: function() {},
    }
    Scope: null;
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;

fnContext = {
    AO: {
        a: 20,
        fn2: function() {}
    }
    scope: fn.[[scope]] = globalContext.AO;
}
fn2.[[scope]] = fnContext.AO;

fn3Content = {
    AO:{}
    scope: fn3.[[scope]] = globalContext.AO;
}

fn2Content = {
    AO: {}
    scope: fn2.[[scope]] = fnContext.AO;
}

（6）输出结果 : undefined 5 1 6 20 200

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • JS函数与作用域(进阶3作业)
    1.函数声明和函数表达式有什么区别 函数声明 代码执行时函数声明会被提升到最前执行，所以函数的调用与函数声明的顺序...
    Feiyu_有猫病阅读 3,038评论 0赞 0
  • 第5章 引用类型
    第5章 引用类型(返回首页) 本章内容 使用对象 创建并操作数组 理解基本的JavaScript类型 使用基本类型...
    大学一百阅读 8,702评论 0赞 4
  • 《C++ Primer》读书笔记
    前言 把《C++ Primer》[https://book.douban.com/subject/25708312...
    尤汐Yogy阅读 13,153评论 1赞 51
  • 童话
    那就起舞吧 白色的柔软的花 在指尖绽放
    苍轩客阅读 1,432评论 3赞 5
  • 等你
    最美不过黄昏的那个身影，清风拂过你的发梢，夕阳印在你的衣角，我在远处驻足，只为在一个不经意，触碰到你温柔的目光和年...
    魔高一丈阅读 1,670评论 0赞 4

友情链接更多精彩内容