diff --git "a/31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\345\255\227\347\254\246\344\270\262\345\222\214\346\225\260\347\273\204.md" "b/31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\345\255\227\347\254\246\344\270\262\345\222\214\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..564c86ff8df14bb28c33c5d1d70d93b393087959
--- /dev/null
+++ "b/31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\345\255\227\347\254\246\344\270\262\345\222\214\346\225\260\347\273\204.md"
@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    <script>
+        const arr = [3,2,1,4,5]
+        //将数组中的  元素1  与  元素3 调换位置
+        let temp = arr[2]
+        arr[2] = arr[0]
+        arr[0] = temp
+        console.log(arr);
+    </script>
+    <br>
+    <script>
+    //使用冒泡排序（从大到小）：  [90,65,78,66,48,39,92,73]  
+    //使用数组解构的方法交换变量
+    const arr2 = [90,65,78,66,48,39,92,73]
+    for(let index =0; index <arr2.length-1; index++){
+        for(let j = 0;j<arr2.length-1;j++){
+            if (arr2[j]>arr2[j+1]) {
+                [arr2[j],arr2[j+1]]=[arr2[j+1],arr2[j]]
+            }
+
+​        }
+
+​    }
+​    console.log(arr2);
+​    </script>
+​    <br>
+    <script>
+    var text ='I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.'
+    //将上述字符串去除标点空格后统计有多少个单词
+    var text1= text.replace(/[,.]/g,"")
+    const textarr=text1.split(' ')
+    console.log(textarr);
+    console.log(textarr.length);
+    </script>
+​    <br>
+    <script>
+        const arr = [87,85,74,70,65,59,43]
+        // 1.移除第一个元素87，并在开头添加 元素86
+        arr3.shift();
+        arr3.unshift(86);
+        console.log(arr3);
+        // 2.移除最后一个元素43， 并在末尾添加1
+        arr3.pop();
+        arr3.push(1);
+        console.log(arr3);
+        // 3.在 70 65 之间插入 元素 68
+        arr3.splice(4,0,68);
+        console.log(arr3);
+        // 4.删除元素65
+        arr3.splice(5,1)
+        console.log(arr3);
+        // 5.使用map返回一个新的数组new_arr，要求新数组new_arr比原来数组大2
+        const new_arr= arr3.map((item)=>{
+        return item+2
+        })
+        console.log(new_arr);
+        // 6.筛选数组new_arr返回new_arr1,要求new_arr1: 能被2整除
+        const new_arr1=arr3.map((item)=>{
+            if (item%2==0) {
+                return item   
+            }
+​        
+
+​        })
+​        console.log(new_arr1);
+​    </script>
+</body>
+</html>
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md" "b/31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md"
similarity index 99%
rename from "\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md"
rename to "31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md"
index 1ee15cd288c24f46186c7c792f717ee87a912609..034395e61bfcd0318fc09422c4bfee5c19cd05c3 100644
--- "a/\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md"
+++ "b/31\345\220\264\346\254\243\347\207\225/\344\275\234\344\270\232/\346\225\260\346\215\256\347\261\273\345\236\213\350\275\254\346\215\242.md"
@@ -27,7 +27,7 @@
             d++;
         }
     </script>
-    <br>
+    <br/>
     <script>
         // 3.输入年月，（用数组）
             const month31 = [1,3,5,7,8,10,12]
