美文网首页
进阶任务3

进阶任务3

作者: cheneyzhangch | 来源:发表于2017-06-10 22:48 被阅读0次

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

  • 函数声明:声明不必放到调用的前面;
  • 函数表达式:声明必须放到调用的前面,因为利用函数表达式来定义函数,本质上是将函数表达式的值赋值给变量,而在变量调用之前,必需先对变量进行赋值,否则会返回undefined;

2. 什么是变量的声明前置?什么是函数的声明前置

JavaScript引擎的工作方式是,先解析代码,获取所有被声明的变量,然后再一行一行地运行。这造成的结果,就是所有的变量的声明语句,都会被提升到相关作用域的前部,这就叫做变量提升(hoisting)
JavaScript引擎将函数名视同变量名,所以采用function命令声明函数时,整个函数会像变量声明一样,被提升到相关作用域的前部。

3. arguments 是什么

arguments为类数组对象,
在函数内部,你可以使用arguments对象获取到该函数的所有传入参数,
arguments[0]就是第一个参数,arguments[1]就是第二个参数,以此类推。这个对象只有在函数体内部,才可以使用

4. 函数的"重载"怎样实现

JS为弱类型语言,因为变量或函数重复定义,后定义的会覆盖先定义的,因此JS中没有重载。 但可以在函数体针对不同的参数调用执行相应的逻辑,例如

    function printPeopleInfo(name, age, sex) {
        if (name) {
            console.log(name);
        }

        if (age) {
            console.log(age);
        }

        if (sex) {
            console.log(sex);
        }
    }
    printPeopleInfo('Byron', 26);
    printPeopleInfo('Byron', 26, 'male');

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

JavaScript引擎规定,如果function关键字出现在行首,一律解释成语句,
因此,JavaScript引擎看到行首是function关键字之后,认为这一段都是函数的定义,而函数只有在调用的时候才会执行;
如果想要函数立即执行,解决方法就是不要让function出现在行首,最简单的做法就是将function语句用()包裹在内,JavaScript引擎会将其解读为表达式并立即执行,就成为立即执行函数表达式;
不同的立即执行表达式之间应用;隔开,
作用:

  • 避免污染全局变量;
  • 可以形成单独作用域,封装一些外部无法读取的局部变量;

6. 求n!,用递归来实现

    function factor(n) {
        if (n < 0) {
            return '输入值为负值,负值没有阶乘'
        } else if (n === 0) {
            return 1
        } else if (n === 1) {
            return 1
        }
        return n*factor(n - 1)
    }
    factor(5)

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('男');

getInfo('饥人谷', 2, '男');输出结果

name: 饥人谷
age: 2
sex: 男
饥人谷 2 男
name valley

getInfo('小谷', 3);输出结果

name: 小谷
age: 3
sex: undefined
小谷 3
name valley

getInfo('男');;输出结果

name: 男
age: undefined
sex: undefined
男
name valley

8. 写一个函数,返回参数的平方和?

    function sumOfSquare() {
        var result = 0;
        for (var i = 0; i < arguments.length; i++) {
            result = result+arguments[i]*arguments[i];
        }
        return result;
    }
   var result = sumOfSquares(2,3,4)
   var result2 = sumOfSquares(1,3)
   console.log(result)  //29
   console.log(result2)  //10

9. 如下代码的输出?为什么

console.log(a); // var a 变量提升, a为undefined
var a = 1;      // 变量赋值 a=1
console.log(b); // 报错,b未经声明

10. 如下代码的输出?为什么

    sayName('world');
    sayAge(10);
    function sayName(name) {
        console.log('hello ', name);
    }
    var sayAge = function (age) {
        console.log(age);
    };
1. 执行函数sayName('world'),输出 hello world
2. 执行sayAge(10); 报错,由于函数表达式对变量sayAge声明前置且为非函数,此时再执行调用函数即报错

11. 如下代码输出什么? 写出作用域链查找过程伪代码

    var x = 10
    bar()
    function foo() {
        console.log(x)
    }
    function bar() {
        var x = 30
        foo()
    }

/* 
1. 
globleContext= {
    AO: {
        x: 10
        bar: function
    }
    bar.[[scope]] = globleContext.AO
    foo.[[scope]] = globleContext.AO
}
2. 
barContext= {
    AO: {
      x: 30
      foo: function
    }
    Scope: bar.[[scope]] = globleContext.AO
}
3.
fooContext= {
    AO: {}
    foo.[[scope]] = globleContext.AO
}
输出 10

*/

