diff --git "a/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.12\351\235\242\345\220\221\345\257\271\350\261\241\344\275\234\344\270\232.md" "b/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.12\351\235\242\345\220\221\345\257\271\350\261\241\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3211b59a93d748564c9c0fc060aed3344e464483
--- /dev/null
+++ "b/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.12\351\235\242\345\220\221\345\257\271\350\261\241\344\275\234\344\270\232.md"
@@ -0,0 +1,12 @@
+//1.统计在线人数 const keysArr = Object.keys(users) //字符串. var count = 0 keysArr.forEach( function (item) { users[item].isLoggedIn == true ? count++ : count
+
+ } ) console.log(count);
+
+ // 2.统计分数大于50的人数
+
+ const fs = Object.keys(users) //字符串. var fs1 = 0 fs.forEach( function (item) { users[item].points >= 50 ? fs1++ : fs1
+
+ } ) console.log(fs1);
+
+ // 3.查找会MongoDB的人，并打印其名字
+​ const zr=Object.keys(users)​ const xsz=[]​ zr.forEach(​ function(item){​ users[item].skills.includes('MongoDB')? xsz.push(item):xsz​ }​ )​ console.log(xsz);​
\ No newline at end of file
diff --git "a/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.13\344\275\234\344\270\232.md" "b/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.13\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..dc34d7d6a9e8d444026e1d62b586b31086c4bed6
--- /dev/null
+++ "b/30\345\220\264\350\266\205/\344\275\234\344\270\232/10.13\344\275\234\344\270\232.md"
@@ -0,0 +1,51 @@
+ *1.定义方法更新记录:*
+
+*// function updateRecords(id,prop,value)*
+
+*// 要求：*
+
+*// 1).如果传入的value是一个空值，表示将该属性删除*
+
+console.**log**(collection);
+
+function **updateRecords**(id,prop,value){
+
+if(value==""){
+
+```
+delete collection[id],[prop]
+```
+
+}
+
+else if(collection.tracks ==value){
+
+```
+collection.tracks.**unshifit**(value)
+```
+
+}
+
+*// 2).传入的prop如果是tracks，则代表添加，其他是修改*
+
+else if(collection.artist == value){
+
+```
+delete collection[id],[prop]
+
+collection.artist.**unshift**(value)
+```
+
+}
+
+else if(collection.album == value){
+
+```
+delete collection.album[id],[prop]
+
+collection.album.**unshifit**(value)
+```
+
+}
+
+}
\ No newline at end of file
diff --git "a/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.12\351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260.md" "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.12\351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a38fcbbc8a0f374a5cd5f3c40dd8d87efaea1abf
--- /dev/null
+++ "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.12\351\235\242\345\220\221\345\257\271\350\261\241\347\254\224\350\256\260.md"
@@ -0,0 +1,96 @@
+##  面向对象
+
+```
+1.全局变量局部变量
+var str1 = "hello1"; //定义一个全局变量
+		function a() {
+			var str2 = "hello2"; //定义一个局部变量
+			str3 = "hello3"; //定义一个全局变量
+        }
+		a() //结果：我是局部变量
+
+	console.log(str1); //结果：全局变量
+	console.log(str3); //结果：我也是全局变量
+	console.log(str2); //局部变量，在函数外使用会报错
+```
+
+
+
+## 构造函数
+
+构造函数是我们用`new`创建对象时调用的函数，比如：`Object`、`Array`、`Function`等。构造函数同函数同样的定义方式，但是构造函数的首字母应该大写，像这样：
+
+```text
+function Person() {
+    // .....
+}
+
+var person = new Person();     // 可传参的写法
+或者
+var person = new Person;       // 不用传参也可以这么写
+
+// 检查person是否为Person类型(推荐使用instanceof的方式)
+console.log(person instanceof Person);    // true
+```
+
+通过自动以构造函数创建出来的对象，其构造函数属性指向创建它的构造函数
+
+```text
+console.log(person.constructor === Person);    // true
+```
+
+创建一个构造函数的目的是创建许多拥有相同属性和方法的对象。 - 给`this`添加属性
+
+```text
+function Person (name) {
+    this.name = name;
+    this.sayName = function() {
+        return this.name;
+    }
+}
+
+var person1 = new Person('熊大');
+var person2 = new Person('熊二');
+
+console.log(person1.name, person1.sayName());   // '熊大' '熊大'
+console.log(person2.name, person2.sayName());   // '熊二' '熊二'
+```
+
+- `Object.defineProperty()`方法
+
+```text
+function Person(name) {
+    Object.defineProperty(this, "name", {
+        get: function() {
+            return name;
+        },
+        set: function(value) {
+            name = value;
+        },
+        // ...一些配置属性
+    });
+    this.sayName = function() {
+        return this.name;
+    }
+}
+
+var person = new Person('熊大');
+
+console.log(person.sayName());         // 熊大
+```
+
+## 增删改查
+
+```
+查
+通过  .  查询 或者 中括号的形式
+console.log(zj.age);
+console.log(zj['qq number']);
+zj['qq number'] = '7952125'
+zj.age = 26
+删
+delete zj['qq number']
+可直接改
+zj.isMarried = false;
+```
+
diff --git "a/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.13\345\257\271\350\261\241\350\247\243\346\236\204\347\254\224\350\256\260.md" "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.13\345\257\271\350\261\241\350\247\243\346\236\204\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7863a8ca2793d5c4f798fa648dc088e209fdf1cd
--- /dev/null
+++ "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.13\345\257\271\350\261\241\350\247\243\346\236\204\347\254\224\350\256\260.md"
@@ -0,0 +1,241 @@
+# 对象解构
+
+## 基本用法
+
+```js
+const herb = {
+    name: "herb",
+    age: 18
+}
+let herbName = herb.name,
+    herbAge = herb.age;
+```
+
+```
+let { 属性名:变量名 } = 解构对象
+let { name, age } = herb;
+// 相当于：let name = herb.name; let age = herb.age;
+复制代码
+```
+
+`=`右边放要解构的对象，可以是返回一个对象的**表达式**。
+
+`=`左边的`{}`括号里面，表示要把哪些属性名从对象那里解构出来，`:`后面跟着变量名，就是说，属性名对应的属性值存放的地方。如果没有`:`则表示属性名和变量名相同。
+
+```js
+let name, age;
+( { name, age } = herb );
+复制代码
+```
+
+如果给事先声明的变量赋值，则赋值表达式必须包含在一对括号中。
+
+## 解构赋值的同时定义默认值
+
+```js
+const herb = {
+    name: "herb",
+    age: null
+}
+let { name: herbName = "person", age = 20, sex = "男" } = herb;
+
+// name: "herb"
+// age: undefined
+// sex: "男"
+复制代码
+let { 属性名:变量名 = 默认值 } = 解构对象
+```
+
+`herb.sex`不存在时，会使用默认值，或者对象中的属性值为`undefiend`，也会用默认值。
+
+上述代码，相当于：先定义了`herbName`、`age`、`sex`三个变量，再从对象中`:`前面的属性名读取出来赋值给这几个变量，如果属性值为`undefined`，就使用默认值。
+
+## 可以解构原型链上的属性
+
+```js
+class Animal {
+    constructor(type, age, sex) {
+        this.type = type;
+        this.age = age;
+        this.sex = sex;
+    }
+    call() {
+        console.log("aaaa");
+    }
+}
+class Person extends Animal {
+    constructor(type, age, sex, name) {
+        super(type, age, sex);
+        this.name = name;
+    }
+}
+const herb = new Person("人类", 18, "男", "herb");
+复制代码
+let { name, age, sex, call } = herb;
+// name: "herb"
+// age: 18
+// sex: "男"
+// call: call() { console.log("aaaa") }
+复制代码
+```
+
+可以把原型链上的属性也解构出来，无论是否可以遍历。
+
+因为只要在原型链上就可以被对象访问到，所以也可以赋值给新的变量。
+
+## 使用计算属性名
+
+```js
+const arr = [1,2,3,4];
+let { [Symbol.iterator]:it } = arr;
+// it: function
+let key = "z";
+let { [key]: foo } = { z: "bar" };
+// foo: "bar"
+复制代码
+```
+
+可以结合使用。
+
+## 隐式把待解构目标转换成对象
+
+```js
+let { length } = "1234";
+// length: 4
+let { constructor:c } = 100;
+// c == Number
+复制代码
+```
+
+原始值会被转换成对象在进行解构。
+
+```js
+let { a } = null
+let { b } = undefined
+复制代码
+```
+
+`null`和`undefined`不能被解构，否则会报错。
+
+## 嵌套解构
+
+```js
+const user = {
+    name: "herb",
+    age: 19,
+    sex: "男",
+    address: {
+        province: "浙江",
+        city: "嘉兴"
+    }
+}
+复制代码
+let { address } = user;
+// address
+// {
+//       province: "浙江",
+//       city: "嘉兴"
+// }
+复制代码
+```
+
+解构出来是一个对象。
+
+```js
+let { address: { province, city } } = user;
+// address 不存在
+// province: "浙江"
+// city: "嘉兴"
+复制代码
+```
+
+`let`创建了`province`和`city`两个变量，不会创建`address`，只是从`user`里找到`address`，并从`address`里找到`province`和`city`。
+
+```js
+let { province, city } = user.address;
+复制代码
+```
+
+也可以这样写，直接在`=`右边把要结构的对象找出来，不用在`{}`里面嵌套解构了。
+
+```js
+let { hobby: { food, sport } } = user;
+// Uncaught TypeError: Cannot read property 'food' of undefined
+复制代码
+```
+
+注意：外层属性没有定义的情况下不能使用嵌套结构。`user`没有`hobby`属性，对其进行嵌套解构肯定会出错。
+
+## 数组解构
+
+```js
+const arr =  [0, 1, 2, 3, 4];
+复制代码
+const { 0: a, 4: e } = arr;
+// a: 0
+// e: 4
+复制代码
+```
+
+数组本质上就是一个对象，所以可以通过对象的方式解构。
+
+```js
+const [a, , , , e] = arr;
+// a: 0
+// e: 4
+复制代码
+```
+
+数组也有自己的解构方式，用`[]`表示，里面变量的顺序代表了`arr`里面元素的顺序。省略了索引，是上一个写法的简化版本，但是要获取不连续的两个索引，要用`,`分隔，表示跳过数组里多少元素。
+
+```js
+const arr =  [0, 1, [2, 3, 4]];
+let [, , [c, d]] = arr;
+// c: 2
+// d: 3
+let [two, three] = arr[2];
+// two: 2
+// three: 3
+复制代码
+```
+
+也可以嵌套解构。
+
+## 剩余参数
+
+```js
+const user = {
+    name: "herb",
+    age: 19,
+    sex: "男",
+    address: {
+        province: "浙江",
+        city: "嘉兴"
+    }
+}
+复制代码
+let { name, ...prop } = user;
+// name: "herb"
+// prop: {
+//   address: { province: "浙江", city: "嘉兴" }
+//   age: 19
+//   sex: "男"
+// }
+复制代码
+```
+
+`...prop`剩余参数会把没有解构的属性全部收集起来，封装成新的对象。
+
+可以很方便的把一个对象的某些属性剔除出来。
+
+```js
+let {...prop1, age, ...prop2 } = user;
+// Uncaught SyntaxError: Rest element must be last element
+复制代码
+```
+
+注意：剩余参数只能出现在最后一位。
+
+## 包装类
+
+new 类名()
\ No newline at end of file
diff --git "a/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.17\346\265\205\346\213\267\350\264\235\344\270\216\346\267\261\346\213\267\350\264\235\347\254\224\350\256\260.md" "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.17\346\265\205\346\213\267\350\264\235\344\270\216\346\267\261\346\213\267\350\264\235\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d335959f71749216c27658c44a2c9666ca836954
--- /dev/null
+++ "b/30\345\220\264\350\266\205/\347\254\224\350\256\260/10.17\346\265\205\346\213\267\350\264\235\344\270\216\346\267\261\346\213\267\350\264\235\347\254\224\350\256\260.md"
@@ -0,0 +1,70 @@
+## 1.浅拷贝与深拷贝
+
+浅拷贝是指，在复制变量时，对于引用类型的变量，只拷贝其引用，不拷贝其在堆中的真实数据。深拷贝是指，拷贝堆中的数据，一个新的引用指向新拷贝出来的数据。
+
+## 2.Array的push方法是浅拷贝
+
+判断浅拷贝还是深拷贝，一个很简单的方法就是使用全等(===)，当两个对象进行比较时，只有指向同一个对象，结果才会是true。当向arr中push一个obj，全等的结果是true，说明两个引用指向的是同一个对象，arr中保存的是旧引用而不是新引用。当我们修改obj后，arr也会一起被修改。当对obj赋值null，由于obj不再是引用，而arr中还保存有引用，所以他们不相等。
+我原本以为执行`obj=null`之后，arr中保存的对象也会没掉，其实并不是。obj是引用，让其等于null只是改变obj的指向，并不影响堆中的真实对象。由于堆中的真实对象还有arr对其引用，所以该对象不会被垃圾回收。
+
+```javascript
+var arr =[];
+var obj = {name:'abc',obj:{name:'new'}};
+arr.push(obj);
+
+console.log(arr[0] === obj);//true
+console.log(JSON.stringify(arr[0]));
+console.log(JSON.stringify(obj));
+
+obj.name = '123';
+console.log(arr[0] === obj);//true
+console.log(JSON.stringify(arr[0]));
+console.log(JSON.stringify(obj));
+
+obj = null;
+console.log(arr[0] === obj);//false
+console.log(JSON.stringify(arr[0]));
+console.log(JSON.stringify(obj));
+```
+
+## 3.对象的深拷贝
+
+对象深拷贝的方法就是遍历对象的属性，并把属性赋值给新对象。数组是比较特殊的对象，在拷贝数组的时候，需要初始化的是`[]`。
+
+```vajascript
+function deep(src) {
+     var des = Array.isArray(src) ? [] : {};
+     for(var key in src) {
+        if(src.hasOwnProperty(key)) {
+            des[key] = src[key];
+        }
+     }
+     return des;
+}
+var des = deep(src);
+```
+
+上面这个拷贝方法会有一些问题：当对象的属性还是对象的时候，该属性对象会是浅拷贝。对于这种情况，我们可以递归地调用该方法。
+
+```javascript
+function deep(src) {
+     var des = Array.isArray(src) ? [] : {};
+     for(var key in src) {
+        if(src.hasOwnProperty(key)) {
+            des[key] = (typeof src[key] == 'object') ? deep(src[key]) : src[key];
+        }
+     }
+     return des;
+}
+var des = deep(src);
+```
+
+JQuery中的浅、深拷贝。第一个参数代表是否深拷贝，第二个参数是目的对象，第三个参数是要拷贝的源对象。
+
+```less
+%.extend({}, src);//浅拷贝
+%.extend(true, {}, src);//深拷贝
+```
+
+上面给出的深拷贝代码解决了嵌套对象的问题，但如果属性是函数的话，该属性是浅拷贝，是对函数的引用。
+