备赛web蓝桥杯①

数组常用函数

        //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)) { // 检查数组是否包含元素3console.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里最后一个元素，并返回它给popValconsole.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) // 2console.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里第一一个元素，并返回它给shiftValconsole.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) // 0console.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)) // 1console.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, Cherryconst 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 --- 角标为3console.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，例如数学运算。

1. NaN 与任何值（包括它自己）都不相等，即 NaN === NaN 的结果是 false。
2. NaN 的类型是 “number”，即 typeof NaN 返回 "number"。
   要检查一个值是否为 NaN，可以使用全局函数 isNaN()，但更推荐使用 Number.isNaN()，
   因为 isNaN() 会尝试将参数转换为数字，而 Number.isNaN() 不会，这使得 Number.isNaN() 的行为更可预测。

栈

栈（Stack）是一种线性数据结构，它遵循特定的访问原则，即后进先出（Last In First Out, LIFO）。这意味着最后压入栈中的元素将会是第一个被弹出栈的元素。栈的操作主要包含以下几种：

1. 压栈（Push）：在栈顶添加一个元素。
2. 出栈（Pop）：移除栈顶元素，并返回它。
3. 查看栈顶元素（Peek/Top）：返回栈顶元素，但不移除它。
4. 检查栈是否为空（IsEmpty）：判断栈内是否含有元素。
5. 获取栈的大小（Size）：返回栈中元素的数量。
   栈的运用非常广泛，以下是一些常见的应用场景：

• 程序调用的存储：在程序执行时，每当一个函数被调用，它的返回地址以及局部变量就会被存储在一个栈帧中，当函数执行完毕后，栈帧会被弹出，程序继续执行之前的代码。
• 表达式求值：编译器在解析和计算表达式时，比如将中缀表达式转换为后缀表达式，或者直接计算后缀表达式，都会使用栈来存储操作数和操作符。
• 递归算法：递归函数在执行时，每递归一次就会在调用栈上添加一个新的栈帧，用于存储该次调用的状态信息。
• 后退/撤销操作：在文本编辑器或浏览器中，后退操作可以通过将之前的操作压入栈来实现，用户点击后退时，就可以从栈中弹出操作进行撤销。
• 深度优先搜索（DFS）：在图和树的遍历算法中，栈可以用来存储接下来要访问的节点。
  括号匹配：在编译器中，检查代码中的括号是否匹配时，可以使用栈来存储左括号，每当遇到右括号时，就从栈中弹出一个左括号进行匹配。
• 函数调用栈：操作系统在执行程序时，会使用栈来管理函数调用，这被称为调用栈。
• 内存分配：在许多系统中，栈被用来动态地分配和释放内存。
• 浏览器历史记录：浏览器用来存储用户访问过的网页历史，前进和后退操作实际上是在这个历史栈上操作。

队

队列（Queue）也是一种线性数据结构，它遵循先进先出（First In First Out, FIFO）的原则。这意味着队列中最早进入的元素将会是最先被移除的元素。队列的操作主要包括以下几种：

入队（Enqueue）：在队列的末尾添加一个元素。
出队（Dequeue）：移除队列的第一个元素，并返回它。
查看队列头部元素（Front/Peek）：返回队列的第一个元素，但不移除它。
检查队列是否为空（IsEmpty）：判断队列内是否含有元素。
获取队列的大小（Size）：返回队列中元素的数量。
队列的运用非常广泛，以下是一些常见的应用场景：

任务调度：操作系统中的任务队列用来存储等待处理的任务，按照任务的到达顺序进行处理。
缓冲处理：在数据传输过程中，如IO操作，队列可以用来平滑处理速度不匹配的设备之间的数据流。
打印任务管理：打印机的打印队列按照文档提交的顺序打印文档。
消息队列：在消息传递系统中，消息队列用来存储和转发消息，确保消息的有序传递。
线程池：在多线程编程中，线程池中的任务队列用来存储待执行的任务。
数据结构中的算法：如广度优先搜索（BFS）算法在图和树的遍历中使用队列来存储接下来要访问的节点。
队列与栈的区别主要在于它们对元素的操作原则不同：

栈 VS 队

1. 操作原则：
   栈是后进先出（LIFO），最后进入的元素最先被移除。
   队列是先进先出（FIFO），最先进入的元素最先被移除。
2. 功能用途：
   栈通常用于那些需要后进先出特性的场景，如递归、后退操作、表达式求值等。
   队列通常用于那些需要先进先出特性的场景，如任务调度、缓冲处理、消息队列等。
3. 数据访问：
   栈只允许在一端进行插入和删除操作，即栈顶。
   队列允许在一端插入元素（队尾），在另一端删除元素（队头）。

数组元素转换为字符串【场景】

1. 将数组元素转换为字符串：当你需要将数组中的所有元素转换成一个单一的字符串，并且元素之间需要用特定的分隔符连接时。
2. 数据格式化：在将数据输出到控制台、显示在网页上或者发送到服务器之前，你可能需要将数组格式化为一个字符串。
3. 生成CSV数据：如果你需要生成CSV（逗号分隔值）格式的数据，join() 方法可以用来将数组元素转换成一个CSV格式的字符串。
4. 拼接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.charAtvar 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')) // trueconsole.log(str.startsWith('Excuse')) //  trueconsole.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

1. 都是函数执行时的上下文相关的内部对象。
2. 它们都可以在函数内部使用，而不需要显式地作为参数传递。
   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是undefinedconst 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.构造函数实例2function 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