diff --git "a/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-24 \347\254\254\344\272\224\346\254\241\344\275\234\344\270\232.html" "b/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-24 \347\254\254\344\272\224\346\254\241\344\275\234\344\270\232.html"
new file mode 100644
index 0000000000000000000000000000000000000000..7ca20d162b42228152f100afb963687c22745398
--- /dev/null
+++ "b/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-24 \347\254\254\344\272\224\346\254\241\344\275\234\344\270\232.html"
@@ -0,0 +1,107 @@
+
+
+
+
+
+
+ Document
+
+
+
+
+
\ No newline at end of file
diff --git "a/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-26 \347\254\254\345\205\255\346\254\241\344\275\234\344\270\232.html" "b/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-26 \347\254\254\345\205\255\346\254\241\344\275\234\344\270\232.html"
new file mode 100644
index 0000000000000000000000000000000000000000..4e8abf463f08ad81f9f8b1fd040adf398b05e1be
--- /dev/null
+++ "b/12 \351\231\210\345\215\216\344\274\237/\344\275\234\344\270\232/2022-10-26 \347\254\254\345\205\255\346\254\241\344\275\234\344\270\232.html"
@@ -0,0 +1,55 @@
+
+
+
+
+
+
+ Document
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-24 \345\257\271\350\261\2412.md" "b/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-24 \345\257\271\350\261\2412.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3cccb6f187ce5fb34a1de1c6c714a236d1d10975
--- /dev/null
+++ "b/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-24 \345\257\271\350\261\2412.md"
@@ -0,0 +1,551 @@
+# 2022-10-13
+
+## 循环体
+
+```js
+在html中嵌套javascript
+
+var let (声明函数)
+
+打印在网页 : document.write(); 在网页上打印括号中的值
+
+弹窗:alert() 弹窗显示括号中的值
+
+弹窗输入 :var name = prompt('请输入一个名字')
+
+console.log() ---打印出值
+
+if 判断:
+
+if(条件){
+
+}else if(条件){
+
+}else{
+
+}
+
+for 循环:
+
+for (let i = 1; i <= 100; i++) {
+
+}
+
+switch 判断：
+
+switch (条件) {
+
+ case 值:
+
+ alert('优秀')
+
+ break;
+
+ default:
+
+ break;
+
+ }
+```
+
+ 1-100之间偶数相加，求加到几的时候和超过1000
+
+```js
+var sum = 0
+ var sum1 = 0
+ for (let i = 0; i <=100; i++) {
+ if (i%2==0) {
+ sum = sum + i
+ if (sum > 1000) {
+ sum1 = i
+ break
+ }
+ }
+ }
+ console.log(sum1);
+```
+
+1-100之间偶数相加，能被7整除的数字不参加累加运算，求和
+
+```js
+var sum1 = 0
+for (let i = 0; i <= 100; i++) {
+ if (i%7==0) {
+ continue;
+ }
+ if (i%2==0) {
+ sum1 = sum1 + i
+ }
+ }
+ console.log(sum1);
+```
+
+ 求199-2022的润年
+
+```js
+ var sum = 0
+ for (let i = 199 ; i <=2022; i++) {
+ if ( (i%4==0) && (i%100==0) && (i%400==0) ) {
+ sum = i
+ console.log(sum);
+ }
+ }
+```
+
+输入分数，如果分数在 90-100: A 80-89：B 60-79：C 小于60：D
+
+```js
+ var score = prompt('请输入分数')
+ if (score>=90 && score<=100) {
+ alert('A')
+
+ }
+ if (score>=80 && score<89) {
+ alert('B')
+
+ }
+ if (score>=60 && score<79) {
+ alert('C')
+
+ }
+ else
+ alert('D')
+```
+
+# 2022-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
+ 2-->10-->16 //先转十进制，再转十六进制
+var num = 10110110;
+var num2 = parseInt(num,2);
+var res = num2.toString(16);
+alert(res);
+```
+
+
+
+## 常用类
+
+#### Math
+
+求最值Math.min() Math.max()
+
+舍入 Math.ceil() Math.floor() Math.round()
+
+```js
+Math:min(最小)，max(最大)
+Math: 舍入 ceil(向上取整) floor(向下取整) round(四舍五入)
+ var minnum = Math.min(1,3,5,64,76,47,84,3)
+ var num = Math.ceil(53.1); //54
+```
+
+#### 2.Random
+
+```js
+20-30 Radom()-->[0,1) 1-30: Random()*(31-1) --[0,30-1+1]+1 --> [1,30]
+Random()*(30-20+1)+20 //[20,30]
+console.log((Random())*(30-20+1)+20); //[0,11)+20 --> [20,31) -->[20,30]
+console.log(parseInt(Math.random()*11)+20);
+```
+
+#### 3.Time
+
+
+
+# 2022-10-17
+
+## 数组
+
+```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():检查所有数组值是否通过测试
+```
+
+## shift
+
+`shift` 方法用于删除数组中的第一个元素，并返回删除的这个元素
+
+```js
+arr.shift();
+console.log(arr);
+```
+
+## unshift
+
+`unshift` 方法用于在数组的第一个位置添加元素，并返回添加元素后的数组长度
+
+```js
+arr.shift()
+arr.unshift(86)
+console.log(arr);
+```
+
+## 数组解构
+
+```js
+ //数组解构
+ // const arr = [1,2,3,4];
+ // var a = arr[0];
+ // var b = arr[1];
+ // var d = arr[3];
+ // var[a,...args] = arr;
+ // console.log(a);
+ // console.log(args);
+ // console.log(b);
+ // console.log(c);
+ // console.log(d);
+```
+
+## reverse()反转数组
+
+```js
+// const arr = [1, '5', null, undefined, 6, 4, 11111111]
+// arr.reverse()
+// console.log(arr1);
+```
+
+```js
+ 去空格函数
+var str = 'JavaScript'
+// const arr = str.split('')
+// console.log(arr);
+ console.log(String.prototype);
+ console.log(str.toUpperCase());
+
+ console.log(str.substr(4,6));
+ console.log(str.substring(4,0)); //[4,6) 如果start>end,交换顺序
+ console.log(str.trim()); //去掉两边的空格，中间穿插的不可以
+
+ console.log(str.includes('Sc'));//返回true表示找得到，返回false表示找不到
+ console.log(str.indexOf('Sc',6)); //返回的是第一个匹配字符串的起始下标,如果找不到返回-1
+ console.log(str.slice(4,0)); //截取,返回对应长度的字符串
+```
+
+## 作业习题
+
+将数组中的 元素1 与 元素3 调换位置
+
+```js
+ // const arr = [3,2,1,4,5]
+
+ // let temp = arr[2]
+
+ // arr[2] = arr[0]
+
+ // arr[0] = temp
+
+ // console.log(arr); //1 2 3 4 5
+```
+
+使用冒泡排序（从大到小）： [90,65,78,66,48,39,92,73] 使用数组解构的方法交换变量
+
+```js
+ // const arr = [90,65,78,66,48,39,92,73];
+ // for(let i = 0; iarr.length-1-i;j++){
+ // if(arr[j]>arr[j+1]){
+ // [arr[j],arr[j+1]] = [arr[j+1],arr[j]]
+ // }
+ // }
+ // }
+ // console.log(arr);
+```
+
+ // 1.移除第一个元素87，并在开头添加 元素86
+
+ // 2.移除最后一个元素43， 并在末尾添加1
+
+ // 3.在 70 65 之间插入 元素 68
+
+ // 4.删除元素65
+
+```js
+const arr = [87,85,74,70,65,59,43]
+
+ // 1.
+ // arr[0] = 86
+ // console.log(arr);
+ // 第二种写法
+ // arr.shift()
+ // arr.unshift(86)
+ // console.log(arr);
+
+ // 2.
+ // arr[6] = 1
+ // console.log(arr);
+ // 第二种写法
+ // arr.pop()
+ // arr.push(1)
+ // console.log(arr);
+
+ // 3.
+ // arr.splice(4,0,68);
+ // console.log(arr);
+
+ // 4.
+ // delete arr[4];
+ // console.log(arr);
+```
+
+# 2022-10-21
+
+## 箭头函数
+
+[es6](https://so.csdn.net/so/search?q=es6&spm=1001.2101.3001.7020) 新增了使用胖箭头（=>）语法定义函数表达式的能力，很大程度上，箭头函数实例化的函数对象与正式的函数表达式创建的函数对象行为是相同的。任何可以使用函数表达式的地方，都可以使用箭头函数
+
+不与new一起使用，箭头函数不能用作构造器，和 new一起用会抛出错误。
+
+没有prototype属性箭头函数没有prototype属性。
+
+```js
+// 声明函数
+function 函数名() {
+ //函数体代码
+function 是声明函数的关键字,必须小写
+-----------------------------------------------
+// 普通函数
+let sum = function(a, b) {
+ return a + b;
+}
+
+// 箭头函数
+let sum1 = (a, b) => {
+ return a + b;
+}
+
+---------------------------------
+ 函数示例
+ var elements = [
+ 'Hydrogen',
+ 'Helium',
+ 'Lithium',
+ 'Beryllium'
+ ];
+
+ elements.map(function(element) {
+ return element.length;
+ }); // 返回数组：[8, 6, 7, 9]
+
+ // 上面的普通函数可以改写成如下的箭头函数
+ elements.map((element) => {
+ return element.length;
+ }); // [8, 6, 7, 9]
+
+ // 当箭头函数只有一个参数时，可以省略参数的圆括号
+ elements.map(element => {
+ return element.length;
+ }); // [8, 6, 7, 9]
+```
+
+```js
+var fact = (x) => ( x==0 ? 1 : x*fact(x-1) );
+fact(5); // 120
+```
+
+## 对象
+
+```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);
+```
+
+# 2022-10-24
+
+## 对象
+
+对象是一种复合的数据类型，在对象中可以存储多个不同数据类型的属性。
+
+ 对象创建
+
+```js
+1.字面量
+就是{}里面包含了这个具体事物（对象）的属性和方法
+例如：var obj = {};创建了一个空的对象 调用对象属性的两种方法：（1）对象名.属性值 （2）对象名['属性值'] 调用对象的方法：对象名.方法名（）
+var person1={
+ name:'柯南',
+ age:12,
+ sex:'男',
+ eat:function(){
+ console.log("我饿了,想吃饭")
+ },
+ say:function(){
+ console.log("我叫柯南")
+ }
+}
+console.log("person.eat输出函数",person.eat)
+person.eat(); //直接输出 我饿了,想吃饭
+
+我们需要注意的是：person.eat和person.eat()的区别
+person.eat是输出函数
+person.eat()是调用函数
+----------------------------------------------------------
+2.构造函数方式(推荐)
+字面量和Object只能一次创建一个对象
+构造函数就是把我们对象里面一些相同的属性和方法抽取出来封装到函数里面
+function Star(uname,age,sex){
+this.name=uname
+this.age=age
+this.sex=sex
+}
+
+var liudehua=new Star('刘德华','18岁',‘男’) 构造函数不需要return就可以返回结果
+
+构造函数和对象的区别：
+对象是一个具体的事物，构造函数类似于java里面的类，泛指某一大类
+我们利用构造函数创建对象的过程称之为对象的实例化
+1：new的构造函数可以在内存中创建了一个新对象
+2：让this指向这个新对象
+3：执行构造函数里面的代码，给这个对象添加属性和方法
+4：返回这个新对象（所以构造函数中不需要return）
+----------------------------------------------------------------
+3.工厂模式 (设计模式)
+function createObj(name,age) {
+ let obj=new Object();
+ obj.name=name;
+ obj.age=age;
+ obj.sayHi=function(){
+ console.log(obj.name)
+ }
+ return obj;
+}
+let per=createObj('司藤',200)
+console.log(per.age); //200
+per.sayHi(); //司藤
+-------------------------------------------------------------------
+4.原型模式
+
+5.混合模式
+```
+
+```
+var obj = {
+ name:'张静',
+ age:18,
+ title:'学生',
+ bf:'张三',
+ ex:'',
+ makebf(bfname){
+ console.log();
+ }
+ //行为(方法)一般是拿来修改对象的属性值
+ makebf: function(bfname){
+ //有没有男朋友
+ if(this.bf==''){
+ this.bf = bfname;
+ console.log(this.name+'与'+bfname+'谈恋爱');
+ }else{
+ console.log('不能交两个男盆友');
+ }
+ },
+ breakup: function(){
+ //
+现任变前任
+ this.ex = this.bf;
+ this.bf = '';
+ }
+breakup
+
+}
+ obj.makebf('李四')
+```
+
diff --git "a/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-26 assign,keys,values,entrues \345\214\205\350\243\205\347\261\273.md" "b/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-26 assign,keys,values,entrues \345\214\205\350\243\205\347\261\273.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bcd532f381286575ac2fef4f7660427a63ead20d
--- /dev/null
+++ "b/12 \351\231\210\345\215\216\344\274\237/\347\254\224\350\256\260/2022-10-26 assign,keys,values,entrues \345\214\205\350\243\205\347\261\273.md"
@@ -0,0 +1,92 @@
+# 2022-10-26
+
+## assign
+
+1.Object.assign方法用于对象的合并，将源对象（ source ）的所有可[枚举](https://so.csdn.net/so/search?q=枚举&spm=1001.2101.3001.7020)属性，复制到目标对象（ target ）。
+
+```javascript
+var target = { a: 1 };
+var source1 = { b: 2 };
+var source2 = { c: 3 };
+Object.assign(target, source1, source2);
+target // {a:1, b:2, c:3}
+```
+
+3.Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。
+
+注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
+
+```javascript
+var target = { a: 1, b: 1 };
+var source1 = { b: 2, c: 2 };
+var source2 = { c: 3 };
+Object.assign(target, source1, source2);
+target // {a:1, b:2, c:3}
+```
+
+3.由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。
+
+```javascript
+Object.assign(undefined) // 报错
+Object.assign(null) // 报错
+```
+
+4.如果只有一个参数，Object.assign会直接返回该参数。
+
+```javascript
+var obj = {a: 1};
+Object.assign(obj) === obj // true
+```
+
+5.如果该参数不是对象，则会先转成对象，然后返回。
+
+```javascript
+typeof Object.assign(2) // "object"
+```
+
+Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。
+
+注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
+
+## 包装类
+
+1. 原始数据类型： number, boolean, string, null, undefined ,es6新加的(symbol,bigint)
+2. JS 提供了 三个 特殊的引用类型：[Boolean](https://so.csdn.net/so/search?q=Boolean&spm=1001.2101.3001.7020)、Number、String（**undefined**和**null**没有自己的包装类）
+3. null,undefined是没有包装类的
+4. 所有的包装类都有 valueOf() 和 toString() 方法，还有charAt(), [indexOf](https://so.csdn.net/so/search?q=indexOf&spm=1001.2101.3001.7020)()等方法。
+
+JS为我们提供了三个包装类，通过这三个包装类可以将基本数据类型的数据转换为对象
+
+```js
+String()
+ - 可以基本数据类型字符串转换为String对象
+
+ Number()
+ - 可以基本数据类型数字转换为Number对象
+
+ Boolean()
+ - 可以基本数据类型布尔值转换为Boolean对象
+---------------------------------------------
+ 创建基本数据类型的对象
+ var str = new String('hello') // str是一个值为'hello'的对象 即：String{'hello'}
+ var str1 = 'hello'
+ var num = new Number(3) // num是一个值为3的对象 即：String{'hello'}
+ var num1 = 3
+ var bool = new Boolean(true) // bool是一个值为true的对象 即：String{'hello'}
+ var bool2 = true
+ console.log(str) // String {'hello'}
+ console.log(num) // Number {3}
+ console.log(bool) // Boolean {true}
+ console.log(typeof str) // object
+ console.log(str === str1) // false (str是对象，而str1是字符串)
+----------------------------------------------------
+算出字符串的所占用字节的长度，
+如: str ='live' 长度为4 str='live生活' 长度为8
+（提示:unicode<=255的占1字节，unicode>255的占用2字节, str.charCodeAt(i)查看i的字节码）
+
+var str = 'Live哈哈哈'
+var count = 0
+for (let index = 0; index < str.length; index++) {
+str.charCodeAt(index)>255 ? count+=2 : count++
+```
+