1. 函数声明和函数表达式有什么区别
函数声明和函数表达式都是声明函数的方式
- 区别1 写法：
函数声明 ： function 函数名(){}
函数表达式： var 变量名 = function(){} - 区别2 声明、调用顺序：
函数声明: 没有前后区别 ，声明不必放在调用前面
函数表达式： 声明必须放在调用前面 - 区别３ 声明前置
函数声明：var 声明的变量和function声明的函数会提前
函数表达式： 不需要声明提前，函数表达式和 var 变量 没有什么区别，先有再用。
函数表达式必须在表达式执行完后，函数才存在并可以被调用。
2. 什么是变量的声明前置？什么是函数的声明前置
声明前置 就是在一个作用域中，前置到当前作用域的头部
- 变量的声明前置： 在一个作用域中，所有的变量的声明放在当前作用域的头部位置
- 函数的声明前置： 在一个作用域中，函数的声明会被放在当前作用域的头部位置处先执行。而函数内部的声明前置则指的是在执行该函数里面的语句的时候，声明会被首先执行。
3. arguments 是什么
在函数的内部使用arguments对象，获取到函数的所有传入参数
可以通过arguments[ 数组下标]求属性值 ，数组长度 arguments.length
4. 函数的"重载"怎样实现
c和c++ 语言中的函数的重载，可有相同重复的函数名，函数名为不同数据类型，不被覆盖。
调用时不同参数会自动匹配对应函数，如参数都为整数，传对应的整型函数中
- js中没有重载，多个相同函数名的函数会被覆盖
但可以模仿重载的功能 - 在一个函数体内，针对不同的参数调用执行相应的逻辑
function fn(name,age,sex){//在fn函数体中， if语句为执行的不同的逻辑
if(name){
console.log(name);
}
if(age){
console.log(age);
}
if(sex){
console.log(sex);
}
}
fn('juan',34);//不同的参数
fn('yuekai',24,'女');
5. 立即执行函数表达式是什么？有什么作用
- 立即执行函数表达式: 定义的（匿名）函数立即执行
*普通定义的函数只能在调用时 才执行，而立即执行函数表达式可以让这个函数立即执行，不需要等待调用
- 生成一个独立的作用域，这个作用域里的变量函数外访问不到
6. 求n!，用递归来实现
递归的终止条件是n===1,但是也要考虑到 n===0的情况 ，万一n为0。因为1!====0!,所以这两种也特殊情况，1！又是终止条件
function fn(n){
if(n>=0){
if(n===0 || n===1){
return 1;
}
}
return n* fn(n-1);
}
fn(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, '男');
依次输出：
name: 饥人谷
age： 2
sex： 男
["饥人谷", 2, "男", callee: function, Symbol(Symbol.iterator): function]
name valley
没有return，函数默认返回 underfined
getInfo('小谷', 3);
name: 小谷
age: 3
sex: undefined
["小谷", 3, callee: function, Symbol(Symbol.iterator): function]
name valley
undefined（同上）
getInfo('男');
name: 男
age: undefined
sex: undefined
["男", callee: function, Symbol(Symbol.iterator): function]
name valley
undefined
8. 写一个函数，返回参数的平方和？
function sumOfSquares(a,b,c){
var sum=0;
for(var i=0 ; i<arguments.length; i++){
sum += arguments[i]*arguments[i];
}
console.log(sum);
}
var result = sumOfSquares(2,3,4);
var result2 = sumOfSquares(1,3);
console.log(result) //29
console.log(result2) //10
9. 如下代码的输出？为什么
>console.log(a); // underfined var a变量声明前置
var a = 1;
console.log(b); // b is not defined 没有这个b变量
10. 如下代码的输出？为什么
>sayName('world');
sayAge(10);
function sayName(name){ //声明函数 调用可以放前面
console.log('hello ', name);// hello world
}
var sayAge = function(age){// 调用必须在声明后面，先调用，但是还没来及声明，没办法获取这个函数执行
console.log(age);// sayAge is not a function
};
- 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x) // 输出10
}
function bar(){
var x = 30
foo()
}
输出10
- globalcontext = {
AO:{
x: 10;
foo: function(){}
bar: function(){} }
}
foo.[[scope]] = globalcontext.AO;
bar.[[scope]] = globalcontext.AO; - barcontext = {
AO:{
x: 30;
},
scope: globalcontext.AO;
} - foocontext = {
AO: {}
scope: globalcontext.AO;
}
- 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出 30
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;foorcontext= {
AO:{}
scope: foo.[[scope]]=barcontext.AO;
}
- 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
输出 30
1.globalcontext= {
AO:{
x: 10;
bar: fiunction(){}
}
scope:
}
bar.[[scope]] = globalcontext.AO;
2.barcontext = {
AO:{
x: 30;
function：function(){}
}
}
function.[[scope]] =globalcontext.AO;
- functioncontext= {
AO:{}
scope: function.[[scope]]=barcontext.AO;
}
- 以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a) // underfined
var a = 5
console.log(a) // 5
a++
var a
fn3()
fn2()
console.log(a)
function fn2(){
console.log(a) //6
a = 20 // a:20
}
}
function fn3(){
console.log(a) //1
a = 200 //a:200
}
fn()
console.log(a)
- globalcontext= {
AO:{
a: 1;
fn: function(){};
fn3: function(){};
}
}
fn.[[scope]]=globalcontext.AO;
fn3.[[scope]]= globalcontext.AO;
fncontext= {
AO:{
a: underfined;// 5 6
fn2: function(){};
}
scope: globalcontext.AO;
}
fn2.[[scope]]= fncontext.AO;fn3comtext= {
AO:{}
scope: globalcontext.AO;
}fn2context={
AO:{}
scope: fncontext.AO;
}
输出
underfined
5
6
1
20
200
