什么是函数？如何声明函数？
JavaScript中的函数是一段可重复使用的代码块，它可以接受输入并返回输出。 在JavaScript中，函数是一种特殊的对象，因此可以将其存储在变量中，将其作为参数传递给其他函数，并从其他函数中返回。
在JavaScript中，声明函数有两种方式：函数声明和函数表达式。
1. 函数声明
函数声明是指用关键字function定义函数的方法，在函数名后跟一对圆括号和一对花括号，并在花括号中编写函数体。
示例：声明一个函数，它将两个数字相加并返回其总和。
function addNumbers(num1, num2) {
return num1 + num2;
}2. 函数表达式
函数表达式是指将函数赋值给变量的方法。它通常包含一个匿名函数，因此可以使用变量名调用该函数。
示例：用函数表达式声明一个函数，它打印出两个数字的总和。
let addNumbers = function(num1, num2) {
console.log(num1 + num2);
};函数还可以在调用时接受参数。这些参数通常是函数需要的输入，可以在函数中使用。
例如，下面的函数将两个参数相加并返回结果：
function addNumbers(num1, num2) {
return num1 + num2;
}
let result = addNumbers(3, 5);
console.log(result); // 输出结果为 8在这个例子中，我们调用了addNumbers函数，并将3和5传递给它作为参数。计算完成后，该函数返回结果8。 最后，我们将结果输出到控制台。
总之，JavaScript中的函数是一种强大的工具，可以帮助我们将代码重用和管理代码流程。无论是函数声明还是函数表达式，我们都可以使用它们来创建代码块，以便在程序中多次使用。
函数如何返回值
JavaScript函数可以返回值。一个函数可以返回一个值，这个值可以是任意类型的数据，包括数字、字符串、对象等等。
要返回一个值，可以使用关键字“return”后面跟着要返回的值。示例如下：
function add(a, b) {
return a + b;
}
var sum = add(2, 3);
console.log(sum); // 输出 5在这个例子中，函数“add”返回了参数“a”和“b”的和。当使用这个函数时，返回值会被存储在变量“sum”中，并且在控制台中输出。
在函数内部，如果没有明确的使用“return”语句，则默认返回“undefined”。例如：
function sayHello() {
console.log("Hello");
}
var result = sayHello();
console.log(result); // 输出 undefined在这个例子中，函数“sayHello”没有返回任何值，因此默认返回了“undefined”。
在实际编程中，函数的返回值通常用于向调用者传递处理结果或者状态。例如，在某些情况下，可能需要根据函数返回的值采取不同的操作，像这样：
function checkAge(age) {
if (age >= 18) {
return "成年人";
} else {
return "未成年人";
}
}
var result = checkAge(20);
if (result === "成年人") {
console.log("你可以去看电影");
} else {
console.log("你还不能去看电影");
}在这个例子中，函数“checkAge”接收一个参数“age”，根据年龄判断是否成年，并返回“成年人”或“未成年人”。当调用函数时，返回值被存储在“result”变量中。在后面的代码中，使用“if”语句根据返回值来判断是否可以去看电影。
什么是函数参数？函数参数传递的方式有哪些？
函数参数是函数定义时用来接收外部传递进来的值或对象的占位符。在调用函数时，我们需要传递实际的值或对象作为函数参数，以便在函数内部使用。
函数参数传递的方式有以下几种：
-
传递单个值：直接把值传递给函数。
-
传递多个值：使用逗号分隔多个值，按照参数列表的顺序传递给函数。
-
传递对象：将一个对象作为参数传递给函数，函数可以通过对象访问其属性。
-
传递数组：将一个数组作为参数传递给函数，函数可以使用数组下标访问数组元素。
-
省略参数：可以省略某些参数，未传递的参数将被设定为undefined。
-
回调函数：将一个函数作为另一个函数的参数传递，以便在另一个函数执行完成后调用该函数。
-
使用arguments对象：函数内部可以使用arguments对象访问所有传递进来的参数，无需事先定义参数的名称和数量。
-
ES6中的展开运算符：可以使用展开运算符将数组或对象中的值展开为函数的参数。
在函数中使用全局变量可以直接使用全局变量的名称。在JavaScript中，全局变量可以通过在函数外部定义变量来创建。例如：
var globalVar = "Hello World!";
function myFunction() {
console.log(globalVar);
}
myFunction(); // 输出结果：Hello World!在函数内部创建局部变量，可以使用var、let和const关键字定义一个新的变量。这些变量的作用域仅限于函数内部，函数外部无法访问。例如：
function myFunction() {
var localVar = "This is a local variable.";
console.log(localVar);
}
myFunction(); // 输出结果：This is a local variable.
console.log(localVar); // 抛出ReferenceError异常：localVar is not defined在ES6中，使用let和const关键字创建的变量具有块级作用域，可以在定义变量的块中访问该变量，包括在函数内部。例如：
function myFunction() {
let localVar = "This is a local variable.";
console.log(localVar);
}
myFunction(); // 输出结果：This is a local variable.
console.log(localVar); // 抛出ReferenceError异常：localVar is not defined什么是函数作用域
JavaScript的函数作用域是指变量可以在函数内声明并在函数内使用，而在函数外无法访问该变量。这是因为JavaScript中的函数都有它们自己的作用域。
例如，在以下示例中，变量x在函数foo的作用域中声明，因此只能在该函数内部使用：
function foo() {
var x = 10; // 变量x 只在函数foo中可见
console.log(x);
}
console.log(x); // 报错，变量x无法访问函数作用域可以帮助程序员避免变量命名冲突和全局变量的滥用。它还允许在函数内声明和使用私有变量，这些变量不会泄露到全局作用域中。
JavaScript中的函数作用域实现是通过词法作用域（也称静态作用域）实现的。在词法作用域中，函数的作用域是在函数定义时确定的，而不是在函数调用时确定的。这意味着函数可以在它被定义的地方访问其外部作用域中的变量，而不必等到函数被调用时。
什么是闭包？如何使用闭包？
闭包是指在一个函数内部定义另一个函数，并使得这个内部函数可以访问到外部函数的变量和参数。闭包可以将这些变量和参数的值保存下来，以供后续使用。
在JavaScript中，可以使用闭包来实现许多功能，比如：
1. 封装私有变量
通过使用闭包，可以创建一个对象，该对象包含一些私有变量和一些公共方法，但这些私有变量无法从外部访问。这样做可以保证代码的安全性和可维护性。
例如：
function createCounter() {
var count = 0;
return {
increment: function() {
count++;
},
getValue: function() {
return count;
}
};
}
var counter = createCounter();
counter.increment();
console.log(counter.getValue()); // 12. 延迟执行
通过使用闭包，可以在需要时延迟执行某些代码，这对于一些需要耗费时间的操作（比如网络请求）很有用。
例如：
function delayedAlert(message, time) {
setTimeout(function() {
alert(message);
}, time);
}
delayedAlert('Hello World!', 2000);3. 记忆化
通过使用闭包，可以在函数执行时将其结果缓存下来，以便下次执行时直接返回缓存的结果，从而提高性能。
例如：
function memoize(func) {
var cache = {};
return function() {
var key = JSON.stringify(arguments);
if (cache[key]) {
return cache[key];
} else {
var result = func.apply(this, arguments);
cache[key] = result;
return result;
}
};
}
var fib = memoize(function(n) {
if (n <= 1) {
return n;
} else {
return fib(n - 1) + fib(n - 2);
}
});
console.log(fib(10)); // 554. 模块化
通过使用闭包，可以创建一个独立的模块，该模块包含一些私有变量和方法，同时仍然可以对外暴露一些公共方法。
例如：
var calculator = (function() {
var result = 0;
function add(x) {
result += x;
}
function subtract(x) {
result -= x;
}
function reset() {
result = 0;
}
function getResult() {
return result;
}
return {
add: add,
subtract: subtract,
reset: reset,
getResult: getResult
};
})();
calculator.add(5);
calculator.subtract(2);
console.log(calculator.getResult()); // 3
calculator.reset();
console.log(calculator.getResult()); // 0总之，闭包是一种非常强大的功能，在JavaScript中广泛使用。它可以用于封装私有变量、延迟执行、记忆化、模块化等多种场合。
闭包的优点和缺点是什么？
JavaScript闭包的优点：
- 可以通过闭包来创建私有变量和方法，防止变量和方法被外部代码访问和修改，从而保护程序的安全性。
- 可以帮助我们实现高阶函数，从而提高代码的可复用性，并且可以使代码更加简洁。
- 闭包可以实现数据缓存，从而提高程序的性能，避免重复计算。
JavaScript闭包的缺点：
- 闭包可能导致内存泄漏，因为闭包中捕获的变量不会被垃圾回收机制自动释放。
- 闭包的运行速度可能比常规函数慢，因为它需要同时保存外部函数的作用域和内部函数的作用域。
- 闭包可能会导致变量被意外修改，因为闭包中的变量是共享的，如果在外部函数中修改了闭包中的变量，那么所有使用该闭包的代码都会受到影响。
什么是高阶函数
在JavaScript中，高阶函数是指能够接收一个或多个函数作为参数，并且能够返回一个新函数的函数。这种函数的灵活性让它们非常强大，并可以用于编写更加简洁和灵活的代码。
高阶函数的特点：
- 接收一个或多个函数作为参数。
- 返回一个新函数。
- 可以对参数函数进行处理，比如运算、组合、封装等操作。
高阶函数的使用场景：
- 回调函数：在异步代码中，高阶函数常常被用作回调函数，用于处理异步操作的结果。
- 遍历：高阶函数可以用于对数组、对象或其他数据结构进行遍历和筛选。
- 函数组合：高阶函数可以将多个处理逻辑组合在一起，实现更加复杂的功能。
- 封装：高阶函数可以用于对一些重复的操作进行封装，提高代码重用性和可维护性。
例如，如果我们想在一个数组中找到所有大于3的数字，可以使用高阶函数`filter`：
const arr = [1, 2, 3, 4, 5];
const result = arr.filter(function(item) {
return item > 3;
});
console.log(result); // [4, 5]在上述代码中，`filter`函数就是一个高阶函数，它接收一个匿名函数作为参数，用于处理数组元素，并返回一个新的数组，其中仅包含满足条件的元素。
什么是回调函数？如何使用回调函数？
回调函数是一个在某个事件发生时执行的函数，它是JavaScript中一种常见的异步编程方式。回调函数通常作为参数传递给另一个函数，并在另一个函数执行完毕后被调用。
使用回调函数时，需要注意以下几点：
- 回调函数必须是一个函数，可以是内置函数或自定义函数。
- 回调函数必须作为参数传递给另一个函数，并在另一个函数执行完毕后被调用。
- 回调函数的参数和返回值必须符合另一个函数的要求。
示例：
function add(a, b, callback) {
var result = a + b;
callback(result);
}
add(1, 2, function(result) {
console.log(result);
});在上面的例子中，add函数有三个参数，其中callback函数是回调函数，当add函数执行完毕后，会调用这个回调函数并传递计算结果。
在调用add函数时，传入了两个数字和一个回调函数。回调函数在add函数执行完毕后被调用，并打印出计算结果。
什么是箭头函数？
JavaScript中的箭头函数是ES6(ECMAScript 2015)中添加的一种新函数类型。箭头函数是一种更简洁的函数声明方式，同时也有不同于传统函数的一些特性。
箭头函数的语法形式为：（参数）=> {函数体}
其中，参数和函数体之间由箭头符号（=>）连接。
箭头函数与传统函数的一些不同点如下：
-
箭头函数没有自己的this对象，它的this继承自父作用域。这意味着在箭头函数中使用this时，它实际上是指向父作用域中的this，而不是箭头函数自己的this。
-
箭头函数没有arguments对象，但可以使用rest参数(...args)取代。
-
如果箭头函数只有一个参数，可以省略小括号。
-
如果函数体只有一条语句，可以省略大括号和return语句。
箭头函数的应用场景：
-
作为回调函数。箭头函数的简洁语法和继承父作用域的this对象使它非常适合作为回调函数。
-
与数组方法结合使用。在数组方法中，箭头函数比传统函数更具可读性和简洁性。
-
与PromiseAPI结合使用。在PromiseAPI中，箭头函数可以帮助我们更方便地处理异步代码。
总之，箭头函数是一种更简洁、更易读、更方便的函数类型，它的使用可以提高代码的可读性和开发效率。
// 传统函数
function greeting(name) {
console.log("Hello, " + name);
}
// 箭头函数
const greetingArrow = name => {
console.log("Hello, " + name);
}
greeting("Tom"); // 输出 "Hello, Tom"
greetingArrow("Jerry"); // 输出 "Hello, Jerry"const shoppingCart = [
{ id: 1, name: "Shirt", price: 25 },
{ id: 2, name: "Pants", price: 50 },
{ id: 3, name: "Shoes", price: 100 }
];
const VAT_RATE = 0.2; // 税率
const calculateTotalPrice = shoppingCart => {
// 使用 reduce 方法计算购物车中所有商品的总价
const totalPrice = shoppingCart.reduce((acc, product) => acc + product.price, 0);
// 计算总价和税费
const total = totalPrice + (totalPrice * VAT_RATE);
// 四舍五入并保留两位小数
return Math.round(total * 100) / 100;
}
const total = calculateTotalPrice(shoppingCart);
console.log("Total Price: $" + total); // 输出 "Total Price: $210"什么是Promise？如何使用Promise？
Promise是JavaScript中一种异步编程的解决方案，它表示一个尚未完成但预计将来会完成的操作，并提供一种处理该操作结果的方式。
在Promise中，我们可以定义需要执行的操作，以及当操作完成后需要执行的一系列回调函数。Promise既可以表示操作失败的情况，也可以表示操作成功的情况。
Promise具有以下特点：
1. Promise对象的状态不受外界影响。一旦状态改变，就不会再变，任何时候都可以得到这个结果。
2. Promise对象的状态一旦改变，就不能再改变。如果不设置回调函数，Promise内部的错误不会影响到外部。
3. Promise 对象提供了链式操作，可以使其代码更加简洁易读。
const promise = new Promise((resolve, reject) => {
// 异步操作
setTimeout(function(){
const num = Math.random();
if(num < 0.5){
resolve(num)
} else {
reject(num)
}
}, 1000)
})
promise.then((res)=>{
console.log("操作成功，结果为：", res);
}).catch((err)=>{
console.log("操作失败，结果为：", err);
})上述代码中，我们通过Promise构造函数创建了一个Promise对象，在异步操作完成后通过resolve方法表示操作成功并返回一个结果，通过reject方法表示操作失败并返回一个错误信息。在then和catch方法中，我们分别定义了操作成功和操作失败后需要执行的回调函数。
Promise有三种状态：pending、fulfilled和rejected。当异步操作执行时，它最初处于pending状态。如果异步操作成功，则状态变为fulfilled，并返回一个值，如果发生错误，则状态变为rejected，并返回一个错误对象。
下面是使用Promise的简单示例：
function fetchData() {
return new Promise((resolve, reject) => {
fetch('https://jsonplaceholder.typicode.com/users')
.then(response => response.json())
.then(data => resolve(data))
.catch(error => reject(error))
})
}
fetchData()
.then(data => console.log(data))
.catch(error => console.error(error))上面的代码中，fetchData函数返回一个Promise。如果异步操作成功，它会调用resolve回调函数，并传递数据对象。如果发生错误，它会调用reject回调函数，并传递一个错误对象。
在这个示例中，我们使用了fetch API来获取数据。通过调用response.json()，我们将响应对象转换为JSON格式的数据。最后，我们处理数据对象或错误对象，您可以在.then()和.catch()方法中进行操作。
在处理异步操作时，Promise非常强大且易于使用。它可以简化代码并提高可读性。不要犹豫，尝试使用Promise来处理异步操作。
什么是async/await？ 如何使用async/await？
async/await 是一种用于简化异步操作的语法特性。它基于 Promise 对象，利用 async 和 await 关键字简化 Promise 的链式调用和错误处理，使异步代码看起来像同步代码。
async 表示一个函数是异步的，并返回一个 Promise 对象。await 表示等待 Promise 对象的解决，并返回 Promise 对象的解决值。使用 async/await 可以避免回调地狱，提高代码的可读性和可维护性。
使用 async/await 的基本流程如下：
1.定义一个异步函数，使用 async 关键字标记。
2.在函数中使用 await 关键字等待 Promise 对象处理完成，返回 Promise 对象的解决值。
3.处理 Promise 对象的错误，使用 try...catch 捕获异步操作的错误。
例如：
async function getData() {
try {
let response = await fetch('https://jsonplaceholder.typicode.com/users');
let data = await response.json();
console.log(data);
} catch (error) {
console.log(error);
}
}
getData();在上面的例子中，我们定义一个异步函数`getData`，使用 await 关键字等待 fetch() 方法返回的 Promise 对象处理完成，然后再使用 await 关键字等待 response 对象的 json() 方法返回的 Promise 对象处理完成，最后将返回的 JSON 数据输出。同时使用 try...catch 捕获异步操作的错误，便于进行错误处理。
使用 async/await 可以大大简化 Promise 的链式调用和错误处理，提高代码的可读性和可维护性。但需要注意的是，await 只能在 async 函数内部使用，否则会报语法错误。