diff --git "a/27 \350\265\265\346\265\251\346\225\217/.keep" "b/27 \350\265\265\346\265\251\346\225\217/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/.keep" "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html" "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html"
similarity index 95%
rename from "\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html"
rename to "27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html"
index dfcd758b29b5cb07ed922ea46c6bf403db238d89..b0a3c822e0c7307efbcf42c5e2a82477eaf5cb51 100644
--- "a/\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-13\345\256\232\344\271\211\347\261\273\345\236\213.html"	
@@ -1,83 +1,83 @@
-<!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 type="text/javascript">
-        // 1.   1-100之间偶数相加，求加到几的时候和超过1000：**
-        var a=0; 
-        var b=0;
-        while (a<=100) {
-            if(a%2!=0){
-                a++;
-                continue;
-
-              
-            }else{
-                b+=a;
-                a++;
-            }
-            if(b>=1000){
-                    break;
-                    
-                }
-
-        }
-        console.log(b)
-
-
-        //2.   1-100之间偶数相加，能被7整除的数字不参加累加运算，求和
-        var c=0;
-        var d=0;
-        while (c<=100) {
-            if(c%2!=0 || c%7==0 ){
-                c++;
-                continue;
-            }
-          
-            else{
-          
-                d+=c;
-                c++;
-            }
-            
-          
-        }
-        console.log(d);
-        //3.   求199-2022的润年
-        var year =199;
-
-        while (year<=2022) {
-            if(year%400==0 ){
-                year++;
-             
-            }else if(year%4==0 && year%100!=0){
-                year++;
-            }
-            
-            else{
-                year++;
-                continue;
-            }
-            console.log(year-1)
-        }
-       //4. 输入分数，如果分数在  90-100: A  80-89：B     60-79：C      小于60：D
-	   //考虑分数不合法
-      var score=prompt('请输入分数');
-      if(score>=90&&score<=100){
-        console.log('A')
-      }else if(score>=80&&score<=89){
-        console.log('B ')
-      }else if(score>=60&&score<=79){
-        console.log('C')
-      }else{
-        console.log('D')
-      }
-
-    </script>
-</body>
+<!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 type="text/javascript">
+        // 1.   1-100之间偶数相加，求加到几的时候和超过1000：**
+        var a=0; 
+        var b=0;
+        while (a<=100) {
+            if(a%2!=0){
+                a++;
+                continue;
+
+              
+            }else{
+                b+=a;
+                a++;
+            }
+            if(b>=1000){
+                    break;
+                    
+                }
+
+        }
+        console.log(b)
+
+
+        //2.   1-100之间偶数相加，能被7整除的数字不参加累加运算，求和
+        var c=0;
+        var d=0;
+        while (c<=100) {
+            if(c%2!=0 || c%7==0 ){
+                c++;
+                continue;
+            }
+          
+            else{
+          
+                d+=c;
+                c++;
+            }
+            
+          
+        }
+        console.log(d);
+        //3.   求199-2022的润年
+        var year =199;
+
+        while (year<=2022) {
+            if(year%400==0 ){
+                year++;
+             
+            }else if(year%4==0 && year%100!=0){
+                year++;
+            }
+            
+            else{
+                year++;
+                continue;
+            }
+            console.log(year-1)
+        }
+       //4. 输入分数，如果分数在  90-100: A  80-89：B     60-79：C      小于60：D
+	   //考虑分数不合法
+      var score=prompt('请输入分数');
+      if(score>=90&&score<=100){
+        console.log('A')
+      }else if(score>=80&&score<=89){
+        console.log('B ')
+      }else if(score>=60&&score<=79){
+        console.log('C')
+      }else{
+        console.log('D')
+      }
+
+    </script>
+</body>
 </html>
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html" "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html"
similarity index 96%
rename from "\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html"
rename to "27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html"
index 9386b44d8a173de8c2ad56559e59f64b27fac27e..d0d263a7166a1c222cc51c3db3032155d9844e28 100644
--- "a/\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-14\346\225\260\346\215\256\347\261\273\345\236\213.html"	
@@ -1,53 +1,53 @@
-<!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 type="text/javascript">
-
-
-
-    //    1.将A5F3转成2进制
-    var num='A5F3';
-    var b = parseInt(num,2)
-    document.write(b +'<br>' );
-
-
-    //  2.99乘法表
-    for (let index = 1; index <=9; index++) {
-        var sum='';
-       for (let index1 = 1; index1 <=index; index1++) {
-        sum+=index+'x'+index1+'='+index*index1+' ';
-       }
-       document.write(sum+'<br>');
-    }
-
-
-    // 3.输入年月，（用数组）
-    //   3.1.计算当月有多少天
-    // 3.2.计算还剩多少天
-    var nian=Number(prompt('请输入年份'));
-    var yue =Number(prompt('请输入月份'));
-    if (yue==1||yue==3||yue==7||yue==9||yue==11){
-        alert('31天');
-    }else if (yue==2){
-        if (nian % 4 == 0 && (nian % 100 != 0)){
-            alert('闰年'+"29天");
-        }else if (nian % 400 != 0){
-            alert('闰年'+"29天");
-        }else {
-            alert('平年'+"28天");
-        }
-    }
-    else {
-
-        alert("30天");
-    }
-
-    </script>
-</body>
+<!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 type="text/javascript">
+
+
+
+    //    1.将A5F3转成2进制
+    var num='A5F3';
+    var b = parseInt(num,2)
+    document.write(b +'<br>' );
+
+
+    //  2.99乘法表
+    for (let index = 1; index <=9; index++) {
+        var sum='';
+       for (let index1 = 1; index1 <=index; index1++) {
+        sum+=index+'x'+index1+'='+index*index1+' ';
+       }
+       document.write(sum+'<br>');
+    }
+
+
+    // 3.输入年月，（用数组）
+    //   3.1.计算当月有多少天
+    // 3.2.计算还剩多少天
+    var nian=Number(prompt('请输入年份'));
+    var yue =Number(prompt('请输入月份'));
+    if (yue==1||yue==3||yue==7||yue==9||yue==11){
+        alert('31天');
+    }else if (yue==2){
+        if (nian % 4 == 0 && (nian % 100 != 0)){
+            alert('闰年'+"29天");
+        }else if (nian % 400 != 0){
+            alert('闰年'+"29天");
+        }else {
+            alert('平年'+"28天");
+        }
+    }
+    else {
+
+        alert("30天");
+    }
+
+    </script>
+</body>
 </html>
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html" "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html"
similarity index 97%
rename from "\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html"
rename to "27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html"
index 2309cdc959db63fef4032a75877b4a1ec0f67ac8..c9effee61f61aa774b6df18877329ce430fb1f06 100644
--- "a/\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-17\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.html"	
@@ -1,164 +1,164 @@
-<!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 type="text/javascript">
-                //输入一个整数，如果是1-10，转成大写，否则提示输入错误
-              
-                
-                // str = '一二三四五六七八九十';
-                // var a= parseInt (prompt('请输入一个整数'));
-                //方法一
-                // if (a>0&&a<=10) {
-                //     console.log(str[a-1]);
-                // }else{
-
-                //     console.log('输入错误');
-                // }
-                //方法二
-                // console.log((a>0&&a<=10)?str[a-1]:'输入错误');
-
-
-
-                //题目一
-                // const arr = [3,2,1,4,5]
-                // let temp = arr[2]
-                // arr[2] = arr[0]
-                // arr[0] = temp
-                // 将数组中的  元素1  与  元素3 调换位置
-
-                // const arr = [3,2,1,4,5];
-                // for (let i = 0; i < arr.length-1; i++) {
-
-                //     for (let j = 0; j < arr.length-1-i; j++) {
-                //         if (arr[j]>arr[j+1]) {
-                //         let temp = arr[2]
-                //         arr[2] = arr[0]
-                //         arr[0] = temp
-                //     }
-                        
-                //     }
-                 
-                    
-                // }
-                // console.log(arr);
-
-                //题目二
-                //使用冒泡排序（从大到小）：  [90,65,78,66,48,39,92,73]  使用数组解构的方法交换变量
-                // const arr=[90,65,78,66,48,39,92,73];
-                // for (let i = 0; i < arr.length-1; i++) {
-                //     for (let j = 0; j < arr.length-1-i; j++) {
-                //         if (arr[j]>arr[j+1]) {
-                //             [arr[j],arr[j+1]]=[arr[j+1],arr[j]];
-                //         }
-                //     }
-                // }
-                // console.log(arr);
-
-                //题目三
-                // var str2 =
-                // 'I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.'
-                //将上述字符串去除标点空格后统计有多少个单词
-                // var text ='I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.';
-                // console.log(text.trim())
-                //统计空格
-        // var knum = 0; //计数
-        // var kong = str2.match(/ /g) //筛选
-        // for (i in kong) {
-        //     knum++
-        // }
-        // console.log("空格一共出现" + knum + "次")//空格一共出现11次
-        // var num2 = 0;
-        // // var numbe = str2.match(/\d+/g)
-        // var numbe2 = str2.match(/\d{1}/g) //统计一位数
-        // for (i in numbe2) {
-        //     num2++
-        // }
-        // console.log("数字一共出现" + num2 + "次")//数字一共出现15次
-
-        // //统计字母
-        // var num3 = 0
-        // var zimu2 = str2.match(/[a-zA-Z]/g)
-        // for (i in zimu2) {
-        //     num3++
-        // }
-        // console.log("字母一共出现" + num3 + "次")//字母一共出现23次
-
-        // // 统计其他字符
-        // var num4 = 0;
-        // var qita = str2.match(/[^0-9a-zA-Z ]/g)
-        // for (i in qita) {
-        //     num4++
-        // }
-        // console.log("其他字母出现" + num4 + "次" + "分别为" + qita)//其他字母出现4次分别为@,@,%,#
-
-
-
-
-                //题目四
-                
-                // const arr = [87,85,74,70,65,59,43]
-              
-                
-               
-               
-                const arr = [87,85,74,70,65,59,43];
-                //  // 1.移除第一个元素87，并在开头添加 元素86
-                //  arr.shift();
-                //  arr.unshift(86);
-                //  console.log('1.移除第一个元素87，并在开头添加 元素86',arr);
-                // // 2.移除最后一个元素43， 并在末尾添加1
-                // arr.pop();
-                // arr.push(1);
-                // console.log('移除最后一个元素43， 并在末尾添加1',arr);
-                // // 3.在 70 65 之间插入 元素 68
-                // arr.splice(4,0,68);
-                // console.log('3.在 70 65 之间插入 元素 68',arr);
-                // // 4.删除元素65
-                // Array.prototype.remove = function(val) { 
-                // var index = this.indexOf(val); 
-                // if (index > -1) { 
-                // this.splice(index, 1); 
-                // } 
-                // }       
-                // arr.remove(65);
-                // console.log('4.删除元素65',arr);
-                 // 5.使用map返回一个新的数组new_arr，要求新数组new_arr比原来数组大2
-//                  数组的map用法，
-
-// 语法及定义
-// map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
-
-// 　　　map() 方法按照原始数组元素顺序依次处理元素
-
-// 　　　我的理解就是map首先会创建一个新的数组，其中新数组的每一个元素就是原数组中每一个元素经过咱们设置的给定函数变化后的结果。也就是说对原始数组中的每一项运行给定的函数，然后按原数组的顺序组装成新的数组，该方法也不会改变原始的数组，还产生一个新数组。
-
-// 　　    map()接收两个参数：
-// 　　　　　第一个参数必填，为一个函数，就是上面所说的给定的函数（每一项执行的函数，必写），这个给定的函数又有三个参数，第一个为当前元素的值（必写），第二个参数是当前值的下标索引，第三个为当前元素属于的数组对象（目前觉得没啥用）。
-
-// 　　　　   第二个参数非必填，thisValue，对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。（目前还不会用） https://www.shuzhiduo.com/A/A7zgQKgV54/
-        function add2(x,y,z){
-        console.log(x+"=="+y+'=='+z);
-        return x + 2
-        }
-        var new_arr=arr.map(add2);
-        console.log('5.使用map返回一个新的数组new_arr',new_arr);
-
-         // 6.筛选数组new_arr返回new_arr1,要求new_arr1: 能被2整除
-
-         var new_arr1=[];
-         for (let i = 0; i < new_arr.length; i++) {
-            if (new_arr[i]%2==0) {
-              new_arr1[new_arr1.length]=new_arr[i];
-            }
-            
-         }
-         console.log(new_arr1);
-    </script>
-</body>
+<!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 type="text/javascript">
+                //输入一个整数，如果是1-10，转成大写，否则提示输入错误
+              
+                
+                // str = '一二三四五六七八九十';
+                // var a= parseInt (prompt('请输入一个整数'));
+                //方法一
+                // if (a>0&&a<=10) {
+                //     console.log(str[a-1]);
+                // }else{
+
+                //     console.log('输入错误');
+                // }
+                //方法二
+                // console.log((a>0&&a<=10)?str[a-1]:'输入错误');
+
+
+
+                //题目一
+                // const arr = [3,2,1,4,5]
+                // let temp = arr[2]
+                // arr[2] = arr[0]
+                // arr[0] = temp
+                // 将数组中的  元素1  与  元素3 调换位置
+
+                // const arr = [3,2,1,4,5];
+                // for (let i = 0; i < arr.length-1; i++) {
+
+                //     for (let j = 0; j < arr.length-1-i; j++) {
+                //         if (arr[j]>arr[j+1]) {
+                //         let temp = arr[2]
+                //         arr[2] = arr[0]
+                //         arr[0] = temp
+                //     }
+                        
+                //     }
+                 
+                    
+                // }
+                // console.log(arr);
+
+                //题目二
+                //使用冒泡排序（从大到小）：  [90,65,78,66,48,39,92,73]  使用数组解构的方法交换变量
+                // const arr=[90,65,78,66,48,39,92,73];
+                // for (let i = 0; i < arr.length-1; i++) {
+                //     for (let j = 0; j < arr.length-1-i; j++) {
+                //         if (arr[j]>arr[j+1]) {
+                //             [arr[j],arr[j+1]]=[arr[j+1],arr[j]];
+                //         }
+                //     }
+                // }
+                // console.log(arr);
+
+                //题目三
+                // var str2 =
+                // 'I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.'
+                //将上述字符串去除标点空格后统计有多少个单词
+                // var text ='I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.';
+                // console.log(text.trim())
+                //统计空格
+        // var knum = 0; //计数
+        // var kong = str2.match(/ /g) //筛选
+        // for (i in kong) {
+        //     knum++
+        // }
+        // console.log("空格一共出现" + knum + "次")//空格一共出现11次
+        // var num2 = 0;
+        // // var numbe = str2.match(/\d+/g)
+        // var numbe2 = str2.match(/\d{1}/g) //统计一位数
+        // for (i in numbe2) {
+        //     num2++
+        // }
+        // console.log("数字一共出现" + num2 + "次")//数字一共出现15次
+
+        // //统计字母
+        // var num3 = 0
+        // var zimu2 = str2.match(/[a-zA-Z]/g)
+        // for (i in zimu2) {
+        //     num3++
+        // }
+        // console.log("字母一共出现" + num3 + "次")//字母一共出现23次
+
+        // // 统计其他字符
+        // var num4 = 0;
+        // var qita = str2.match(/[^0-9a-zA-Z ]/g)
+        // for (i in qita) {
+        //     num4++
+        // }
+        // console.log("其他字母出现" + num4 + "次" + "分别为" + qita)//其他字母出现4次分别为@,@,%,#
+
+
+
+
+                //题目四
+                
+                // const arr = [87,85,74,70,65,59,43]
+              
+                
+               
+               
+                const arr = [87,85,74,70,65,59,43];
+                //  // 1.移除第一个元素87，并在开头添加 元素86
+                //  arr.shift();
+                //  arr.unshift(86);
+                //  console.log('1.移除第一个元素87，并在开头添加 元素86',arr);
+                // // 2.移除最后一个元素43， 并在末尾添加1
+                // arr.pop();
+                // arr.push(1);
+                // console.log('移除最后一个元素43， 并在末尾添加1',arr);
+                // // 3.在 70 65 之间插入 元素 68
+                // arr.splice(4,0,68);
+                // console.log('3.在 70 65 之间插入 元素 68',arr);
+                // // 4.删除元素65
+                // Array.prototype.remove = function(val) { 
+                // var index = this.indexOf(val); 
+                // if (index > -1) { 
+                // this.splice(index, 1); 
+                // } 
+                // }       
+                // arr.remove(65);
+                // console.log('4.删除元素65',arr);
+                 // 5.使用map返回一个新的数组new_arr，要求新数组new_arr比原来数组大2
+//                  数组的map用法，
+
+// 语法及定义
+// map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
+
+// 　　　map() 方法按照原始数组元素顺序依次处理元素
+
+// 　　　我的理解就是map首先会创建一个新的数组，其中新数组的每一个元素就是原数组中每一个元素经过咱们设置的给定函数变化后的结果。也就是说对原始数组中的每一项运行给定的函数，然后按原数组的顺序组装成新的数组，该方法也不会改变原始的数组，还产生一个新数组。
+
+// 　　    map()接收两个参数：
+// 　　　　　第一个参数必填，为一个函数，就是上面所说的给定的函数（每一项执行的函数，必写），这个给定的函数又有三个参数，第一个为当前元素的值（必写），第二个参数是当前值的下标索引，第三个为当前元素属于的数组对象（目前觉得没啥用）。
+
+// 　　　　   第二个参数非必填，thisValue，对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。（目前还不会用） https://www.shuzhiduo.com/A/A7zgQKgV54/
+        function add2(x,y,z){
+        console.log(x+"=="+y+'=='+z);
+        return x + 2
+        }
+        var new_arr=arr.map(add2);
+        console.log('5.使用map返回一个新的数组new_arr',new_arr);
+
+         // 6.筛选数组new_arr返回new_arr1,要求new_arr1: 能被2整除
+
+         var new_arr1=[];
+         for (let i = 0; i < new_arr.length; i++) {
+            if (new_arr[i]%2==0) {
+              new_arr1[new_arr1.length]=new_arr[i];
+            }
+            
+         }
+         console.log(new_arr1);
+    </script>
+</body>
 </html>
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html" "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html"
similarity index 95%
rename from "\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html"
rename to "27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html"
index a679d0c61d13cc5a4d0f17c017d995ec8b846ee8..9676e657dd5f5bb1e788690f3d05f263fcf8a164 100644
--- "a/\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\344\275\234\344\270\232/10-22\345\207\275\346\225\260.html"	
@@ -1,71 +1,71 @@
-<!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 type="text/javascript">
-
-    //    var num  =parseInt (prompt("请输入一个数"));
-    //    匿名函数表达式
-    //  function name(num) {
-    //     var res=1;//定义积
-    //     for (let i = 1; i <=num; i++) {
-    //         res*=i;
-    //     }
-    //     return res;
-    // }
-    // var res=name(num);
-    // console.log(res);
-    function fn() {
-        //arguments:只有长度，只能找到下标和元素
-        console.log(arguments);
-    }
-
-
-
-    fn(1,2,3,5,6,7,8,9,0)
-    //1.将数组map，filter，reduce，every改写成箭头函数形式
-
-    const arr = [1, 2, 3, 4, 5, 6]
-
-
-
-    const arr1 = arr.map(
-    function (element) {
-        return element + 1
-    }
-)
- const new_arr = arr.filter(
-            function (e){
-                return e%2==0  //true：返回 false：不符合条件=>过滤
-            }
-        )
-
- var sum = arr.reduce(
-            function (v1,v2){
-                return v1*v2
-            }
-        )
-
-var isMatch = arr.every(
-            function (e){
-                return e>1
-            }
-        )
-        // 使用箭头函数实现
-        let result1 = arr.map(element => element + 2);
-let result2 = arr.filter(e=>  e%2==0);
-let result4 =arr.reduce((v1,v2) => v1*v2);
-let result3 = arr.every(e=> e>0);
-console.log(result2);
-console.log(result3);
-console.log(result1);
-console.log(result4);
-    </script>
-    
-</body>
+<!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 type="text/javascript">
+
+    //    var num  =parseInt (prompt("请输入一个数"));
+    //    匿名函数表达式
+    //  function name(num) {
+    //     var res=1;//定义积
+    //     for (let i = 1; i <=num; i++) {
+    //         res*=i;
+    //     }
+    //     return res;
+    // }
+    // var res=name(num);
+    // console.log(res);
+    function fn() {
+        //arguments:只有长度，只能找到下标和元素
+        console.log(arguments);
+    }
+
+
+
+    fn(1,2,3,5,6,7,8,9,0)
+    //1.将数组map，filter，reduce，every改写成箭头函数形式
+
+    const arr = [1, 2, 3, 4, 5, 6]
+
+
+
+    const arr1 = arr.map(
+    function (element) {
+        return element + 1
+    }
+)
+ const new_arr = arr.filter(
+            function (e){
+                return e%2==0  //true：返回 false：不符合条件=>过滤
+            }
+        )
+
+ var sum = arr.reduce(
+            function (v1,v2){
+                return v1*v2
+            }
+        )
+
+var isMatch = arr.every(
+            function (e){
+                return e>1
+            }
+        )
+        // 使用箭头函数实现
+        let result1 = arr.map(element => element + 2);
+let result2 = arr.filter(e=>  e%2==0);
+let result4 =arr.reduce((v1,v2) => v1*v2);
+let result3 = arr.every(e=> e>0);
+console.log(result2);
+console.log(result3);
+console.log(result1);
+console.log(result4);
+    </script>
+    
+</body>
 </html>
