函数声明和函数表达式有什么区别##
函数声明：function functionName(){}
函数表达式：var fn = function(){}
区别：
1.函数声明会在代码开始前定义，函数表达式遇到时才会执行。
2.函数声明必须有函数名，函数表达式则可以省略。
什么是变量的声明前置？什么是函数的声明前置##
变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明。JavaScript引擎将函数名视同变量名，所以采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部，只要函数在代码中进行了声明，无论它在哪个位置上进行声明，js引擎都会将它的声明放在范围作用域的顶部。
arguments 是什么##
arguments 是一个类数组对象。代表传给一个function的参数列表。在函数内部，你可以使用arguments对象获取到该函数的的所有传入参数
函数的"重载"怎样实现##
function printInfo(name,age,sex) {
if(name) {
console.log(name);
}
if(age) {
console.log(age);
}
if(sex) {
console.log(sex);
}
}
//printInfo(27 ,'male') 输出 27 male
立即执行函数表达式是什么？有什么作用##
当JS执行到该行代码时，函数会被定义且立即执行，叫做立即执行函数表达式。
使用立即执行函数表达式可以创建一个独立的作用域，形成隔离，避免污染全局
求n!，用递归来实现##
function factor(n) {
if (n>0) {
if (n===1) {
return 1;
}
return n * factor(n-1);
} else if (n===0) {
return 0;
} else {
if (n<0) {
return 'ERROR'
}
}
}
以下代码输出什么？##
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，'男']
//name valley
getInfo('小谷', 3);
// name:小谷 age:3 sex:undefined
// ['小谷'，3]
// name valley
getInfo('男');
// name:男 age:undefined sex:undefined
// ['男']
//name valley
写一个函数，返回参数的平方和？##
function sumOfSquares(){
var sum=0;
for (var i=0;i<arguments.length;i++) {
sum += (arguments[i]*arguments[i])
}
return sum;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
如下代码的输出？为什么?##
console.log(a);// 变量声明前置，a未赋值，undefined
var a = 1;
console.log(b); //b未定义变量，报错
如下代码的输出？为什么?##
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name); // hello world 因为函数声明中变量和函数声明提前不影响调用；
}
var sayAge = function(age){
console.log(age); //报错 函数表达式需要放在调用之前；
};
11、如下代码输出什么? 写出作用域链查找过程伪代码##
var x = 10
bar() //输出10
function foo() {
console.log(x) //输出10
}
function bar(){
var x = 30
foo()
}
查找过程
globalContext = {
AO: {
x:undefined -->10,
foo:function,
bar:function
}
scope:null
}
barContext = {
AO: {
x:undefined-->30，
}
scope: globalContext.AO
}
fooContext ={
AO: { }
scope: globalContext.AO
}
12、如下代码输出什么? 写出作用域链查找过程伪代码##
var x = 10;
bar() //输出30
function bar(){
var x = 30;
function foo(){
console.log(x) //输出30
}
foo();
}
12查找过程
globalContext= {
AO: {
x: undefined-->10,
bar:function
}
scope:null
}
barContext = {
AO: {
x:undefined-->30,
foo:function
}
scope: globalContext.AO
fooContext = {
AO :{}
scope: barContext.AO
}
13、如下代码输出什么? 写出作用域链查找过程伪代码##
var x = 10;
bar() //输出30
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
查找过程
globalContext= {
AO: {
x:10,
bar:function
}
scope:unll
}
barContext = {
AO:{
x: undefined-->30,
匿名函数:function
}
scope: globalContext.AO
}
匿名函数context = {
AO :{}
scope: barcontext.AO
14、如下代码输出什么? 写出作用域链查找过程伪代码##
var a = 1;
function fn(){
console.log(a) //输出undefined
var a = 5
console.log(a) //输出5
a++ //6
var a //6
fn3() //输出1
fn2() //输出6
console.log(a) //20
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn() //undefined 5 1 6 20
console.log(a) //200
查找过程
globalContext= {
AO: {
a: undefined-->1-->200,
fn:function,
fn3:function
}
scope:null
}
fnContext = {
AO:{
a:underfined-->5-->6-->20,
fn2:function
}
scope: globalContext.AO
}
fn3Context = {
AO:{}
scope :globalContext.AO
}
fn2Context = {
AO: {}
scope: fnContext.AO
}
