函数声明和函数表达式有什么区别
函数声明:
function name(params) {
console.log("say hello~");
}
函数表达式:
var sayHello = function(params) {
console.log("say hello~");
}
JavaScript 解释器中存在一种变量声明被提升的机制，也就是说函数声明会被提升到作用域的最前面，即使写代码的时候是写在最后面，也还是会被提升至最前面。
而用函数表达式创建的函数是在运行时进行赋值，且要等到表达式赋值完成后才能调用
什么是变量的声明前置？什么是函数的声明前置
变量的前置声明:JavaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，然后给他初始值undefined，然后才逐句执行程序，这就叫做“变量提升”，也即“变量的声明前置”。
函数的声明前置JavaScript引擎将函数名视同变量名，所以采用function声明函数时，整个函数会像var声明变量一样，被提升到代码头部
arguments 是什么
arguments是一个类数组对象, 代表传给一个function的参数列表, 只在函数内部起作用; arguments的值与函数传入参数有关, 与定义参数无关。
可以使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数的条目，第一个条目的索引从0开始。例如，如果一个函数传递了三个参数，你可以以如下方式引用他们：
arguments[0]
arguments[1]
arguments[2]
参数也可以被设置：
arguments[1] = 'new value';
arguments对象不是一个 Array 。它类似于Array，但除了长度之外没有任何Array属性
arguments.callee指向当前执行的函数。
arguments.caller指向调用当前函数的函数。
arguments.length指向传递给当前函数的参数数量。
arguments[@@iterator]返回一个新的Array迭代器对象，该对象包含参数中每个索引的值。
函数的"重载"怎样实现
根据函数内建变量arguments的length属性来实现:
function overLoading() {
// 根据arguments.length，对不同的值进行不同的操作
switch(arguments.length) {
case 0:
/*操作1的代码写在这里*/
break;
case 1:
/*操作2的代码写在这里*/
break;
case 2:
/*操作3的代码写在这里*/
//后面还有很多的case......
}
}
立即执行函数表达式是什么？有什么作用
在定义函数之后，立即调用该函数, 为了避免function出现在行首, 引起JS解析错误, 让JS引擎将其理解成一个表达式,这就叫做"立即执行的函数表达式
常见的实现如下:
(function name() {
do something;
})();
(function wahah() {
console.log('wahahah');
}());
var aa = function() {
console.log("wahha");
}();
主要用于隔绝作用域。因为其创建了一个新的函数作用域，从而不去污染全局命名空间。
求n!，用递归来实现
function n(x) {
if(x < 2){
return 1;
}else if(x < 0){
return
}
else {
return x * arguments.callee(x - 1);
}
}
以下代码输出什么？
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: 男
{ '0': '饥人谷', '1': 2, '2': '男' }
name valley
getInfo('小谷', 3);
name: 小谷
age: 3
sex: undefined
{ '0': '小谷', '1': 3 }
name valley
getInfo('男');
name: 男
age: undefined
sex: undefined
{ '0': '男' }
name valley
写一个函数实现返回参数的平方和
function sumOfSquares() {
var res = 0;
for (var i = 0; i < arguments.length; i++) {
res += arguments[i] * arguments[i];
}
return res;
}
var sum = sumOfSquares(1,2);
console.log(sum);
如下代码的输出？为什么
console.log(a); //undefined, 变量声明会前置，并赋值undefined
var a = 1;
console.log(b); //报错, b未声明
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
输出显示:
hello world
报错:sayAge is not a function
第二行报错是因为sayAge是函数表达式，而函数表达式要先声明后调用
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
输出: x = 10
作用域链查找伪代码:
globalContext = {
ActiveObject:{
x:10
foo:function
bar:fucntion
}
scope: null
}
声明foo: foo.[[scope]] = globalContext.ActiveObject
声明bar: bar.[[scope]] = globalContext.ActiveObject
barContext = {
ActiveObject:{
x:30
foo:function
}
scope: globalContext.ActiveObject
}
fooContext = {
ActiveObject: {
}
scope: globalContext.ActiveObject
}
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出: x = 30
作用域链查找:
globalContext = {
ActiveObject:{
x:10
bar:function
}
scope: null
}
barContext = {
ActiveObject:{
x:30
foo:function
}
scope:globalContext.ActiveObject
}
fooContext = {
ActiveObject:{
}
scope: barContext.ActiveObject
}
以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
输出: x = 30
作用域链查找:
globalContext = {
AO: {
x: 10
bar:function
}
scope: null
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
function
}
scope = globalContext.AO
}
function.[[scope]] = barContext.AO
functionContext = {
AO: {}
scope = barContext.AO
}
以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a)
var a = 5
console.log(a)
a++
var a
fn3()
fn2()
console.log(a)
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn()
console.log(a)
输出: undefind 5 1 6 20 200
作用域链查找:
globalContext = {
ActiveObject:{
a: 200
fn:function(){}
fn3:function(){}
}
scope: null
}
fn.[[scope]] = globalContext.ActiveObject
fn3.[[scope]] = globalContext.ActiveObject
fnContext = {
ActiveObject:{
a: 20
fn2: function(){}
}
scope: globalContext.ActiveObject
}
fn2.[[scope]] = fnContext.ActiveObject
fn3Context = {
ActiveObject：{}
scope: globalContext.ActiveObject
}
fn2Context = {
ActiveObject:{}
scope: fnContext.ActiveObject
}
