From c70488fbba8802f44cbde4f884485533771ad6a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E6=96=B9=E6=97=AD?= <3402439200@qq.com>
Date: Sun, 30 Nov 2025 20:21:17 +0800
Subject: [PATCH] 1

---
 ...4\350\256\260+\347\273\203\344\271\240.md" | 73 +++++++++++++++++++
 ...4\350\256\260+\347\273\203\344\271\240.md" | 49 +++++++++++++
 ...4\350\256\260+\347\273\203\344\271\240.md" | 41 +++++++++++
 ...4\350\256\260+\347\273\203\344\271\240.md" | 23 ++++++
 4 files changed, 186 insertions(+)
 create mode 100644 "\351\231\210\346\226\271\346\227\255/20251124-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
 create mode 100644 "\351\231\210\346\226\271\346\227\255/20251126-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
 create mode 100644 "\351\231\210\346\226\271\346\227\255/20251127-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
 create mode 100644 "\351\231\210\346\226\271\346\227\255/20251128-\347\254\224\350\256\260+\347\273\203\344\271\240.md"

diff --git "a/\351\231\210\346\226\271\346\227\255/20251124-\347\254\224\350\256\260+\347\273\203\344\271\240.md" "b/\351\231\210\346\226\271\346\227\255/20251124-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
new file mode 100644
index 00000000..20c07d82
--- /dev/null
+++ "b/\351\231\210\346\226\271\346\227\255/20251124-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
@@ -0,0 +1,73 @@
+# 笔记
+
+## 数组与集合
+# JS 数组对象方法速查表
+| 方法名 | 说明 | 简单代码实现 |
+| ------ | ---- | ---- |
+| `push()` | 向数组末尾添加一个/多个元素，返回新数组长度（改变原数组） | ```js const arr = [1,2]; const len = arr.push(3,4); // len=4, arr=[1,2,3,4] ``` |
+| `pop()` | 删除数组最后一个元素，返回被删除的元素（改变原数组） | ```js const arr = [1,2,3]; const del = arr.pop(); // del=3, arr=[1,2] ``` |
+| `unshift()` | 向数组开头添加一个/多个元素，返回新数组长度（改变原数组） | ```js const arr = [2,3]; const len = arr.unshift(0,1); // len=4, arr=[0,1,2,3] ``` |
+| `shift()` | 删除数组第一个元素，返回被删除的元素（改变原数组） | ```js const arr = [0,1,2]; const del = arr.shift(); // del=0, arr=[1,2] ``` |
+| `splice()` | 增删改数组元素，返回被删除元素组成的数组（改变原数组）<br>参数：起始索引、删除个数、新增元素 | ```js const arr = [1,2,3]; // 删除：从索引1删1个 const del = arr.splice(1,1); // del=[2], arr=[1,3] // 新增：索引1处加2、4 arr.splice(1,0,2,4); // arr=[1,2,4,3] ``` |
+| `slice()` | 截取数组片段，返回新数组（不改变原数组）<br>参数：起始索引（含）、结束索引（不含，可选） | ```js const arr = [1,2,3,4]; const newArr = arr.slice(1,3); // newArr=[2,3], arr不变 ``` |
+| `forEach()` | 遍历数组，对每个元素执行回调（无返回值） | ```js const arr = [1,2,3]; arr.forEach((item, idx) => { console.log(item, idx); // 输出1 0、2 1、3 2 }); ``` |
+| `map()` | 遍历数组，返回由回调返回值组成的新数组（不改变原数组） | ```js const arr = [1,2,3]; const newArr = arr.map(item => item * 2); // newArr=[2,4,6], arr不变 ``` |
+| `filter()` | 过滤数组，返回满足回调条件的元素组成的新数组（不改变原数组） | ```js const arr = [1,2,3,4]; const newArr = arr.filter(item => item % 2 === 0); // newArr=[2,4] ``` |
+| `find()` | 遍历数组，返回第一个满足回调条件的元素（不改变原数组，无则返回`undefined`） | ```js const arr = [1,2,3,4]; const res = arr.find(item => item > 2); // res=3 ``` |
+| `findIndex()` | 遍历数组，返回第一个满足回调条件的元素索引（不改变原数组，无则返回`-1`） | ```js const arr = [1,2,3,4]; const idx = arr.findIndex(item => item > 2); // idx=2 ``` |
+| `some()` | 判断数组是否有至少一个元素满足回调条件，返回布尔值（不改变原数组） | ```js const arr = [1,2,3]; const has = arr.some(item => item > 2); // has=true ``` |
+| `every()` | 判断数组是否所有元素都满足回调条件，返回布尔值（不改变原数组） | ```js const arr = [1,2,3]; const all = arr.every(item => item > 0); // all=true ``` |
+| `join()` | 将数组元素按指定分隔符拼接为字符串，返回字符串（不改变原数组，默认分隔符为`,`） | ```js const arr = [1,2,3]; const str1 = arr.join(); // str1="1,2,3" const str2 = arr.join('-'); // str2="1-2-3" ``` |
+| `concat()` | 合并两个/多个数组，返回新数组（不改变原数组） | ```js const arr1 = [1,2]; const arr2 = [3,4]; const newArr = arr1.concat(arr2); // newArr=[1,2,3,4] ``` |
+| `flat()` | 扁平化数组，返回新数组（不改变原数组）<br>参数：扁平化深度（默认1，`Infinity`表示完全扁平化） | ```js const arr = [1,[2,[3]]]; const flat1 = arr.flat(); // flat1=[1,2,[3]] const flatAll = arr.flat(Infinity); // flatAll=[1,2,3] ``` |
+| `flatMap()` | 先执行`map`再执行`flat(1)`，返回新数组（不改变原数组） | ```js const arr = [1,2]; const newArr = arr.flatMap(item => [item, item*2]); // newArr=[1,2,2,4] ``` |
+| `sort()` | 对数组元素排序，返回排序后的原数组（改变原数组，默认按字符串Unicode排序） | ```js const arr = [3,1,2]; // 数字升序 arr.sort((a,b) => a - b); // arr=[1,2,3] // 数字降序 arr.sort((a,b) => b - a); // arr=[3,2,1] ``` |
+| `reverse()` | 反转数组元素顺序，返回反转后的原数组（改变原数组） | ```js const arr = [1,2,3]; arr.reverse(); // arr=[3,2,1] ``` |
+| `reduce()` | 从左到右遍历数组，累计回调返回值，返回最终累计结果（不改变原数组）<br>参数：回调函数、初始值（可选） | ```js const arr = [1,2,3]; // 求和（无初始值） const sum = arr.reduce((acc, cur) => acc + cur); // sum=6 // 求和（有初始值2） const sum2 = arr.reduce((acc, cur) => acc + cur, 2); // sum2=8 ``` |
+| `indexOf()` | 查找元素在数组中首次出现的索引（不改变原数组，无则返回`-1`）<br>参数：目标元素、起始索引（可选） | ```js const arr = [1,2,3,2]; const idx1 = arr.indexOf(2); // idx1=1 const idx2 = arr.indexOf(2, 2); // idx2=3 ``` |
+| `includes()` | 判断数组是否包含目标元素，返回布尔值（不改变原数组）<br>参数：目标元素、起始索引（可选） | ```js const arr = [1,2,3]; const has = arr.includes(2); // has=true const has2 = arr.includes(2, 2); // has2=false ``` |
+| `fill()` | 用指定值填充数组，返回填充后的原数组（改变原数组）<br>参数：填充值、起始索引（可选）、结束索引（可选，不含） | ```js const arr = [1,2,3]; arr.fill(0); // arr=[0,0,0] arr.fill(9, 1, 2); // arr=[0,9,0] ``` |
+| `Array.from()` | 将类数组/可迭代对象转为数组，返回新数组（静态方法） | ```js // 类数组 const likeArr = {0:1, 1:2, length:2}; const arr1 = Array.from(likeArr); // arr1=[1,2] // 字符串 const str = "abc"; const arr2 = Array.from(str); // arr2=['a','b','c'] ``` |
+| `Array.of()` | 创建包含指定元素的数组，返回新数组（静态方法，解决`Array()`的歧义） | ```js const arr1 = Array.of(1,2,3); // arr1=[1,2,3] const arr2 = Array.of(5); // arr2=[5]（区别于Array(5)返回长度5的空数组） ``` |
+| `Array.isArray()` | 判断参数是否为数组，返回布尔值（静态方法） | ```js const res1 = Array.isArray([1,2]); // res1=true const res2 = Array.isArray("abc"); // res2=false ``` |
+
+## Map集合
+| 方法名/属性 | 说明 | 简单代码实现 |
+| ------ | ---- | ---- |
+| `new Map()` | 创建空Map实例（或传入可迭代对象初始化，如数组、另一个Map） | ```js // 空Map const map1 = new Map(); // 初始化键值对（数组形式：[[key1, val1], [key2, val2]]） const map2 = new Map([['name', '张三'], [1, '数字']]); // 从另一个Map初始化 const map3 = new Map(map2); ``` |
+| `size`（属性） | 返回Map中键值对的数量（只读属性，非方法） | ```js const map = new Map([['a', 1]]); console.log(map.size); // 输出1 ``` |
+| `set(key, value)` | 新增/修改键值对（key存在则更新值，不存在则新增），返回当前Map实例（可链式调用） | ```js const map = new Map(); // 新增 map.set('age', 20); // 链式新增 map.set('gender', '男').set('city', '北京'); // 更新 map.set('age', 22); console.log(map); // Map(3) { 'age' => 22, 'gender' => '男', 'city' => '北京' } ``` |
+| `get(key)` | 获取指定key对应的value，key不存在则返回`undefined` | ```js const map = new Map([['name', '李四']]); const name = map.get('name'); // name='李四' const addr = map.get('addr'); // addr=undefined ``` |
+| `has(key)` | 判断Map是否包含指定key，返回布尔值 | ```js const map = new Map([['id', 1001]]); console.log(map.has('id')); // true console.log(map.has('phone')); // false ``` |
+| `delete(key)` | 删除指定key对应的键值对，删除成功返回`true`，key不存在返回`false` | ```js const map = new Map([['name', '王五']]); const res1 = map.delete('name'); // res1=true, map变为空 const res2 = map.delete('name'); // res2=false ``` |
+| `clear()` | 清空Map中所有键值对，无返回值（改变原Map） | ```js const map = new Map([['a', 1], ['b', 2]]); map.clear(); console.log(map.size); // 0 ``` |
+| `forEach(callback)` | 遍历Map，对每个键值对执行回调（无返回值）<br>回调参数：value、key、当前Map | ```js const map = new Map([['name', '赵六'], ['age', 25]]); map.forEach((value, key, map) => { console.log(`${key}: ${value}`); // 输出name: 赵六、age: 25 }); ``` |
+| `keys()` | 返回Map中所有key的迭代器对象，可通过`for...of`遍历 | ```js const map = new Map([['a', 1], ['b', 2]]); const keys = map.keys(); for (const key of keys) { console.log(key); // 输出a、b } ``` |
+| `values()` | 返回Map中所有value的迭代器对象，可通过`for...of`遍历 | ```js const map = new Map([['a', 1], ['b', 2]]); const values = map.values(); for (const val of values) { console.log(val); // 输出1、2 } ``` |
+| `entries()` | 返回Map中所有`[key, value]`的迭代器对象（默认遍历Map时使用此迭代器） | ```js const map = new Map([['a', 1], ['b', 2]]); const entries = map.entries(); for (const [key, val] of entries) { console.log(key, val); // 输出a 1、b 2 } // 简写（直接遍历Map） for (const [key, val] of map) { console.log(key, val); // 同上 } ``` |
+| `Map.from(iterable)` | （ES2022+静态方法）将可迭代对象（如数组、Set、Map）转为Map，返回新Map | ```js // 数组转Map const arr = [['x', 10], ['y', 20]]; const map1 = Map.from(arr); // Map(2) { 'x' => 10, 'y' => 20 } // Set转Map（Set元素需为[key, value]数组） const set = new Set([['a', 1]]); const map2 = Map.from(set); // Map(1) { 'a' => 1 } ``` |
+| `Map.of(...entries)` | （ES2022+静态方法）创建包含指定键值对的Map，返回新Map（直接传入key-value参数，无需嵌套数组） | ```js const map = Map.of('name', '孙七', 'age', 30); console.log(map); // Map(2) { 'name' => '孙七', 'age' => 30 } ``` |
+| `Map.prototype[Symbol.iterator]` | 迭代器方法，返回`entries()`迭代器（支持`for...of`直接遍历Map的核心） | ```js const map = new Map([['a', 1]]); const iter = map[Symbol.iterator](); console.log(iter.next().value); // ['a', 1] ``` |
+
+##  set集合速查表
+| 方法名/属性 | 说明 | 简单代码实现 |
+| ------ | ---- | ---- |
+| `new Set()` | 创建空Set实例（或传入可迭代对象初始化，自动去重重复元素） | ```js // 空Set const set1 = new Set(); // 传入数组初始化（自动去重） const set2 = new Set([1,2,2,3]); // set2 = Set(3) {1,2,3} // 传入字符串初始化（按字符去重） const set3 = new Set("aabcc"); // set3 = Set(3) {'a','b','c'} ``` |
+| `size`（属性） | 返回Set中元素的个数（只读属性，非方法） | ```js const set = new Set([1,2,3]); console.log(set.size); // 输出3 ``` |
+| `add(value)` | 向Set中添加元素（重复元素会被忽略），返回当前Set实例（可链式调用） | ```js const set = new Set(); // 单个添加 set.add(1); // 链式添加 set.add(2).add(3).add(2); // 重复添加2被忽略 console.log(set); // Set(3) {1,2,3} ``` |
+| `delete(value)` | 从Set中删除指定元素，删除成功返回`true`，元素不存在返回`false` | ```js const set = new Set([1,2,3]); const res1 = set.delete(2); // res1=true, set变为{1,3} const res2 = set.delete(4); // res2=false ``` |
+| `has(value)` | 判断Set是否包含指定元素，返回布尔值 | ```js const set = new Set([1,2,3]); console.log(set.has(2)); // true console.log(set.has(4)); // false ``` |
+| `clear()` | 清空Set中所有元素，无返回值（改变原Set） | ```js const set = new Set([1,2,3]); set.clear(); console.log(set.size); // 0 ``` |
+| `forEach(callback)` | 遍历Set，对每个元素执行回调（无返回值）<br>回调参数：value、key（与value相同）、当前Set | ```js const set = new Set([1,2,3]); set.forEach((value, key, set) => { console.log(`${key}: ${value}`); // 输出1:1、2:2、3:3（key=value） }); ``` |
+| `keys()` | 返回Set中所有元素的迭代器对象（与`values()`效果一致，因Set无键值区分） | ```js const set = new Set([1,2,3]); const keys = set.keys(); for (const key of keys) { console.log(key); // 输出1、2、3 } ``` |
+| `values()` | 返回Set中所有元素的迭代器对象（Set默认迭代器） | ```js const set = new Set([1,2,3]); const values = set.values(); for (const val of values) { console.log(val); // 输出1、2、3 } ``` |
+| `entries()` | 返回Set中所有`[value, value]`的迭代器对象（因Set无键值区分，键和值相同） | ```js const set = new Set([1,2,3]); const entries = set.entries(); for (const [key, val] of entries) { console.log(key, val); // 输出1 1、2 2、3 3 } ``` |
+| `for...of` 遍历 | 直接遍历Set元素（依托`Symbol.iterator`迭代器，等价于遍历`values()`） | ```js const set = new Set([1,2,3]); for (const val of set) { console.log(val); // 输出1、2、3 } ``` |
+| `Set.from(iterable)` | （ES2022+静态方法）将可迭代对象（如数组、Set、字符串）转为Set，自动去重 | ```js // 数组转Set（去重） const arr = [1,2,2,3]; const set1 = Set.from(arr); // Set(3) {1,2,3} // 字符串转Set（按字符去重） const str = "aabbcc"; const set2 = Set.from(str); // Set(3) {'a','b','c'} ``` |
+| `Set.of(...values)` | （ES2022+静态方法）创建包含指定元素的Set，自动去重重复参数 | ```js const set = Set.of(1,2,2,3,4); console.log(set); // Set(4) {1,2,3,4} ``` |
+| `Set.prototype[Symbol.iterator]` | 迭代器方法，返回`values()`迭代器（支持`for...of`直接遍历Set的核心） | ```js const set = new Set([1,2]); const iter = set[Symbol.iterator](); console.log(iter.next().value); // 1 console.log(iter.next().value); // 2 ``` |
+| 转数组技巧 | Set无原生转数组方法，可通过`Array.from()`或扩展运算符`[...set]`实现 | ```js const set = new Set([1,2,3]); // 方法1：Array.from() const arr1 = Array.from(set); // [1,2,3] // 方法2：扩展运算符 const arr2 = [...set]; // [1,2,3] ``` |
+
+
+## 作业 
+
diff --git "a/\351\231\210\346\226\271\346\227\255/20251126-\347\254\224\350\256\260+\347\273\203\344\271\240.md" "b/\351\231\210\346\226\271\346\227\255/20251126-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
new file mode 100644
index 00000000..a8de1f1c
--- /dev/null
+++ "b/\351\231\210\346\226\271\346\227\255/20251126-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
@@ -0,0 +1,49 @@
+# 笔记
+
+### 正则表达式
+
+- 正则表达式是一个用简单语法来描述的字符串模式，通常用于替换验证文本内容
+
+## 正则表达式简单速查表
+
+## 一、基础语法
+
+| 类型       | 符号           | 说明                           | 示例                       |
+| ---------- | -------------- | ------------------------------ | -------------------------- |
+| 字面量     | 直接字符       | 匹配自身（字母 / 数字 / 符号） | `/abc/` 匹配 "abc"         |
+| 转义字符   | `\`            | 匹配特殊字符（`.`/`*`等）      | `/\./` 匹配 "."            |
+| 字符类     | `[abc]`        | 匹配任意一个指定字符           | `/[abc]/` 匹配 "a"/"b"/"c" |
+| 反向字符类 | `[^abc]`       | 匹配非指定字符                 | `/[^abc]/` 匹配 "d"/"1"    |
+| 范围匹配   | `[a-z0-9]`     | 匹配区间内字符（简写）         | `/[0-9]/` 匹配数字         |
+| 预定义类   | `\d`/`\w`/`\s` | 数字 / 字母下划线 / 空白符     | `/\d/` 等价于 `[0-9]`      |
+| 边界匹配   | `^`/`$`        | 行首 / 行尾                    | `/^abc$/` 匹配整行 "abc"   |
+| 量词       | `*`/`+`/`?`    | 0 + 次 / 1 + 次 / 0-1 次       | `/a*/` 匹配 ""/"a"/"aa"    |
+| 精确量词   | `{n}`/`{n,}`   | 恰好 n 次 / 至少 n 次          | `/a{2}/` 匹配 "aa"         |
+
+## 二、常用方法
+
+| 方法           | 所属对象 | 功能                                | 示例                                              |
+| -------------- | -------- | ----------------------------------- | ------------------------------------------------- |
+| `test()`       | RegExp   | 验证字符串是否匹配，返回布尔值      | `/\d+/.test("123")` → `true`                      |
+| `match()`      | String   | 匹配结果存入数组（无匹配返回 null） | "abc123".match(/\d+/) → `["123"]`                 |
+| `replace()`    | String   | 替换匹配内容                        | "abc".replace(/a/, "x") → "xbc"                   |
+| `replaceAll()` | String   | 替换所有匹配（需加`g`修饰符）       | "aaa".replaceAll(/a/g, "b") → "bbb"               |
+| `exec()`       | RegExp   | 逐次匹配（支持分组捕获）            | `/(\d)([a-z])/.exec("1a2b")` → `["1a", "1", "a"]` |
+
+## 三、修饰符
+
+| 修饰符 | 说明                            | 示例                                |
+| ------ | ------------------------------- | ----------------------------------- |
+| `i`    | 忽略大小写                      | `/abc/i` 匹配 "ABC"/"abc"           |
+| `g`    | 全局匹配（不终止于第一个匹配）  | "aaa".match(/a/g) → `["a","a","a"]` |
+| `m`    | 多行匹配（`^`/`$`匹配行首行尾） | `/^a/m` 匹配 "a\nabc" 中第一行 "a"  |
+
+## 四、实用示例（直接复用）
+
+| 场景       | 正则表达式                      | 说明                          |
+| ---------- | ------------------------------- | ----------------------------- |
+| 手机号验证 | `/^1[3-9]\d{9}$/`               | 中国大陆手机号（11 位）       |
+| 邮箱验证   | `/^\w+@[a-z0-9]+\.[a-z]{2,}$/i` | 简单邮箱格式（含域名后缀）    |
+| 提取数字   | `/\d+/g`                        | 匹配字符串中所有数字          |
+| 去除空格   | `/\s+/g`                        | 替换所有空白符（空格 / 换行） |
+| 匹配中文   | `/[\u4e00-\u9fa5]/g`            | 匹配中文字符                  |
\ No newline at end of file
diff --git "a/\351\231\210\346\226\271\346\227\255/20251127-\347\254\224\350\256\260+\347\273\203\344\271\240.md" "b/\351\231\210\346\226\271\346\227\255/20251127-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
new file mode 100644
index 00000000..2f6b29d7
--- /dev/null
+++ "b/\351\231\210\346\226\271\346\227\255/20251127-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
@@ -0,0 +1,41 @@
+# 笔记
+
+## 异常处理
+
+
+
+## 核心语法：try-catch (-finally)
+
+### 1. 基础格式（捕获异常）
+
+```js
+try {
+  // 可能发生错误的代码（如：运算、接口请求、DOM操作）
+} catch (error) {
+  // 错误发生时执行：处理异常（如：提示用户、打印日志）
+}
+```
+
+### 2. 带 finally 格式（无论是否出错都执行)
+
+```js
+try {
+  // 可能出错的代码
+} catch (error) {
+  // 处理异常
+} finally {
+  // 必执行代码（如：关闭弹窗、释放资源）
+}
+```
+
+### 3. 主动抛出异常（throw）
+
+```js
+// 主动触发异常（可抛字符串、Error对象等，推荐Error）
+throw new Error("自定义错误信息"); // 推荐：带堆栈信息，便于调试
+// 或简化（不推荐，无堆栈）：throw "错误信息";
+```
+
+
+## 
+
diff --git "a/\351\231\210\346\226\271\346\227\255/20251128-\347\254\224\350\256\260+\347\273\203\344\271\240.md" "b/\351\231\210\346\226\271\346\227\255/20251128-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
new file mode 100644
index 00000000..709b28ce
--- /dev/null
+++ "b/\351\231\210\346\226\271\346\227\255/20251128-\347\254\224\350\256\260+\347\273\203\344\271\240.md"
@@ -0,0 +1,23 @@
+# 笔记
+
+## 一、焦点事件（元素获取 / 失去焦点）
+
+| 事件名     | 说明                   | 语法示例（2 种常用绑定）                                |
+| ---------- | ---------------------- | ------------------------------------------------------- |
+| `focus`    | 元素获取焦点（无冒泡） | 1. 标签属性：``                                         |
+|            |                        | 2. JS 绑定：`input.addEventListener('focus', () => {})` |
+| `blur`     | 元素失去焦点（无冒泡） | 1. 标签属性：``                                         |
+|            |                        | 2. JS 绑定：`input.addEventListener('blur', () => {})`  |
+| `focusin`  | 获取焦点（支持冒泡）   | `parent.addEventListener('focusin', () => {})`          |
+| `focusout` | 失去焦点（支持冒泡）   | `parent.addEventListener('focusout', () => {})`         |
+
+## 二、表单事件（表单交互相关）
+
+| 事件名                                           | 说明                            | 语法示例 |
+| ------------------------------------------------ | ------------------------------- | -------- |
+| `submit`                                         | 表单提交（点击提交按钮 / 回车） | ```js    |
+| form.addEventListener('submit', (e) => {         |                                 |          |
+| e.preventDefault (); // 阻止默认提交行为（必写） |                                 |          |
+| // 表单验证、数据提交逻辑                        |                                 |          |
+| });                                              |                                 |          |
+
-- 
Gitee