12. 如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}

/*
1. 
globleContext={
    AO: {
        x:10
        bar: function
    }
    bar.[[scope]]=globleContext.AO
}
2.
barContext={
    AO: {
        x: 30
        foo: function
    }
    scope: bar.[[scope]]=globleContext.AO
    foo[[scope]]=barContext.AO
}
3.
fooContext={
    AO: {}
    scope: foo[[scope]]=barContext.AO
}
输出 30

13. 以下代码输出什么? 写出作用域链的查找过程伪代码

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}
/*
1.
globleContext={
    AO: {
        x: 10 
        bar: function
    }
    bar.[[scope]]=globleContext.AO
}
2.
barContext= {
    AO: {
        x:30
        未命名函数: function
    }
    scope: bar.[[scope]]=globleContext.AO
    未命名函数.[[scope]]=barContext.AO
}
未命名函数Context= {
    AO:{}
    scope: 未命名函数.[[scope]]=barContext.AO
}
输出 30
*/

14. 以下代码输出什么? 写出作用域链查找过程伪代码

var a = 1;
function fn(){
  console.log(a) // output: undefined
  var a = 5     // a = 5    
  console.log(a) // output: 5
  a++           //  a=6      
  var a
  fn3()         
  fn2()
  console.log(a)    // 20

  function fn2(){
    console.log(a)
    a = 20
  }
}
function fn3(){
  console.log(a)
  a = 200
}
fn()
console.log(a)
/*
1.
globleContext= {
    AO: {
        a: 200
        fn: function
        fn3: function
    }
    fn.[[scope]]=globleContext.AO
    fn3.[[scope]]=globleContext.AO
}
2. 
fnContext = {
    AO:{
        a:20
    }
    scope: fn.[[scope]]=globleContext.AO
    fn2.[[scope]]=fnContext.AO
}
3.
fn3Context= {
    AO: {
    }
    scope: fn3.[[scope]]=globleContext.AO
}
4. 
fn2Context= {
    AO: {
    }
    scope:fn2.[[scope]]=fnContext.AO
}
// 输出 undefined 5 1 6 20 200
*/

写在最后:
如果在函数作用域内直接 a = 1, 不写var,会声明一个全局变量,则此时a为全局变量

相关文章

  • 进阶任务-3

    函数声明和函数表达式有什么区别 函数声明可以在在代码中任意位置调用,但是函数表达式只能在表达式语句后面调用 什么是...

  • 进阶任务3

    1. 函数声明和函数表达式有什么区别 函数声明:声明不必放到调用的前面; 函数表达式:声明必须放到调用的前面,因为...

  • 进阶任务3

    1.函数声明和函数表达式有什么区别函数表达式的声明必须放在调用前面,函数声明的声明不需要放在调用前面。2.什么是变...

  • 进阶任务3

    1、函数声明和函数表达式有什么区别2、什么是变量的声明前置?什么是函数的声明前置3、arguments 是什么4、...

  • 进阶任务3

    函数声明和函数表达式有什么区别## 函数声明:function functionName(){}函数表达式:var...

  • 进阶-任务3

    函数声明和函数表达式有什么区别 函数声明 函数声明命名了一个叫做print的函数,以后使用print()就可以调用...

  • 任务:进阶3:JS函数

    前言 在程序设计语言里面有一种语句叫决策语句,可以使程序根据是否满足特定的条件,运行相对应代码。换言之,决策语句使...

  • 进阶任务3(主线任务):函数与作用域

    任务 函数声明和函数表达式有什么区别答:函数声明:function functionName(){}  函数表达式...

  • Swift多线程:GCD进阶,单例、信号量、任务组

    Swift多线程:GCD进阶,单例、信号量、任务组 Swift多线程:GCD进阶,单例、信号量、任务组

  • 进阶-任务2

    1、JavaScript 定义了几种数据类型? 哪些是原始类型?哪些是复杂类型?原始类型和复杂类型的区别是什么? ...

网友评论

      本文标题:进阶任务3

      本文链接:https://www.haomeiwen.com/subject/tqbcqxtx.html