\ No newline at end of file
diff --git "a/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/.keep" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md"
similarity index 93%
rename from "\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md"
rename to "27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md"
index 65028e07ba42c0517523b9ed141e1f99bfdfd14e..c63f2f565e21c35d2d464d706826baed3d670d59 100644
--- "a/\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md"	
+++ "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-13 Html\345\205\250\345\261\200\345\217\230\351\207\217\345\274\271\347\252\227\350\276\223\345\205\245\345\207\272.md"	
@@ -1,44 +1,44 @@
-# 	               10-13Html全局变量弹窗输入\出
-
-## 1.1如何导入js文件
-
-```html
-
-    <script type="text/javascript">
-
-```
-
-## 1.2定义变量
-
-```js
-  var a=0; 
-  var b=0;
-```
-
-## 1.3输出\入
-
-```js
-//输出
-console.log('D')
-//输入
-var name =prompt()
-
-   //3.   求199-2022的润年
-        var year =199;
-
-        while (year<=2022) {
-            if(year%400==0 ){
-                year++;
-             
-            }else if(year%4==0 && year%100!=0){
-                year++;
-            }
-            
-            else{
-                year++;
-                continue;
-            }
-            console.log(year-1)
-        }
-```
-
+# 	               10-13Html全局变量弹窗输入\出
+
+## 1.1如何导入js文件
+
+```html
+
+    <script type="text/javascript">
+
+```
+
+## 1.2定义变量
+
+```js
+  var a=0; 
+  var b=0;
+```
+
+## 1.3输出\入
+
+```js
+//输出
+console.log('D')
+//输入
+var name =prompt()
+
+   //3.   求199-2022的润年
+        var year =199;
+
+        while (year<=2022) {
+            if(year%400==0 ){
+                year++;
+             
+            }else if(year%4==0 && year%100!=0){
+                year++;
+            }
+            
+            else{
+                year++;
+                continue;
+            }
+            console.log(year-1)
+        }
+```
+
diff --git "a/\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md"
similarity index 93%
rename from "\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md"
rename to "27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md"
index 9e72942c86369f974ca87d51d087b952510e03ff..30f7379857f6a926f6224ae1333db1353113b3d8 100644
--- "a/\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-14\346\225\260\346\215\256\347\261\273\345\236\213.md"	
@@ -1,78 +1,78 @@
-
-
-# 			  10-14数据类型
-
-#### 基本数据类型
-
-##### Number  - Integer,float
-
-##### Boolean
-
-##### Null
-
-##### Undefined
-
-##### Symbol
-
-##### String 
-
-## 数据类型转换
-
-#### 1.显示类型转换
-
-- #### Number(mix)
-
-- #### parseInt(str, radix)
-
-- #### parseFloat(string)
-
-- #### String(mix)
-
-- #### toString(radix)
-
-- #### Boolean()
-
-**练习：将10110110转成16进制**
-
-```js
-    var num=10110110;
-     var num1=parseInt(num,2);
-     var num2=num1.toString(16);
-     alert(num2);
-```
-
-## 常用类Math
-
-```js
-//求随机数
-math.round()
-//取整
-math.ceil() //向上
-math.floor() //向上
-```
-
-## 引用类型
-
-### 1.创建数组
-
-```js
-//1.1创建空数组
-//使用数组构造器
-const arr = Array()
-const arr = []
-
-//1.2 带元素数组
-const numbers =  [0, 3.14, 9.81, 37, 98.6, 100];
-const fruits = ['banana', 'orange', 'mango', 'lemon']
-const arr = [
-    'Asabeneh',
-    250,
-    true,
-    { country: 'Finland', city: 'Helsinki' },
-    { skills: ['HTML', 'CSS', 'JS', 'React', 'Python'] }
-]
-//使用字符串的split方法创建数组
-let js = 'JavaScript'
-const charsInJavaScript = js.split('')
-```
-
+
+
+# 			  10-14数据类型
+
+#### 基本数据类型
+
+##### Number  - Integer,float
+
+##### Boolean
+
+##### Null
+
+##### Undefined
+
+##### Symbol
+
+##### String 
+
+## 数据类型转换
+
+#### 1.显示类型转换
+
+- #### Number(mix)
+
+- #### parseInt(str, radix)
+
+- #### parseFloat(string)
+
+- #### String(mix)
+
+- #### toString(radix)
+
+- #### Boolean()
+
+**练习：将10110110转成16进制**
+
+```js
+    var num=10110110;
+     var num1=parseInt(num,2);
+     var num2=num1.toString(16);
+     alert(num2);
+```
+
+## 常用类Math
+
+```js
+//求随机数
+math.round()
+//取整
+math.ceil() //向上
+math.floor() //向上
+```
+
+## 引用类型
+
+### 1.创建数组
+
+```js
+//1.1创建空数组
+//使用数组构造器
+const arr = Array()
+const arr = []
+
+//1.2 带元素数组
+const numbers =  [0, 3.14, 9.81, 37, 98.6, 100];
+const fruits = ['banana', 'orange', 'mango', 'lemon']
+const arr = [
+    'Asabeneh',
+    250,
+    true,
+    { country: 'Finland', city: 'Helsinki' },
+    { skills: ['HTML', 'CSS', 'JS', 'React', 'Python'] }
+]
+//使用字符串的split方法创建数组
+let js = 'JavaScript'
+const charsInJavaScript = js.split('')
+```
+
diff --git "a/\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md"
similarity index 96%
rename from "\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md"
rename to "27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md"
index 87db80b1f9435403b39c2332636fa1a8958db0c0..9a9712981d862c71c2c1b2dbec9b0f0eb5bf38c7 100644
--- "a/\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md"	
+++ "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-18 JS\345\255\227\347\254\246\344\270\262\344\270\216\346\225\260\347\273\204.md"	
@@ -1,170 +1,170 @@
-# 10-18 JS字符串与数组
-
-## 计算字符串的长度使用`字符串.length`的方式。
-
-例如：
-
-```js
-var txt1 = "Hello World!";
-document.write(txt1.length);	// 12
-```
-
-## 3.charAt() 和 charCodeAt()
-
-`charAt()` 和 `charCodeAt()` 均表示获取指定位置的字符。不同的是
-前者返回具体的字符，后者返回字符的 Unicode 码。
-
-例如：
-
-```js
-var str = "Hello World!";
-console.log(str.charAt(0)); // H
-console.log(str.charCodeAt(0)); // 72
-```
-
-**注意**： 如果向 `charCodeAt()` 方法中传入了负数或者大于等于字符串的长度，那么该方法会返回 `NaN`。
-
-
-
-## 数组
-
-```js
-//获取数组长度 length
-
-
-//concat:将两个数组合并在一起
-const firstList = [1, 2, 3]
-const secondList = [4, 5, 6]
-const thirdList = firstList.concat(secondList)
-
-//indexof:查找数组的元素，返回-1表示不存在,与之相同的查找方法还有includes,lastindexof
-
-//toString():将数组转成字符串
-
-//join():添加指定字符后转成字符串 转成json常用
-
-//slice():表示切片，参数个数：0 1 2  返回一个数组对象
-
-//splice(): 接收 0 2 多 个参数 表示移除，替换元素
-
-
-//数组的添加元素：push  unshift
-//数组的删除元素: shift pop
-
-//reverse() ：反转
-//sort()
-
-//forEach():数组为每个数组元素调用一次函数（回调函数）。
-//map()
-//filter()：匹配符合条件的元素
-//reduce()： 汇总数据，返回是一个数据
-//every():检查所有数组值是否通过测试
-```
-
-### 3.7 shift
-
-`shift` 方法用于删除数组中的第一个元素，并返回删除的这个元素。
-语法：
-
-```js
-arr.shift();
-```
-
-### 3.8 unshift
-
-`unshift` 方法用于在数组的第一个位置添加元素，并返回添加元素后的数组长度。
-语法：
-
-```js
-arr.unshift();
-var arr = ["a", "b", "c"];
-console.log(arr.unshift("100"));    // 4
-console.log(arr);   // ["100", "a", "b", "c"]
-```
-
-3.9 reverse
-reverse 方法能够反序排列数组。
-语法：
-
-arr.reverse();
-1
-var arr = ["a", "b", "c"];
-console.log(arr.reverse()); // ["c", "b", "a"]
-1
-2
-3.10 slice
-slice 方法可以根据指定的 起点和终点 来对数组进行截取，并生成一个新数组。新数组的内容是从起点下标的元素到终点下标的元素，但不包含终点下标的元素本身。
-
-语法：
-
-arr.slice(index1, index2);
-1
-var arr = ["a", "b", "c"];
-console.log(arr.slice(1, 2));	// b
-1
-2
-上面的代码从下标为 1 的元素开始截取，截取到下标为 2 处，但是不包括下标为 2 的元素。
-
-注意：
-
-slice 方法的参数可以是负值，-1 代表最后一个元素，-2 代表倒数第二个元素。
-如果只写一个下标，则表示从该下标处截取到数组末尾。
-3.11 splice
-splice 方法和 slice 方法很相似，但是 splice 更强大，splice 方法的作用是在指定下标处截取一定长度的元素，再插入一些新元素，并将删除的元素构成一个新数组返回，splice 方法会改变原数组。
-
-语法：
-
-arr.splice(index, removeCount, addItem1, addItem2...);
-1
-var nums = [1, 2, 3, 'a', 'b', 'c', 7, 8, 9];
-// 从索引为 3 的位置删除 3 个元素，再将 4, 5, 6 添加进去
-var new1 = nums.splice(3, 3, 4, 5, 6);  
-console.log(new1);  // ["a", "b", "c"]
-console.log(nums);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
-1
-2
-3
-4
-5
-注意：前两个参数是必要的，后面的可以自己选择。
-
-3.12 sort
-sort 方法用于对数组元素进行排序，默认按照编码方式进行排序（即不在括号里写任何内容），如果不希望按照默认方式排序，则需要自定义排序函数。
-
-语法：
-
-arr.sort(sortby);
-1
-var arr = [1, 100, 40, 25, 38];
-console.log(arr.sort());    // [1, 100, 25, 38, 40]
-1
-2
-注意：如果调用该方法时没有使用参数，则按照字符编码的顺序排序。
-
-3.13 indexOf
-indexOf 方法能够从前到后检索数组，并返回元素在数组中的第一次出现的下标，如果没有找到则返回 -1，indexOf 第二个参数表示第几个元素开始索引。
-语法：
-
-arr.indexOf(item, beginIndex);
-1
-var nums = [11, 13, 15, 17, 19, 11];
-console.log(nums.indexOf(11));	// 0
-console.log(nums.indexOf(11, 1));   // 5
-console.log(nums.indexOf(100));	// -1
-1
-2
-3
-4
-注意：第二个参数可以是负值，如果是 -1 则表示从最后一个元素开始向后查找（不推荐）。
-
-3.14 lastIndexOf
-lastIndexOf 方法能够从后向前检索数组，并返回元素在数组中的最后一次出现的下标，如果没有找到则返回 -1，lastIndexOf 的第二个参数表示从第几个元素开始索引，是可选参数。
-
-语法：
-
-arr.lastIndexOf(item, beginIndex);
-1
-var nums = [11, 13, 15, 17, 19, 11];
-console.log(nums.lastIndexOf(11));  // 5
-console.log(nums.lastIndexOf(11, -2));  // 0
-console.log(nums.lastIndexOf(100)); // -1
+# 10-18 JS字符串与数组
+
+## 计算字符串的长度使用`字符串.length`的方式。
+
+例如：
+
+```js
+var txt1 = "Hello World!";
+document.write(txt1.length);	// 12
+```
+
+## 3.charAt() 和 charCodeAt()
+
+`charAt()` 和 `charCodeAt()` 均表示获取指定位置的字符。不同的是
+前者返回具体的字符，后者返回字符的 Unicode 码。
+
+例如：
+
+```js
+var str = "Hello World!";
+console.log(str.charAt(0)); // H
+console.log(str.charCodeAt(0)); // 72
+```
+
+**注意**： 如果向 `charCodeAt()` 方法中传入了负数或者大于等于字符串的长度，那么该方法会返回 `NaN`。
+
+
+
+## 数组
+
+```js
+//获取数组长度 length
+
+
+//concat:将两个数组合并在一起
+const firstList = [1, 2, 3]
+const secondList = [4, 5, 6]
+const thirdList = firstList.concat(secondList)
+
+//indexof:查找数组的元素，返回-1表示不存在,与之相同的查找方法还有includes,lastindexof
+
+//toString():将数组转成字符串
+
+//join():添加指定字符后转成字符串 转成json常用
+
+//slice():表示切片，参数个数：0 1 2  返回一个数组对象
+
+//splice(): 接收 0 2 多 个参数 表示移除，替换元素
+
+
+//数组的添加元素：push  unshift
+//数组的删除元素: shift pop
+
+//reverse() ：反转
+//sort()
+
+//forEach():数组为每个数组元素调用一次函数（回调函数）。
+//map()
+//filter()：匹配符合条件的元素
+//reduce()： 汇总数据，返回是一个数据
+//every():检查所有数组值是否通过测试
+```
+
+### 3.7 shift
+
+`shift` 方法用于删除数组中的第一个元素，并返回删除的这个元素。
+语法：
+
+```js
+arr.shift();
+```
+
+### 3.8 unshift
+
+`unshift` 方法用于在数组的第一个位置添加元素，并返回添加元素后的数组长度。
+语法：
+
+```js
+arr.unshift();
+var arr = ["a", "b", "c"];
+console.log(arr.unshift("100"));    // 4
+console.log(arr);   // ["100", "a", "b", "c"]
+```
+
+3.9 reverse
+reverse 方法能够反序排列数组。
+语法：
+
+arr.reverse();
+1
+var arr = ["a", "b", "c"];
+console.log(arr.reverse()); // ["c", "b", "a"]
+1
+2
+3.10 slice
+slice 方法可以根据指定的 起点和终点 来对数组进行截取，并生成一个新数组。新数组的内容是从起点下标的元素到终点下标的元素，但不包含终点下标的元素本身。
+
+语法：
+
+arr.slice(index1, index2);
+1
+var arr = ["a", "b", "c"];
+console.log(arr.slice(1, 2));	// b
+1
+2
+上面的代码从下标为 1 的元素开始截取，截取到下标为 2 处，但是不包括下标为 2 的元素。
+
+注意：
+
+slice 方法的参数可以是负值，-1 代表最后一个元素，-2 代表倒数第二个元素。
+如果只写一个下标，则表示从该下标处截取到数组末尾。
+3.11 splice
+splice 方法和 slice 方法很相似，但是 splice 更强大，splice 方法的作用是在指定下标处截取一定长度的元素，再插入一些新元素，并将删除的元素构成一个新数组返回，splice 方法会改变原数组。
+
+语法：
+
+arr.splice(index, removeCount, addItem1, addItem2...);
+1
+var nums = [1, 2, 3, 'a', 'b', 'c', 7, 8, 9];
+// 从索引为 3 的位置删除 3 个元素，再将 4, 5, 6 添加进去
+var new1 = nums.splice(3, 3, 4, 5, 6);  
+console.log(new1);  // ["a", "b", "c"]
+console.log(nums);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+1
+2
+3
+4
+5
+注意：前两个参数是必要的，后面的可以自己选择。
+
+3.12 sort
+sort 方法用于对数组元素进行排序，默认按照编码方式进行排序（即不在括号里写任何内容），如果不希望按照默认方式排序，则需要自定义排序函数。
+
+语法：
+
+arr.sort(sortby);
+1
+var arr = [1, 100, 40, 25, 38];
+console.log(arr.sort());    // [1, 100, 25, 38, 40]
+1
+2
+注意：如果调用该方法时没有使用参数，则按照字符编码的顺序排序。
+
+3.13 indexOf
+indexOf 方法能够从前到后检索数组，并返回元素在数组中的第一次出现的下标，如果没有找到则返回 -1，indexOf 第二个参数表示第几个元素开始索引。
+语法：
+
+arr.indexOf(item, beginIndex);
+1
+var nums = [11, 13, 15, 17, 19, 11];
+console.log(nums.indexOf(11));	// 0
+console.log(nums.indexOf(11, 1));   // 5
+console.log(nums.indexOf(100));	// -1
+1
+2
+3
+4
+注意：第二个参数可以是负值，如果是 -1 则表示从最后一个元素开始向后查找（不推荐）。
+
+3.14 lastIndexOf
+lastIndexOf 方法能够从后向前检索数组，并返回元素在数组中的最后一次出现的下标，如果没有找到则返回 -1，lastIndexOf 的第二个参数表示从第几个元素开始索引，是可选参数。
+
+语法：
+
+arr.lastIndexOf(item, beginIndex);
+1
+var nums = [11, 13, 15, 17, 19, 11];
+console.log(nums.lastIndexOf(11));  // 5
+console.log(nums.lastIndexOf(11, -2));  // 0
+console.log(nums.lastIndexOf(100)); // -1
diff --git "a/\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md"
similarity index 96%
rename from "\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md"
rename to "27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md"
index 9c1f29bcf64e90de90f7c03249c906097420ad3b..710439110ec197ae7226e912cf5ab4f19fb80287 100644
--- "a/\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md"
+++ "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-21\345\207\275\346\225\260.md"	
@@ -1,278 +1,278 @@
-# 							10-21函数
-
-## 1.1函数概念
-
-在 JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。虽然 for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用 JS 中的函数。
-
- 函数：就是封装了一段**可被重复调用执行的代码块**。通过此代码块可以**实现大量代码的重复使用。**2.2 函数的使用
-
-#### 1.2声明函数
-
-```js
-// 声明函数
-function 函数名() {
-    //函数体代码
-}
-//定义一个函数，输入n，求n!的阶乘 5!=1*2*3*4*5
- // var num = parseInt(prompt("请输入一个数"));  //输入一个数
-
-        // function aa(num) {
-        //     var res = 1;  //result:定义积： 1*1*2*3*4*5
-        //     for (var i = 1; i <= num; i++) {
-        //         res *= i; //res = res * i
-        //     }
-        //     return res;
-        // }
-function 是声明函数的关键字,必须小写
-
-由于函数一般是为了实现某个功能才定义的， 所以通常我们将函数名命名为动词，比如 getSum
-
-
-
-        //匿名函数： function (){}
-        // function (num) {
-        //     var res = 1;  //result:定义积： 1*1*2*3*4*5
-        //     for (var i = 1; i <= num; i++) {
-        //         res *= i; //res = res * i
-        //     }
-        //     return res;
-        // }
-
-
-        //表达式
-        // var aa =  function(num){
-        //     var res = 1;
-        //     for(var i = 1; i <= num ; i++){
-        //         res*=i;
-        //     }
-        //     return res;
-        // }
-        // var res = aa(num);
-        // console.log(res);
-        // console.log(typeof aa);  //number boolean array function(对象)
-
-        // function fn(){
-        //     //arguments:只有长度，只能找下标和元素
-        //     //console.log(arguments);
-
-        // }
-
-        // fn(1,2,3,4,5,6,7,8,9,0)
-
-
-        //箭头函数：  var aa =   (形参列表)   =>  {函数体} arrow function
-        // var aa = function (n1, n2) {
-        //     var sum = n1 + n2
-        //     return sum;
-        // }
-
-        // var bb = (n1, n2) => {
-        //     var sum = n1 + n2;
-        //     return n1+n2;
-        // }
-
-        // var cc = (n1, n2) => n1 + n2; //函数只有一个return语句时，省略{}和return关键字,直接写返回值
-
-
-        // var aa = function (num) {
-        //     var res = 1;
-        //     for (var i = 1; i <= num; i++) {
-        //         res *= i;
-        //     }
-        //     return res;
-        // }
-
-        //当函数只有一个形参时，可以省略圆括号
-        // var dd = (num) => {
-        //     var res = 1;
-        //     for (var i = 1; i <= num; i++) {
-        //         res *= i;
-        //     }
-        //     return console.log(res);;
-        // }
-
-        // var ee = () => '这是一个箭头函数';  //无参时，圆括号不可以省略
-
-
-        // console.log(aa(5,5));
-        // console.log(bb(5, 5));
-        // console.log(cc(5, 5));
-        // console.log(dd(5,5));
-        // console.log(ee());
-
-
-        //无返回值,一般不用箭头函数
-
-```
-
-## 1.3调用函数
-
-// 调用函数
-函数名();  // 通过调用函数名来执行函数体代码
-1
-2
-调用的时候千万不要忘记添加小括号
-
-口诀：函数不调用，自己不执行
-
-注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。
-
-## 1.4函数的参数
-
-
-
-```js
-  //对象：  类(人类，鱼类，鸟类)   万物对象(陈鹏):属性和行为
-        //字面量表达式创建对象
-        // var obj = {
-        //     name:{
-        //         firstName:'陈',
-        //         lastName:'鹏'
-        //     },
-        //     age:18,
-        //     'qq number': 1658656456
-        // }  
-        //属性:增删改查
-        //1.查 . 一级属性  二级属性往后[][]
-        // console.log(obj.name);
-        // console.log(obj.age);
-        //1.1查  使用 []
-        // console.log(obj['name']['lastName']);  
-
-        //增 obj.原来obj中没有的属性，相当于将该属性添加到对象obj中
-        // obj.gender = '男'
-        // console.log(obj);
-
-        // obj.age = 19
-        // console.log(obj);
-
-        //删 delete  一般删之前要对该属性进行判断 
-        // delete obj.age
-        // console.log(obj);
-
-        //构造函数   =  new 对象
-
-        //普通函数命名规则：小驼峰:getName()
-        //构造函数命名规则：大驼峰:GetName()
-        function GetName(){
-            this.name = '陈鹏'
-            this.age = 18
-        };
-
-
-        var obj = new GetName()   //生成了一个对象
-        console.log(obj.age);
-
-        //设计模式：12种  工厂模式
-        
-        
-
-        
-```
-
-函数参数语法
-形参：函数定义时设置接收调用时传入
-
-实参：函数调用时传入小括号内的真实数据
-
-
-
-参数的作用 : 在函数内部某些值不能固定，我们可以通过参数在调用函数时传递不同的值进去。
-
-函数参数的运用：
-
-// 带参数的函数声明
-function 函数名(形参1, 形参2 , 形参3...) { // 可以定义任意多的参数，用逗号分隔
-  // 函数体
-}
-// 带参数的函数调用
-函数名(实参1, 实参2, 实参3...); 
-1
-2
-3
-4
-5
-6
-调用的时候实参值是传递给形参的
-形参简单理解为：不用声明的变量
-实参和形参的多个参数之间用逗号（,）分隔
-函数形参和实参数量不匹配时
-
-
-注意：在JavaScript中，形参的默认值是undefined。
-1
-小结：
-
-函数可以带参数也可以不带参数
-声明函数的时候，函数名括号里面的是形参，形参的默认值为 undefined
-调用函数的时候，函数名括号里面的是实参
-多个参数中间用逗号分隔
-形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配
-
-## 1.5函数的返回值
-
-return 语句
-返回值：函数调用整体代表的数据；函数执行完成后可以通过return语句将指定数据返回 。
-1
-// 声明函数
-function 函数名（）{
-    ...
-    return  需要返回的值；
-}
-// 调用函数
-函数名();    // 此时调用函数就可以得到函数体内return 后面的值
-1
-2
-3
-4
-5
-6
-7
-在使用 return 语句时，函数会停止执行，并返回指定的值
-如果函数没有 return ，返回的值是 undefined
-
-## 1.6 arguments的使用
-
- 当不确定有多少个参数传递的时候，可以用 arguments 来获取。JavaScript 中，arguments实际上它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象，arguments 对象中存储了传递的所有实参。arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：
-
-具有 length 属性
-
-按索引方式储存数据
-
-不具有数组的 push , pop 等方法
-
-注意：在函数内部使用该对象，用此对象获取函数调用时传的实参。
-
-## 1.7 函数的两种声明方式
-
-自定义函数方式(命名函数)
-
-利用函数关键字 function 自定义函数方式
-
-// 声明定义方式
-function fn() {...}
-// 调用  
-fn();  
-1
-2
-3
-4
-因为有名字，所以也被称为命名函数
-调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面
-函数表达式方式(匿名函数）
-
-利用函数表达式方式的写法如下：
-
-// 这是函数表达式写法，匿名函数后面跟分号结束
-var fn = function(){...}；
-// 调用的方式，函数调用必须写到函数体下面
-fn();
-1
-2
-3
-4
-因为函数没有名字，所以也被称为匿名函数
-这个fn 里面存储的是一个函数
-函数表达式方式原理跟声明变量方式是一致的
-函数调用的代码必须写到函数体后面
-
+# 							10-21函数
+
+## 1.1函数概念
+
+在 JS 里面，可能会定义非常多的相同代码或者功能相似的代码，这些代码可能需要大量重复使用。虽然 for循环语句也能实现一些简单的重复操作，但是比较具有局限性，此时我们就可以使用 JS 中的函数。
+
+ 函数：就是封装了一段**可被重复调用执行的代码块**。通过此代码块可以**实现大量代码的重复使用。**2.2 函数的使用
+
+#### 1.2声明函数
+
+```js
+// 声明函数
+function 函数名() {
+    //函数体代码
+}
+//定义一个函数，输入n，求n!的阶乘 5!=1*2*3*4*5
+ // var num = parseInt(prompt("请输入一个数"));  //输入一个数
+
+        // function aa(num) {
+        //     var res = 1;  //result:定义积： 1*1*2*3*4*5
+        //     for (var i = 1; i <= num; i++) {
+        //         res *= i; //res = res * i
+        //     }
+        //     return res;
+        // }
+function 是声明函数的关键字,必须小写
+
+由于函数一般是为了实现某个功能才定义的， 所以通常我们将函数名命名为动词，比如 getSum
+
+
+
+        //匿名函数： function (){}
+        // function (num) {
+        //     var res = 1;  //result:定义积： 1*1*2*3*4*5
+        //     for (var i = 1; i <= num; i++) {
+        //         res *= i; //res = res * i
+        //     }
+        //     return res;
+        // }
+
+
+        //表达式
+        // var aa =  function(num){
+        //     var res = 1;
+        //     for(var i = 1; i <= num ; i++){
+        //         res*=i;
+        //     }
+        //     return res;
+        // }
+        // var res = aa(num);
+        // console.log(res);
+        // console.log(typeof aa);  //number boolean array function(对象)
+
+        // function fn(){
+        //     //arguments:只有长度，只能找下标和元素
+        //     //console.log(arguments);
+
+        // }
+
+        // fn(1,2,3,4,5,6,7,8,9,0)
+
+
+        //箭头函数：  var aa =   (形参列表)   =>  {函数体} arrow function
+        // var aa = function (n1, n2) {
+        //     var sum = n1 + n2
+        //     return sum;
+        // }
+
+        // var bb = (n1, n2) => {
+        //     var sum = n1 + n2;
+        //     return n1+n2;
+        // }
+
+        // var cc = (n1, n2) => n1 + n2; //函数只有一个return语句时，省略{}和return关键字,直接写返回值
+
+
+        // var aa = function (num) {
+        //     var res = 1;
+        //     for (var i = 1; i <= num; i++) {
+        //         res *= i;
+        //     }
+        //     return res;
+        // }
+
+        //当函数只有一个形参时，可以省略圆括号
+        // var dd = (num) => {
+        //     var res = 1;
+        //     for (var i = 1; i <= num; i++) {
+        //         res *= i;
+        //     }
+        //     return console.log(res);;
+        // }
+
+        // var ee = () => '这是一个箭头函数';  //无参时，圆括号不可以省略
+
+
+        // console.log(aa(5,5));
+        // console.log(bb(5, 5));
+        // console.log(cc(5, 5));
+        // console.log(dd(5,5));
+        // console.log(ee());
+
+
+        //无返回值,一般不用箭头函数
+
+```
+
+## 1.3调用函数
+
+// 调用函数
+函数名();  // 通过调用函数名来执行函数体代码
+1
+2
+调用的时候千万不要忘记添加小括号
+
+口诀：函数不调用，自己不执行
+
+注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码。
+
+## 1.4函数的参数
+
+
+
+```js
+  //对象：  类(人类，鱼类，鸟类)   万物对象(陈鹏):属性和行为
+        //字面量表达式创建对象
+        // var obj = {
+        //     name:{
+        //         firstName:'陈',
+        //         lastName:'鹏'
+        //     },
+        //     age:18,
+        //     'qq number': 1658656456
+        // }  
+        //属性:增删改查
+        //1.查 . 一级属性  二级属性往后[][]
+        // console.log(obj.name);
+        // console.log(obj.age);
+        //1.1查  使用 []
+        // console.log(obj['name']['lastName']);  
+
+        //增 obj.原来obj中没有的属性，相当于将该属性添加到对象obj中
+        // obj.gender = '男'
+        // console.log(obj);
+
+        // obj.age = 19
+        // console.log(obj);
+
+        //删 delete  一般删之前要对该属性进行判断 
+        // delete obj.age
+        // console.log(obj);
+
+        //构造函数   =  new 对象
+
+        //普通函数命名规则：小驼峰:getName()
+        //构造函数命名规则：大驼峰:GetName()
+        function GetName(){
+            this.name = '陈鹏'
+            this.age = 18
+        };
+
+
+        var obj = new GetName()   //生成了一个对象
+        console.log(obj.age);
+
+        //设计模式：12种  工厂模式
+        
+        
+
+        
+```
+
+函数参数语法
+形参：函数定义时设置接收调用时传入
+
+实参：函数调用时传入小括号内的真实数据
+
+
+
+参数的作用 : 在函数内部某些值不能固定，我们可以通过参数在调用函数时传递不同的值进去。
+
+函数参数的运用：
+
+// 带参数的函数声明
+function 函数名(形参1, 形参2 , 形参3...) { // 可以定义任意多的参数，用逗号分隔
+  // 函数体
+}
+// 带参数的函数调用
+函数名(实参1, 实参2, 实参3...); 
+1
+2
+3
+4
+5
+6
+调用的时候实参值是传递给形参的
+形参简单理解为：不用声明的变量
+实参和形参的多个参数之间用逗号（,）分隔
+函数形参和实参数量不匹配时
+
+
+注意：在JavaScript中，形参的默认值是undefined。
+1
+小结：
+
+函数可以带参数也可以不带参数
+声明函数的时候，函数名括号里面的是形参，形参的默认值为 undefined
+调用函数的时候，函数名括号里面的是实参
+多个参数中间用逗号分隔
+形参的个数可以和实参个数不匹配，但是结果不可预计，我们尽量要匹配
+
+## 1.5函数的返回值
+
+return 语句
+返回值：函数调用整体代表的数据；函数执行完成后可以通过return语句将指定数据返回 。
+1
+// 声明函数
+function 函数名（）{
+    ...
+    return  需要返回的值；
+}
+// 调用函数
+函数名();    // 此时调用函数就可以得到函数体内return 后面的值
+1
+2
+3
+4
+5
+6
+7
+在使用 return 语句时，函数会停止执行，并返回指定的值
+如果函数没有 return ，返回的值是 undefined
+
+## 1.6 arguments的使用
+
+ 当不确定有多少个参数传递的时候，可以用 arguments 来获取。JavaScript 中，arguments实际上它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象，arguments 对象中存储了传递的所有实参。arguments展示形式是一个伪数组，因此可以进行遍历。伪数组具有以下特点：
+
+具有 length 属性
+
+按索引方式储存数据
+
+不具有数组的 push , pop 等方法
+
+注意：在函数内部使用该对象，用此对象获取函数调用时传的实参。
+
+## 1.7 函数的两种声明方式
+
+自定义函数方式(命名函数)
+
+利用函数关键字 function 自定义函数方式
+
+// 声明定义方式
+function fn() {...}
+// 调用  
+fn();  
+1
+2
+3
+4
+因为有名字，所以也被称为命名函数
+调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面
+函数表达式方式(匿名函数）
+
+利用函数表达式方式的写法如下：
+
+// 这是函数表达式写法，匿名函数后面跟分号结束
+var fn = function(){...}；
+// 调用的方式，函数调用必须写到函数体下面
+fn();
+1
+2
+3
+4
+因为函数没有名字，所以也被称为匿名函数
+这个fn 里面存储的是一个函数
+函数表达式方式原理跟声明变量方式是一致的
+函数调用的代码必须写到函数体后面
+
diff --git "a/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-24\345\257\271\350\261\241.md" "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-24\345\257\271\350\261\241.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b97bb6e3881c69f3ac0ecece53dd13cef61097c6
--- /dev/null
+++ "b/27 \350\265\265\346\265\251\346\225\217/\347\254\224\350\256\260/10-24\345\257\271\350\261\241.md"	
@@ -0,0 +1,123 @@
+#    						10-24对象
+
+## 1.1this
+
+```js
+//构造函数 this 出现的情况只有新建了一个对象之后里面才有this 
+ //字面量
+        var obj={}
+  //1.当new了之后会创建一个this 只不过里面是空的  2.this赋值 3.return this
+
+    function Students(name,age) {
+
+     this.name=name; //单纯的this 指向zi
+
+    this.age=age
+
+  }
+
+    var zi=new Students('张三',18)
+    
+    //工厂模式(设计模式)
+        function GetValues(name,age){
+            var that ={ }
+            that.name=name
+            that.age=age
+            return that
+        }
+        var that= GetValues('胡桃',18)
+        console.log(typeof that);
+
+//工厂设计模式和构造函数的效果一样
+
+
+        var obj={
+
+            name:'胡桃',
+            age:18,
+            title:'学生',
+            bf:'赵浩敏',
+            ex:'',
+            //行为一般是拿来修改对象的属性值
+            makebef: function(bfname){
+                //有没有男朋友
+                if (this.bf==' ') {
+                    this.bf=bfname;
+                    console.log(this.name+'与'+bfname+'谈恋爱');
+                }else{
+                    console.log('不能交两个男朋友');
+                }
+            },
+               breakup: function(){
+                //现任变前任
+                this.ex = this.bf;
+                this.bf = '';
+            }
+
+        }
+           //数组解构
+        const arr=[1,4,5,6];
+        let[a,b,...args]=arr
+        
+         //对象解构
+        var obj={
+            name: '零七',
+            age:16
+        }
+        let personName =obj.name,personAge=obj.age
+        console.log(personName);
+        console.log(personAge);
+       let{name:personName, age: personAge}= obj
+
+
+        console.log(personName);
+        console.log(personAge);
+    let{name,age}=obj;
+        console.log(name);
+        console.log(age);
+//新增变量
+        let{name,age,jop='学生'}=obj;
+        console.log(name,age,jop);
+       
+
+//先声明后赋值
+
+
+        //嵌套结构
+        var obj={
+            name: '零七',
+            age:16,
+            skill:
+                [{
+                    sname:'java',
+                year:2021 },
+                {
+                    sname:'php',
+                    year:2022
+                }
+                ]  
+        }
+        //取数据
+        console.log(obj.skill[1].sname);
+
+
+    var obj={
+            name: '零七',
+            age:16,
+            skill:
+                {
+                    sname:'java',
+                year:2021 }
+               
+                 
+        }
+        //取数据
+        // console.log(obj.skill[1].sname);
+        //嵌套解构
+        let{name:personName,skill:{sname:skillName}}=obj
+        console.log(personName)
+        console.log(skillName)
+
+
+```
+
