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为全局变量
网友评论