函数声明和函数表达式有什么区别
- 函数声明会提升到当前作用于执行之前；而函数表达式提升的声明是变量的声明。
- 函数声明必须有标识符，也就是函数名；函数表达式的函数名可以省略。
- 函数的声明不一定要放到调用的前面；函数表达式的声明必须放到调用的前面。
//函数声明
function myName(name){
console.log(name)
}
//函数表达式
var= myName = function(){
console.log(name)
}
什么是变量的声明前置？什么是函数的声明前置
- 变量的声明前置：
提升变量的声明到当前作用于执行之前，此时变量的值为undefined； - 函数的声明前置：
提升函数的声明到当前作用于执行之前，所以在当前作用域的任何地方都可以调用函数；
arguments 是什么
arguments是一种类数组对象，可以通过arguments[0,1,2,]来获取传入参数。
函数的"重载"怎样实现
- 根据传入参数的类型执行不同的操作。
- 利用参数中特殊的参数值进行不同的操作。
- 根据参数的个数进行重载。
简言之：函数的“重载”就是根据参数的不同属性执行对应的逻辑。
例：
function fn() {
switch (arguments.length) {
case 0:
//执行语句块
break;
case 1:
//执行语句块
break;
case 2:
//执行语句块
break;
default:
break;
}
}
//根据参数的个数进行重载
立即执行函数表达式是什么？有什么作用
写法：
(function(){
})()
//用括号形成函数表达式
1,function(){
}()
//用逗号形成函数表达式
立即执行函数表达式的作用就是隔离函数，不会出现变量污染的情况。
求n!，用递归来实现
function factor(result){
if(result === 1){
return 1
}
return result *factor(result-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: 男
["饥人谷","2","男"]
name valley //
getInfo('小谷', 3);
//输出
name: 小谷
age: 3
sex: undefined
["小谷","3"]
name valley//
getInfo('男');
//输出
name: 男
age: undefined
sex: undefined
["男"]
name valley//
写一个函数，返回参数的平方和？
function sumOfSquares(){
var a =0;
for(var i=0;i<=arguments.length;i++){
a = + Math.pow(arguments[i],2)
}
return a
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
如下代码的输出？为什么
console.log(a);
var a = 1;
console.log(b);
//报错 因为b没有声明；如果去掉console(b)；则会输出undefined，因为变量声明提升了，但是赋值在输出之后。
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
//hello world
报错，因为函数表达式必须先声明再调用。
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
//查找过程伪代码：
globalContext = {
AO:{
x:10
foo:function
bar:function
}
Scope:null
}
foo.[[Scope]] = globalContext.AO
bar.[[Scope]] = globalContext.AO
barContext = {
AO:{
x:30
foo:function
}
Scope:bar.[[Scope]] = globalContext.AO
}
fooContext = {
AO:{
}
Scope:foo[[Scope]] =globalContext.AO
//
执行console.log(x)时 在fooContext里找不到,所以到globalContext.AO里找到x=10,所以输出10
- 如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
//查找过程伪代码
globalContext = {
AO:{
x:10
bar:function
}
Scope:null
}
bar.[[Scope]]:globalContext.AO
barContext = {
AO:{
x:30
foo:function
}
Scope:bar.[[Scope]]globalContext.AO
}
foo.[[Scope]]:barContext.AO
fooContext = {
AO:{
}
Scope:foo.[[Scope]]barContext.AO
}
在barContext里找到X=30；所以输出30。
- 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
//查找过程伪代码
globalContext = {
AO:{
x:10
bar:function
}
Scope:null
}
bar.[[Scope]] = globalContext.AO
barContext = {
AO:{
x:30
(function()) = (function())()
}
bar.[[Scope]]globalContext.AO
}
bar.[[Scope]] = globalContext.AO
输出30
- 以下代码输出什么？ 写出作用域链查找过程伪代码
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)
//查找过程伪代码
globalContext = {
AO:{
a:1 200
fn:function
fn3:function
}
Scope:null
}
fn.[[Scope]] = globalContext.AO
fn3.[[Scope]] = globalContext.AO
fnContext = {
AO:{
a:undefined 5 6 20
fn2:function
}
Scope:globalContext.AO
}
fn2:[[Scope]]=function.AO
fn3Context = }
AO:{
}
Scope:globalContext.AO
}
fn2Context = {
AO:{
}
Scope:fnContext.AO
}
输出为：undefined ,5 , 1, 6 ,20 ,200
