数组常用函数
//1.find()
const arry1 = [5,12,8,130,44];
const found = arry1.find(a => a > 10);
// 这一行使用了find方法，它是JavaScript数组对象的一个方法，用于找出第一个满足提供的测试函数的元素。
// find()的箭头函数：变量名 => 条件【满足条件返回它所找到的第一个值，不满足返回undefined】
console.log(found);//[12]
//2.filter()
const arry1 = [5, 12, 8, 130, 44];
const filtered = arry1.filter(element => element > 10); // 返回所有大于10的元素组成的新数组
console.log(typeof filtered); // object--->数组是特殊的对象
console.log(filtered); // [12,130,44]
console.log(Array.isArray(filtered)); // true
// 返回一个新数组，包含所有满足条件的元素,没有就返回空数组。
// 3.include()
const array = [1, 2, 3, 4, 5];
if (array.includes(3&&4)) { // 检查数组是否包含元素3
console.log('数组包含元素 3和4');
} else {
console.log('数组不包含元素 3或4');
}
// 检查数组里有没有相应的值
//4.Array.isArray()
console.log(Array.isArray(变量)); // true
//检查是不是Array类型
//5.push()
const arr = [1, 2, 3]
arr.push(8)
console.log(arr) // [1, 2, 3, 8]
//在数组后面添加数字
//6.pop()
const arr = [1, 2, 3]
const popVal = arr.pop()//移除arr里最后一个元素，并返回它给popVal
console.log(popVal) // 3 -->被移走的元素
console.log(arr) // [1, 2]
//栈 -->
// ① 数组模拟常见数据结构之一：栈
const stack = [0, 1]
stack.push(2) // 压栈
console.log(stack) // [0, 1, 2]
const popValue = stack.pop() // 出栈
console.log(popValue) // 2
console.log(stack) // [0, 1]
//7.unshift()
const arr = [1, 2, 3]
arr.unshift(0)
console.log(arr) // [0, 1, 2, 3]
//8.shift()
const arr = [1, 2, 3]
const shiftVal = arr.shift()--移除arr里第一一个元素，并返回它给shiftVal
console.log(shiftVal) // 1 -->被移走的元素
console.log(arr) // [2, 3]
// ②数组模拟常见数据结构之一：队列
const queue = [0, 1]
queue.push(2) // 入队
console.log(queue) // [0, 1, 2]
const shiftValue = queue.shift() // 出队
console.log(shiftValue) // 0
console.log(queue) // [1, 2]
//9.concat()
const arr = [1, 2, 3]
const arr2 = arr.concat([7, 8, 9])
console.log(arr) // [1, 2, 3]
console.log(arr2) // [1, 2, 3, 7, 8, 9]
//把concat括号里的内容放到原数组的后面
//10.ndexof()
const arr = [1, 2, 3]
console.log(arr.indexOf(2)) // 1
console.log(arr.indexOf(-1)) // -1
// 在数组中寻找该值，找到则返回其下标，找不到则返回-1。
//11.join()
const arr = [1, 2, 3]
console.log(arr.join()) // ‘1, 2, 3’//将数组转化成字符串，并返回该字符串，不传值则默认逗号隔开，
console.log(arr) // [1, 2, 3]//原数组不变。
// 将数组转化成字符串，并返回该字符串，不传值则默认逗号隔开，原数组不变。
let fruits = ["Apple", "Banana", "Cherry"];
let result = fruits.join(", "); // 使用逗号和空格作为分隔符
//12.reverse()
console.log(result); // 输出: Apple, Banana, Cherry
const arr = [1, 2, 3]
console.log(arr.reverse()) // [3, 2, 1]
console.log(arr) // [3, 2, 1]
// 翻转原数组，并返回已完成翻转的数组，原数组改变。
13. slice(start,end)
const arr = [1, 2, 3, 4, 5]
console.log(arr.slice(1, 4)) // [2, 3, 4]
//角标为1 --- 角标为3
console.log(arr) // [1, 2, 3, 4, 5]
// 从start 开始截取到end，但是不包括end
//14.splice(index1,index2,new1,new2,new3.....)
const arr3 = [1, 2, 3, 4, 5, 6, 7, "f1", "f2"];
const arr4 = arr3.splice(2, 3)
console.log(arr4); // [3, 4, 5];
console.log(arr3); // [1, 2, 6, 7, "f1", "f2"];
const arr5 = arr3.splice(2, 0, "wu", "leon"); //插入的元素在选定下标位置前面
console.log(arr5); // [] 返回空数组
console.log(arr3); // [1, 2, "wu", "leon", 6, 7, "f1", "f2"];
const arr6 = arr3.splice(2, 3, "xiao", "long");
console.log(arr6); // ["wu", "leon", 6]
console.log(arr3); //[ 1, 2, "xiao", "long", 7, "f1", "f2"]
const arr7 = arr3.splice(2);
console.log(arr7);// ["xiao", "long", 7, "f1", "f2"]
console.log(arr3); // [1, 2]
原数组删除从下标index1开始num个元素【包括端点】，如果需要被删元素，将它存到新的变量里就好
p.s.如果num不写，默认删光下标开始所有元素
//15.sort((a, b) => a - b)--从小到大
//15.sort((a, b) => b - a)--从大到小
const arr = [1, 4, 3]
arr.sort((a, b) => b - a)
console.log(arr) // [4, 3, 1]
const arrplus = [1, 4, 3]
arrplus.sort((a, b) => a - b)
console.log(arrplus) // [1, 3, 4]
//16.tostring()
const arr = [1, 2, 3, 4, 5]
console.log(arr.toString()) // ‘1, 2, 3, 4, 5’
console.log(arr) // [1, 2, 3, 4, 5]
将数组变成字符串 将数组转化成字符串，并返回该字符串，**逗号**隔开，原数组不变。
//1.Number.isNaN()
function isNumber(value) { // 功能-->检查是不是数字
return typeof value === 'number' && !Number.isNaN(value);
} //isNaN 函数来排除那些虽然是数字类型，但值实际上是 NaN（Not-a-Number）的情况。
object
它用于存储各种键值对。
- 对象是由键（也称为属性或成员）和值组成的集合。
- 每个键都是一个字符串（或者是一个Symbol），而值可以是任何类型的数据。
- 对象的键值对是无序的。
数组（Array）是对象的一种特殊形式，它是一个有序的集合，其中的元素可以通过数字索引来访问。
typeof
检查变量类型
NaN
- 任何涉及 NaN 的操作都会返回 NaN，例如数学运算。
- NaN 与任何值（包括它自己）都不相等，即 NaN === NaN 的结果是 false。
- NaN 的类型是 “number”，即 typeof NaN 返回 "number"。
要检查一个值是否为 NaN，可以使用全局函数 isNaN()，但更推荐使用 Number.isNaN()，
因为 isNaN() 会尝试将参数转换为数字，而 Number.isNaN() 不会，这使得 Number.isNaN() 的行为更可预测。
栈
栈（Stack）是一种线性数据结构，它遵循特定的访问原则，即后进先出（Last In First Out, LIFO）。这意味着最后压入栈中的元素将会是第一个被弹出栈的元素。栈的操作主要包含以下几种：
- 压栈（Push）：在栈顶添加一个元素。
- 出栈（Pop）：移除栈顶元素，并返回它。
- 查看栈顶元素（Peek/Top）：返回栈顶元素，但不移除它。
- 检查栈是否为空（IsEmpty）：判断栈内是否含有元素。
- 获取栈的大小（Size）：返回栈中元素的数量。
栈的运用非常广泛，以下是一些常见的应用场景：
- 程序调用的存储：在程序执行时，每当一个函数被调用，它的返回地址以及局部变量就会被存储在一个栈帧中，当函数执行完毕后，栈帧会被弹出，程序继续执行之前的代码。
- 表达式求值：编译器在解析和计算表达式时，比如将中缀表达式转换为后缀表达式，或者直接计算后缀表达式，都会使用栈来存储操作数和操作符。
- 递归算法：递归函数在执行时，每递归一次就会在调用栈上添加一个新的栈帧，用于存储该次调用的状态信息。
- 后退/撤销操作：在文本编辑器或浏览器中，后退操作可以通过将之前的操作压入栈来实现，用户点击后退时，就可以从栈中弹出操作进行撤销。
- 深度优先搜索（DFS）：在图和树的遍历算法中，栈可以用来存储接下来要访问的节点。
括号匹配：在编译器中，检查代码中的括号是否匹配时，可以使用栈来存储左括号，每当遇到右括号时，就从栈中弹出一个左括号进行匹配。 - 函数调用栈：操作系统在执行程序时，会使用栈来管理函数调用，这被称为调用栈。
- 内存分配：在许多系统中，栈被用来动态地分配和释放内存。
- 浏览器历史记录：浏览器用来存储用户访问过的网页历史，前进和后退操作实际上是在这个历史栈上操作。
队
队列（Queue）也是一种线性数据结构，它遵循先进先出（First In First Out, FIFO）的原则。这意味着队列中最早进入的元素将会是最先被移除的元素。队列的操作主要包括以下几种：
入队（Enqueue）：在队列的末尾添加一个元素。
出队（Dequeue）：移除队列的第一个元素，并返回它。
查看队列头部元素（Front/Peek）：返回队列的第一个元素，但不移除它。
检查队列是否为空（IsEmpty）：判断队列内是否含有元素。
获取队列的大小（Size）：返回队列中元素的数量。
队列的运用非常广泛，以下是一些常见的应用场景：
任务调度：操作系统中的任务队列用来存储等待处理的任务，按照任务的到达顺序进行处理。
缓冲处理：在数据传输过程中，如IO操作，队列可以用来平滑处理速度不匹配的设备之间的数据流。
打印任务管理：打印机的打印队列按照文档提交的顺序打印文档。
消息队列：在消息传递系统中，消息队列用来存储和转发消息，确保消息的有序传递。
线程池：在多线程编程中，线程池中的任务队列用来存储待执行的任务。
数据结构中的算法：如广度优先搜索（BFS）算法在图和树的遍历中使用队列来存储接下来要访问的节点。
队列与栈的区别主要在于它们对元素的操作原则不同：
栈 VS 队
- 操作原则：
栈是后进先出（LIFO），最后进入的元素最先被移除。
队列是先进先出（FIFO），最先进入的元素最先被移除。 - 功能用途：
栈通常用于那些需要后进先出特性的场景，如递归、后退操作、表达式求值等。
队列通常用于那些需要先进先出特性的场景，如任务调度、缓冲处理、消息队列等。 - 数据访问：
栈只允许在一端进行插入和删除操作，即栈顶。
队列允许在一端插入元素（队尾），在另一端删除元素（队头）。
数组元素转换为字符串【场景】
- 将数组元素转换为字符串：当你需要将数组中的所有元素转换成一个单一的字符串，并且元素之间需要用特定的分隔符连接时。
- 数据格式化：在将数据输出到控制台、显示在网页上或者发送到服务器之前，你可能需要将数组格式化为一个字符串。
- 生成CSV数据：如果你需要生成CSV（逗号分隔值）格式的数据，join() 方法可以用来将数组元素转换成一个CSV格式的字符串。
- 拼接HTML：在构建动态HTML内容时，你可能需要将数组中的元素转换成一个字符串，以便插入到DOM中。
join() 与 toSing()
Difference：
分隔符：join()允许自定义分隔符，而toString()总是使用逗号,作为分隔符。
用途：虽然两者都用于将数组转换为字符串，但join()提供了更灵活的字符串格式化选项。
返回值：两者都返回一个字符串，但join()可以根据需要返回不同的格式。
Same：
原数组不变：两者都不会改变原数组。
Conclude：
总的来说，join()方法在功能上比toString()更强大，因为它允许开发者自定义元素之间的分隔符，而toString()方法则更简单，用于快速获取数组的字符串表示。
let result = fruits.join(", "); // 使用逗号和空格作为分隔符
console.log(arr.toString()) // ‘1, 2, 3, 4, 5’
字符串常用函数
//1.charAt
var father = 'abcdefg'
let son = father.charAt(2)
console.log(son) // 输出 'c'
console.log(father[3]) // 输出 'd'
// 返回指定索引位置处的字符。类似于数组用中括号获取相应下标位置的数据。
//2.concat()
const str1 = 'abcdefg'
const str2 = '1234567'
const str3 = str1.concat(str2)
console.log(str3) // 输出 'abcdefg1234567'
// 类似数组的concat()，用来返回一个合并拼接两个或两个以上字符串。原字符串不变。
//3.indexOf() lastIndexOf()
const str = 'abcdcefcg'
console.log(str.indexOf('c')) // '2'
console.log(str.lastIndexOf('c')) // '7'
// indexOf,返回一个字符在字符串中首次出现的位置,
// lastIndexOf返回一个字符在字符串中最后一次出现的位置。
//4.slice(index,endIndex) --->endl:截至位置下标
const str = 'abcdefg'
console.log(str.slice()) // 'abcdefg'
console.log(str.slice(1)) // 'bcdefg'
console.log(str.slice(2, str.length-1)) // 'cdef'
//5.split()
const str = 'A*B*C*D*E*F*G'
console.log(str.split('*')) // ["A", "B", "C", "D", "E", "F", "G"]
const str1 = 'ABC*DEF*G'
console.log(str1.split('*')) // ['ABC', 'DEF', 'G']
// 使用指定的分隔符将一个字符串拆分为多个子字符串数组并返回，原字符串不变。
//6.substr(index)-->从index开始，后面都砍掉
//6.substr(index, length)-->从index开始，长度为length删掉
const str = 'ABCDEFGHIJKLMN'
console.log(str.substr(2)) // 'CDEFGHIJKLMN'
console.log(str.substr(2, 9)) //'CDEFGHIJK'
// substr的参数二如果为0或者负数，则返回一个空字符串，如果未填入，则会截取到字符串的结尾去。substring的参数一和参数二为NAN或者负数，那么它将被替换为0。
//7.substring(index,newIndex)-->从index开始，newIndex截至【不包括newIndex】
//7.substring(index)-->从index开始，后面都砍掉
const str = 'ABCDEFGHIJKLMN'
console.log(str.substring(2)) //'CDEFGHIJKLMN'
console.log(str.substring(2, 9)) //'CDEFGHI'
//8.match()
const str = '2018年结束了，2019年开始了'
const reg = /\d+/g // 这里是定义匹配规则，匹配字符串里的1到多个数字
// /\d+/g 是一个全局正则表达式，\d 匹配任何数字（等价于 [0-9]），+ 表示匹配一次或多次。g 标志代表全局匹配
console.log(str.match(reg)) // 输出符合匹配规则的内容，以数组形式返回 ['2018', '2019']
console.log(str.match('年')) // 不使用正则 ["20", index: 4, input: "2018年结束了，2019年开始了"]
console.log(str.match('20')) // 不使用正则 ["20", index: 0, input: "2018年结束了，2019年开始了"]
// 当你传递一个字符串（而不是正则表达式）给 match() 方法时，它会返回第一个与该字符串匹配的子串的信息。返回值是一个数组，其中第一个元素是匹配的子串，index 属性是匹配子串在原字符串中的位置，input 属性是原字符串本身。
//9.search(number)
const str = '2018年结束了，2019年开始了，2020年就也不远了'
const reg = /\d+/i // 这里是定义匹配规则,匹配字符串里的1到多个数字
console.log(str.search(reg)) // 输出 0 这里搜索到的第一项是从位置0开始的
//10.toLowerCase(变量名) -->全转小写
//10.toUpperCase(变量名) -->全转大写
const str1 = 'A！cd1fg'
const str2 = 'aBCDEFG'
console.log(str2.toLowerCase()) // 'abcdefg'
console.log(str1.toUpperCase()) // 'A！CD1FG'
// 数字，特殊符号不变
// 11.includes('X')
// 11.startsWith('X')
// 11.endsWith('X')
const str = 'Excuse me, how do I get to park road?'
console.log(str.includes('how')) // true
console.log(str.startsWith('Excuse')) // true
console.log(str.endsWith('?')) // true
//包含X？ 以X为开头？ 以X为结尾？
//12.repear(times)
const str = 'http'
const str2 = str.repeat(3)
console.log(str) // 输出：'http'
console.log(str2) // 输出：'httphttphttp'
//重复次数
//13.replace()
const str = '2018年结束了，2019年开始了，2020年就也不远了'
const rex = /\d+/g
const str1 = str.replace(rex, '****')
console.log(str1) // "****年结束了，****年开始了,****年也不远了"
const str2 = str.replace(rex, function(item){
console.log(arguments)
const arr = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']
let newStr = ''
item.split('').map(function(i){
newStr += arr[i]
})
return newStr
})
console.log(str2) //贰零壹捌年结束了，贰零壹玖年开始了,贰零贰零年也不远了
match() 与 search()
match()
用途：match() 方法用于在字符串中检索与正则表达式匹配的子串。
参数：接受一个正则表达式作为参数。
返回值：
如果使用全局匹配（即正则表达式中包含 g 标志），则返回一个包含所有匹配子串的数组。
如果不使用全局匹配，则返回第一个匹配的结果，包括匹配的子串、捕获组（如果有），以及 index（匹配子串在原字符串中的位置）和 input（原字符串）属性。
如果没有找到匹配，则返回 null。
search()
用途：search() 方法用于在字符串中检索与正则表达式匹配的子串的位置。
参数：接受一个正则表达式作为参数。
返回值：
返回第一个匹配的子串在原字符串中的位置索引。
如果没有找到匹配，则返回 -1。
注意：search() 方法不提供全局搜索功能，即正则表达式中的 g 标志对 search() 方法没有影响。
Arguments 与 this
Same
- 都是函数执行时的上下文相关的内部对象。
- 它们都可以在函数内部使用，而不需要显式地作为参数传递。
Difference
- this 指向函数的调用者，而 arguments 包含了函数调用时的参数列表。
- 箭头函数没有自己的 this 和 arguments 对象，它们从外围函数继承 this 值，并且不能直接访问 arguments 对象（除非通过剩余参数 ...args）。
遍历方法
// 1. for() while() do{} while()
// 2. forEach(变量数组)
const arr = [5,1,3,7,4]
arr.forEach((item, index) => {
if (item < 2)
return//return无法终止循环。不过可以起到continue效果。
// 本身是不支持的continue与break语句的我们可以通过some和 every来实现。
console.log(`索引：${index}，数值：${item}`)
arr[5] = 0
})
console.log(arr)
// 打印结果：
// 索引：0，数值：5
// 索引：2，数值：3
// 索引：3，数值：7
// 索引：4，数值：4
// [5, 1, 3, 7, 4, 0]
//3.for (变量类型 变量名 in 原来对象)--->了解即可
const foo = {name: 'bar', sex: 'male'}
Object.defineProperty(foo, "age", { value : 18 })
for(const key in foo){
console.log(`可枚举属性：${key}`)
}
console.log(`age属性：${foo.age}`) // 可枚举属性：name 可枚举属性：sex age
//主要是用来循环遍历对象的属性。
// 遍历数组的缺点：数组的下标index值是数字，for-in遍历的index值"0","1","2"等是字符串。
// Object.defineProperty，建立的属性，默认不可枚举。
//4.for (变量类型 变量名 of 原来对象)
// for of 循环直接得到的就是值
const arr = [1, 2, 3]
for (const value of arr) {
console.log(value)
}
//5.some(形参)形参个数多少都可以，不用声明变量
const foo = [5,1,3,7,4].some((item, index) => {
console.log(`索引：${index}，数值：${item}`)
return item > 2
})
console.log(foo)
// 索引：0，数值：5
// true
//6.every(形参1，形参2)形参个数多少都可以，不用声明变量
const foo = [5,1,3,7,4].every((item, index) => {
console.log(`索引：${index}，数值：${item}`)
return item > 2
})
console.log(foo)
// 索引：0，数值：5
// 索引：1，数值：1
// false
//7. filter(形参)
const foo = [5,1,3,7,4].filter((item,index) => {
console.log(`索引：${index}，数值：${item}`)
return item > 2
})
console.log(foo)
// 索引：0，数值：5
// 索引：1，数值：1
// 索引：2，数值：3
// 索引：3，数值：7
// 索引：4，数值：4
// [5, 3, 7, 4]
// 该方法不会改变原数组。
//8.map(形参)
const foo = [5,1,3,7,4].map((item,index) => {
console.log(`索引：${index}，数值：${item}`)
return item + 2//每个元素+2
})
console.log(foo)
// 打印结果：
// 索引：0，数值：5
// 索引：1，数值：1
// 索引：2，数值：3
// 索引：3，数值：7
// 索引：4，数值：4
// [7, 3, 5, 9, 6]
// map：支持return，相当与原数组克隆了一份，把克隆的每项改变了，也不影响原数组
//9.reduce()-->从左到右将数组元素做“叠加”处理，
//9.reduceRight()-->从右到左叠加
const foo = [5,1,3,7,4].reduce((total, cur) => {
console.log(`叠加：${total}，当前：${cur}`)
return total + cur
})
console.log(foo)
// 打印结果：
// 叠加：5，当前：1
// 叠加：6，当前：3
// 叠加：9，当前：7
// 叠加：16，当前：4
// 20
//10.Object.keys(变量)
const obj = {p1: 123, p2: 456};
Object.keys(obj) // ["p1", "p2"]
//方法的参数是一个对象，返回一个数组。该数组的成员都是该对象自身的（而不是继承的）所有属性名，且只返回可枚举的属性。
//11.Object.getOwnPropertyNames(变量名)
const arr = ['Hello', 'World'];
Object.keys(arr) // ["0", "1"]
Object.getOwnPropertyNames(arr) // ["0", "1", "length"]
//在11的基础上还返回数组长度
for...in 与for...of
（1）for…in 用于可枚举数据，如对象、数组、字符串
（2）for…of 用于可迭代数据，如数组、字符串、Map、Set
for…of是ES6新增的方法，但是for…of不能去遍历普通的对象，for…of的好处是可以使用break跳出循环。
for-of这个方法避开了for-in循环的所有缺陷
与forEach()不同的是，它可以正确响应break、continue和return语句
for-of循环不仅支持数组，还支持大多数类数组对象，例如DOM NodeList对象。
for-of循环也支持字符串遍历
some()与every()
Same
- 都返回一个布尔值。
- 当我们需要判定数组中的元素是否都满足某些条件时，可以使用every / some。
Difference
- every会去遍历判断是否数组中的每一项都满足条件，遇到不满足的直接停止遍历,返回false
- some则是当某一项满足条件时停止遍历，返回true。
Conclude
every ---> every 方法中的回调函数返回 false 时，every 方法会立即停止执行，并返回 false。
some ---> some 方法在回调函数返回 true 时立即停止执行，并返回 true。
以上遍历的区别与联系
map()，forEach()，filter()循环的共同之处：
1.forEach，map，filter循环中途是无法停止的，总是会将所有成员遍历完。
2.他们都可以接受第二个参数，用来绑定回调函数内部的 this 变量，将回调函数内部的 this 对象，指向第二个参数，间接操作这个参数（一般是数组）。
map()、filter()循环和forEach()循环的不同：
forEach 循环没有返回值； map，filter 循环有返回值。
map()和filter()
都会跳过空位，for 和 while 不会
some()和every():
some()只要有一个是true，便返回true；而every()只要有一个是false，便返回false.
reduce()，reduceRight()：
reduce是从左到右处理（从第一个成员到最后一个成员），reduceRight则是从右到左（从最后一个成员到第一个成员）。
Object对象的两个遍历 Object.keys 与 Object.getOwnPropertyNames：
他们都是遍历对象的属性，也是接受一个对象作为参数，返回一个数组，包含了该对象自身的所有属性名。
但Object.keys不能返回不可枚举的属性；Object.getOwnPropertyNames能返回不可枚举的属性。
回调函数定义：回调函数是定义在调用函数之外的函数，但它被作为参数传递给另一个函数。
传递：你可以在调用另一个函数时，将回调函数作为参数传递。
执行：回调函数不是立即执行，而是在包含它的函数中的某个点被调用。
用途：回调函数常用于异步操作（如读取文件、网络请求、定时器等），在操作完成时执行特定的逻辑。
function greet(name, callback) {
console.log('Hello, ' + name);
callback();
}
function sayGoodbye() {
console.log('Goodbye!');
}
// 调用 greet 函数，并将 sayGoodbye 作为回调函数传递
greet('Alice', sayGoodbye);
//匿名的回调函数
// 在这个例子中，我们没有预先定义一个名为 sayGoodbye 的函数，而是直接传递了一个匿名函数作
//为回调。回调函数在 JavaScript 中非常普遍，尤其是在处理异步操作时
//例如在 setTimeout、setInterval、事件监听器、AJAX 请求（通过 XMLHttpRequest 或 fetch API）等场景中。
greet('Bob', function() {
console.log('Goodbye!');
});
//回调地狱
setTimeout(function() {
console.log('First task done');
setTimeout(function() {
console.log('Second task done');
setTimeout(function() {
console.log('Third task done');
// 可能还有更多的嵌套...
}, 1000);
}, 1000);
}, 1000);
回调地狱（Callback Hell）是指在编程中，特别是在 JavaScript 中，由于大量的嵌套回调函数导致的代码难以阅读和维护的现象。这种代码通常看起来像是一层又一层的回调函数，每个回调都依赖于前一个回调的结果，形成了一种金字塔式的结构，也被称为“末日金字塔”。
箭头函数注意事项
箭头函数=>后面加{ }和不加效果完全不一样
箭头函数有花括号{ }与没有{ }的区别
1.有 默认无返回值 () => { } 默认没有返回值，如果需要返回值需要写return
2.没有 默认返回 () => 1 + 1 默认返回，
// 1.三元表达解决问题
const n =5;
const climbStairs = (n) => {
return (n <= 2) ? n : climbStairs(n - 1) + climbStairs(n - 2);
}
console.log(climbStairs(n))
//只可以写在函数外面，return以前没计算，return以后不执行！！
//2.没有大括号，默认返回a+b;
const add = (a, b) => a + b; // 自动返回a + b的结果
console.log(add(1, 2)); // 输出3
// 3.有大括号，默认无返回值 () => { } 默认没有返回值，如果需要返回值需要写return
const sayHello = () => { console.log('Hello!'); }; // 没有返回值
const result = sayHello(); // 输出'Hello!'，但result是undefined
const add = (a, b) => { return a + b; }; // 需要显式返回值
console.log(add(1, 2)); // 输出3
dom操作
先拿到dom元素，绑定变量，然后绑定事件，执行！
CSS3的Transform属性
/* 1.rotate函数用于围绕一个中心点旋转元素。它可以接受一个角度值，表示旋转的度数。 */
transform: rotate(angle);
/* angle: 一个角度值，表示旋转的角度。正值表示顺时针旋转，负值表示逆时针旋转。角度单位可以是deg（度）、rad（弧度）、grad（梯度）或turn（圈）。 */
/* 2.origin函数用于确定旋转中心 */
transform-origin: x-axis y-axis;
/* 默认情况下，元素是围绕其中心点旋转的。但你可以通过transform-origin属性来改变旋转的中心点。 */
/* x-axis: 定义旋转中心点的水平位置，可以是left、center、right或者百分比。 */
/* y-axis: 定义旋转中心点的垂直位置，可以是top、center、bottom或者百分比。 */
transform属性可以与其他转换函数结合使用，如translate（移动）、scale（缩放）、skew（倾斜）等，并且可以通过空格分隔来同时应用多个转换。
旋转不会影响元素的布局，也就是说，旋转后的元素不会改变其在文档流中的位置，也不会影响其他元素的位置。
对于3D旋转，可以使用rotateX()、rotateY()和rotateZ()函数来分别围绕x轴、y轴和z轴旋转元素。
正则表达式
//1.判断字符
由26个英文字母组成的字符串：^[A-Za-z]+$
由26个大写英文字母组成的字符串：^[A-Z]+$
由26个小写英文字母组成的字符串：^[a-z]+$
由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
//2.判断数字
数字：^[0-9]*$
质数与斐波那契数列
/*判断素数 */
function judgePrime(n) {--->//写在括号里的是形参，可以不用声明类型
for (let i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true
}
/*兔子数列·递归 */
function Fibonacci(n) {
if (n <= 1) return n
return Fibonacci(n - 1) + Fibonacci(n - 2)
}
-->//或者直接三元运算符
function rabbit(n){
return (n <= 2) ? : rabbit(n-1) + rabbit(n-2);
}
this与复杂的异步传参
//1.回调函数
function sayGoodbye() {
console.log('Goodbye!');
}//定义了一个sayGoodby函数，它在 greet 函数执行完毕后被调用。
function greet(name, call) {
console.log('Hello, ' + name);
call();//回调函数，形参，实际是sayGoodbye
}//定义一个外（主）函数【greet】--->接收参数name和回调函数【名字可以自取】
//回调函数（Callback Function）是一个作为参数传递给另一个函数的函数，这个被传递的函数在某个特定的操作或事件完成后被调用。回调函数允许程序代码在特定时刻执行，而不需要程序员明确地编写调用该函数的代码。
greet('Alice', sayGoodbye);
//2.this与构造函数
function Counter() {
this.sum = 0;
this.count = 0;
}
// 一个构造函数的定义。构造函数用于创建对象
// 通常具有首字母大写的名称，以区分于普通函数。
// 通过使用 new 关键字，你可以创建 Counter 的实例
// var myCounter = new Counter();
Counter.prototype.add = function(array) {
// 这一行定义了 Counter 原型上的 add 方法，它接受一个array作为参数。
array.forEach(function(entry) {
// 这一行使用 forEach 方法遍历传入的array。
// 对于数组中的每个元素（这里称为 entry），都会执行这个匿名函数。
this.sum += entry;
// 这一行尝试将数组元素的值加到 this.sum 上。
// 这里的 'this' 应该指向 Counter 实例，以便我们可以访问和修改它的 sum 属性。
++this.count;
// 这一行增加 this.count 的值，用来计数处理了多少个元素。
// 同样，这里的 'this' 应该指向 Counter 实例。
}, this); // 注意这里的 'this'，它指向 新的Counter
// 在 forEach 方法的第二个参数中，我们传递了 'this'。
// 这里的 'this' 是在调用 add 方法时的上下文，即 Counter 实例。
// 通过传递 'this' 作为第二个参数，我们确保了在匿名函数内部，'this' 仍然指向 Counter 实例。
};
var obj = new Counter();//Count实例
obj.add([2, 5, 9]);//Count实例
console.log(obj.sum); // 输出 16
console.log(obj.count); // 输出 3
//2.构造函数实例2
function Counter() {
this.count = 0; // 初始化计数器
}
// 在 Counter.prototype 上定义 add 方法
Counter.prototype.add = function(amount) {
this.count += amount; // 增加计数器的值
};
// 创建 Counter 的实例
var myCounter = new Counter();
// 使用 add 方法
myCounter.add(5); // 增加计数器的值
console.log(myCounter.count); // 输出 5
myCounter.add(3); // 再次增加计数器的值
console.log(myCounter.count); // 输出 8