diff --git "a/\347\254\224\350\256\260/2022-10-16\345\237\272\347\241\200\344\270\216\346\225\260\346\215\256\350\275\254\346\215\242\347\261\273\345\236\213.md" "b/31\345\220\264\346\254\243\347\207\225/\347\254\224\350\256\260/2022-10-16\345\237\272\347\241\200\344\270\216\346\225\260\346\215\256\350\275\254\346\215\242\347\261\273\345\236\213.md"
similarity index 100%
rename from "\347\254\224\350\256\260/2022-10-16\345\237\272\347\241\200\344\270\216\346\225\260\346\215\256\350\275\254\346\215\242\347\261\273\345\236\213.md"
rename to "31\345\220\264\346\254\243\347\207\225/\347\254\224\350\256\260/2022-10-16\345\237\272\347\241\200\344\270\216\346\225\260\346\215\256\350\275\254\346\215\242\347\261\273\345\236\213.md"
diff --git "a/31\345\220\264\346\254\243\347\207\225/\347\254\224\350\256\260/2022-10-18\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204.md" "b/31\345\220\264\346\254\243\347\207\225/\347\254\224\350\256\260/2022-10-18\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..19aac9a17ceb6eb250ba2aabe0497c10c1f2cf97
--- /dev/null
+++ "b/31\345\220\264\346\254\243\347\207\225/\347\254\224\350\256\260/2022-10-18\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204.md"
@@ -0,0 +1,174 @@
+arr.splice 它可以做所有事情：添加，删除和插入元素。
+
+```
+arr.splice(start[, deleteCount, elem1, ..., elemN])
+```
+
+它从索引 `start` 开始修改 `arr`：删除 `deleteCount` 个元素并在当前位置插入 `elem1, ..., elemN`。最后返回被删除的元素所组成的数组
+
+```
+let arr = ["I", "study", "JavaScript"];
+
+arr.splice(1, 1); // 从索引 1 开始删除 1 个元素
+
+alert( arr ); // ["I", "JavaScript"]
+//当只填写了 splice 的 start 参数时，将删除从索引 start 开始的所有数组项
+```
+
+删除了 3 个元素，并用另外两个元素替换它们：
+
+```
+let arr = ["I", "study", "JavaScript", "right", "now"];
+
+// 删除数组的前三项，并使用其他内容代替它们
+arr.splice(0, 3, "Let's", "dance");
+
+alert( arr ) // 现在 ["Let's", "dance", "right", "now"]
+```
+
+`splice` 返回了被删除的元素所组成的数组：
+
+```
+let arr = ["I", "study", "JavaScript", "right", "now"];
+
+// 删除前两个元素
+let removed = arr.splice(0, 2);
+
+alert( removed ); // "I", "study" <-- 被从数组中删除了的元素
+```
+
+将 `deleteCount` 设置为 `0`，`splice` 方法就能够插入元素而不用删除任何元素：
+
+```
+let arr = ["I", "study", "JavaScript"];
+
+// 从索引 2 开始
+// 删除 0 个元素
+// 然后插入 "complex" 和 "language"
+arr.splice(2, 0, "complex", "language");
+
+alert( arr ); // "I", "study", "complex", "language", "JavaScript"
+```
+
+在这里和其他数组方法中，负向索引都是被允许的。它们从数组末尾计算位置，如下所示
+
+```
+let arr = [1, 2, 5];
+
+// 从索引 -1（尾端前一位）
+// 删除 0 个元素，
+// 然后插入 3 和 4
+arr.splice(-1, 0, 3, 4);
+
+alert( arr ); // 1,2,3,4,5
+```
+
+## [转换数组](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23zhuan-huan-shu-zu)
+
+让我们继续学习进行数组转换和重新排序的方法。
+
+### [map](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23map)
+
+[arr.map](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FArray%2Fmap) 方法是最有用和经常使用的方法之一。
+
+它对数组的每个元素都调用函数，并返回结果数组。
+
+语法：
+
+```
+let result = arr.map(function(item, index, array) {
+  // 返回新值而不是当前元素
+})
+```
+
+例如，在这里我们将每个元素转换为它的字符串长度：
+
+```
+let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
+alert(lengths); // 5,7,6
+```
+
+### [sort(fn)](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23sortfn)
+
+[arr.sort](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FArray%2Fsort) 方法对数组进行 **原位（in-place）** 排序，更改元素的顺序。(译注：原位是指在此数组内，而非生成一个新数组。)
+
+它还返回排序后的数组，但是返回值通常会被忽略，因为修改了 `arr` 本身。
+
+语法：
+
+```
+let arr = [ 1, 2, 15 ];
+
+// 该方法重新排列 arr 的内容
+arr.sort();
+
+alert( arr );  // 1, 15, 2
+```
+
+### [reverse](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23reverse)
+
+[arr.reverse](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FArray%2Freverse) 方法用于颠倒 `arr` 中元素的顺序。
+
+例如：
+
+```
+let arr = [1, 2, 3, 4, 5];
+arr.reverse();
+
+alert( arr ); // 5,4,3,2,1
+```
+
+它也会返回颠倒后的数组 `arr`。
+
+### [split 和 join](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23split-he-join)
+
+举一个现实生活场景的例子。我们正在编写一个消息应用程序，并且该人员输入以逗号分隔的接收者列表：`John, Pete, Mary`。但对我们来说，名字数组比单个字符串舒适得多。怎么做才能获得这样的数组呢？
+
+[str.split(delim)](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FString%2Fsplit) 方法可以做到。它通过给定的分隔符 `delim` 将字符串分割成一个数组。
+
+在下面的例子中，我们用“逗号后跟着一个空格”作为分隔符：
+
+```
+let names = 'Bilbo, Gandalf, Nazgul';
+
+let arr = names.split(', ');
+
+for (let name of arr) {
+  alert( `A message to ${name}.` ); // A message to Bilbo（和其他名字）
+}
+```
+
+`split` 方法有一个可选的第二个数字参数 —— 对数组长度的限制。如果提供了，那么额外的元素会被忽略。但实际上它很少使用：
+
+```
+let arr = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);
+
+alert(arr); // Bilbo, Gandalf
+```
+
+### [reduce/reduceRight](https://gitee.com/link?target=https%3A%2F%2Fzh.javascript.info%2Farray-methods%23reducereduceright)
+
+当我们需要遍历一个数组时 —— 我们可以使用 `forEach`，`for` 或 `for..of`。
+
+当我们需要遍历并返回每个元素的数据时 —— 我们可以使用 `map`。
+
+[arr.reduce](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FArray%2Freduce) 方法和 [arr.reduceRight](https://gitee.com/link?target=https%3A%2F%2Fdeveloper.mozilla.org%2Fzh%2Fdocs%2FWeb%2FJavaScript%2FReference%2FGlobal_Objects%2FArray%2FreduceRight) 方法和上面的种类差不多，但稍微复杂一点。它们用于根据数组计算单个值。
+
+语法是：
+
+```
+let value = arr.reduce(function(accumulator, item, index, array) {
+  // ...
+}, [initial]);
+```
+
+该函数一个接一个地应用于所有数组元素，并将其结果“搬运（carry on）”到下一个调用。
+
+参数：
+
+- `accumulator` —— 是上一个函数调用的结果，第一次等于 `initial`（如果提供了 `initial` 的话）。
+- `item` —— 当前的数组元素。
+- `index` —— 当前索引。
+- `arr` —— 数组本身。
+
+应用函数时，上一个函数调用的结果将作为第一个参数传递给下一个函数。
\ No newline at end of file
