进阶任务3
2017-06-10 本文已影响0人
cheneyzhangch
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为全局变量
