From 5e5b7dba495b22442a97af8406d1fea611ff6ae9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?09=E9=99=88=E7=83=BD=E6=9D=B0sql=E8=BF=9B=E9=98=B6?=
 <3241892760@qq.com>
Date: Wed, 26 Oct 2022 12:34:13 +0800
Subject: [PATCH 1/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...24\344\275\234\347\224\250\345\237\237.md" | 92 +++++++++++++++++++
 .../10.25\351\227\255\345\214\205.md"         | 48 ++++++++++
 ...24\344\275\234\347\224\250\345\237\237.md" | 62 +++++++++++++
 .../10.25\351\227\255\345\214\205.md"         | 61 ++++++++++++
 4 files changed, 263 insertions(+)
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.24\344\275\234\347\224\250\345\237\237.md"
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.25\351\227\255\345\214\205.md"
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.24\344\275\234\347\224\250\345\237\237.md"
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"

diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.24\344\275\234\347\224\250\345\237\237.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.24\344\275\234\347\224\250\345\237\237.md"
new file mode 100644
index 0000000..d42e750
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.24\344\275\234\347\224\250\345\237\237.md"
@@ -0,0 +1,92 @@
+```
+<script>
+//1、
+            var nAdd;
+            function out(){
+                var n = 999;
+                nAdd = function(){ 
+                    n ++;  
+                    console.log(n) //
+                }
+                return function(){
+                    console.log(n); 
+                }
+            }
+            var getN = out();
+            getN();    // function(){console.log(n); } 999
+            nAdd();    // undefined -->1000
+            getN();    // 1000
+
+            // GO: nAdd:undefined  
+            //     out: f out(){}  
+            //     getN:undefined-->999-->1000
+
+            // AO: n:undefined-->999-->1000   
+            //     nAdd: f (){}
+
+ //2、
+function test(){
+	var arr = [];
+	for(var i=0;i<3;i++){
+		(function(j){
+			arr[j] = function(){
+				console.log(j)
+			}
+		}(i))
+	}
+	return arr;
+}
+var myArr = test();
+myArr[0]();//0   arr:undefined-->0
+myArr[1]();//1   arr:undefined-->1
+myArr[2]();//2   arr:undefined-->2
+             //GO：test:undefined-->f test(){}
+             //AO: arr：undefined-->arr[0,1,2]
+
+
+// //3、
+function fun(){
+	var i=1;
+    
+	return function(){console.log(i++)}
+}
+var getFun = fun();
+getFun(); // 1
+getFun(); // 2
+var i=2;    
+getFun(); // 3
+getFun(); // 4
+    //GO: fun:undefined-->f fun(){} 
+    //    getFun:undefined-->f fun(){}
+    //    i：undefined-->2
+    //AO: i:undefined -->1-->2-->3-->4
+
+// //4、
+function fn(){
+	var a = 1;
+	function b(){
+		a++;
+		console.log(a)
+	}
+	function c(){
+		a--;
+		console.log(a)
+	}
+	a  += 10;
+	return [b,c];
+}
+var arr = fn();
+arr[0](); 
+arr[1]();
+
+    //GO:fn:undefined -->fn (){} 
+    //   arr:undefined -->fn (){}
+    //AO: a:undefined -->1-->11 
+    //    b:undefined-->f b(){}-->12
+    //    c:undefined-->f c(){}-->12-->11
+
+
+
+
+    </script>xxxxxxxxxx function a(){    function b(){        var b = 2;    }    var a = 1;    b();}var c = 3;a();//函数全部执行完时依次往销毁内部AO直到全局执行上下文GO，GO在浏览器关闭的那一刻销毁
+```
diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.25\351\227\255\345\214\205.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.25\351\227\255\345\214\205.md"
new file mode 100644
index 0000000..6542a32
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.25\351\227\255\345\214\205.md"
@@ -0,0 +1,48 @@
+- 
+
+- ```
+   <script>
+          //1、
+          function fun(n,o){   // fun(0) 时  n: 0
+          console.log(n,o);       
+          return {
+  
+              fun:function(m){           // 后面三次开始执行里面的函数 fun()括号里的值都是赋值给return里的 m
+  
+                  return fun(m,n)
+              }
+  
+          }
+      }
+          const a =fun(0)  //第一次执行第一个fun(n,o)函数  传入0  n:0  o:undefined
+                           //后面三次都是 带入执行return 里的函数 所以值赋给了m   m对于输出里的n
+          a.fun(1)         //  m-->   n:0  n-->o:1  
+          a.fun(2)         //  m-->   n:0  n-->o:2  
+          a.fun(3)         //  m-->   n:0  n-->o:3  
+          // GO:  fun:f fun(){}, a:undefined
+  
+          // AO: 
+  
+      //2、
+      let a=0,b=0;
+      function A(a){                      //第一次 a:1        第二次: a:2
+          A=function(b){          
+              console.log(a+ b++);        //第一次 不执行     第二次 传入2 b: 2           
+          }
+          console.log(a++);               //第一次 a: 1++     第二次 a:4
+  
+      }
+      A(1); //  1  
+      A(2); //  4
+  
+      //GO: a:undefined-->0 ,b:undefined-->0 , A:f A(){} 
+      //AO: 
+  
+      
+      
+      
+      
+     
+     
+      </script>
+  ```
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.24\344\275\234\347\224\250\345\237\237.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.24\344\275\234\347\224\250\345\237\237.md"
new file mode 100644
index 0000000..94e9204
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.24\344\275\234\347\224\250\345\237\237.md"
@@ -0,0 +1,62 @@
+###  作用域
+
+###### **在 JavaScript 中, 作用域为可访问变量，对象，函数的集合。**
+
+JavaScript 函数作用域: 作用域在函数内修改。
+
+------
+
+## JavaScript 局部作用域
+
+变量在函数内声明，变量为局部变量，具有局部作用域。
+
+局部变量：只能在函数内部访问。
+
+因为局部变量只作用于函数内，所以不同的函数可以使用相同名称的变量。
+
+局部变量在函数开始执行时创建，函数执行完后局部变量会自动销毁。
+
+function outer(){
+    function inner(){
+        var b = 23;
+    }
+    var a = 12;
+    b();
+}
+var global = 100;
+a();
+
+##  作用域链
+
+相当于一个集合，这个集合里面包含着变量对象和所有父级变量对象
+
+```
+function bs() {
+    var b='书包里面的书本';
+    return function () {
+        console.log(b);//没有变量b往bs的作用域变量中找
+    }
+}
+var ba=bs();//返回匿名函数
+ba();//真正执行
+```
+
+### **查找变量的流程**
+
+1. 现在当前作用域的**变量对象**中查找，若无
+2. 沿着作用域链的数组去上级作用域的变量中查找
+
+**示例**:
+
+```
+function a(){
+    function b(){
+        var b = 2;
+    }
+    var a = 1;
+    b();
+}
+var c = 3;
+a();
+//函数全部执行完时依次往销毁内部AO直到全局执行上下文GO，GO在浏览器关闭的那一刻销毁
+```
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"
new file mode 100644
index 0000000..6d60ae4
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"
@@ -0,0 +1,61 @@
+## 闭包
+
+##### 一、闭包的概念
+
+如果一个函数访问了此函数的父级及父级以上的作用域变量，那么这个函数就是一个闭包。
+
+##### 二、为什么要闭包
+
+1. 使外部得以访问函数内部的变量;
+2. 避免全局变量的使用,防止全局变量污染(匿名函数);
+3. 让某些关键变量得以常驻内存,免于被回收销毁(闭包函数);
+
+##### 三、立即执行函数
+
+立即执行函数模式是一种语法，可以让你的函数在定义后立即被执行。
+
+作用:
+
+- 页面加载完成后只执行一次的设置函数。
+- 将设置函数中的变量包裹在局部作用域中，不会泄露成全局变量
+
+例:
+
+```
+<script>
+    
+(function () {
+    console.log("app")
+})()
+```
+
+####  2、优缺点
+
+##### （1）优点
+
+- 使外部得以访问函数内部的变量
+- 避免全局变量的使用,防止全局变量污染(匿名函数)
+- 让某些关键变量得以常驻内存,免于被回收销毁(闭包函数)
+
+##### （2）缺点
+
+- 函数执行完后，函数内的局部变量没有释放，占用内存时间会变长
+- 容易造成内存泄漏
+
+### 二、立即执行函数
+
+- 页面加载完成后只执行一次的设置函数。
+- 将设置函数中的变量包裹在局部作用域中，不会泄露成全局变量
+- 创建一个独立的[作用域](https://gitee.com/link?target=https%3A%2F%2Fso.csdn.net%2Fso%2Fsearch%3Fq%3D%E4%BD%9C%E7%94%A8%E5%9F%9F%26spm%3D1001.2101.3001.7020)。这个作用域里面的变量，外面访问不到
+
+```
+(function b(c){
+   console.log(c);
+}(2))
+```
+
+### 三，立即执行函数与闭包的区别
+
+- 共同优点---能减少全局变量的使用
+- 立即执行函数只是函数的一种调用方式，只是声明完之后立即执行，这类函数一般都只是调用一次，调用完之后会立即销毁，不会占用内存
+- 闭包则主要是让外部函数可以访问内部函数的作用域，也减少了全局变量的使用，保证了内部变量的安全，但因被引用的内部变量不能被销毁，增大了内存消耗，使用不当易造成内存泄露
-- 
Gitee


From 85808ed3eb87dd4568fd630f1d213029d07c67bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?09=E9=99=88=E7=83=BD=E6=9D=B0sql=E8=BF=9B=E9=98=B6?=
 <3241892760@qq.com>
Date: Wed, 26 Oct 2022 12:44:50 +0800
Subject: [PATCH 2/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"   | 1 -
 1 file changed, 1 deletion(-)

diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"
index 6d60ae4..81ffc58 100644
--- "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.25\351\227\255\345\214\205.md"
@@ -46,7 +46,6 @@
 
 - 页面加载完成后只执行一次的设置函数。
 - 将设置函数中的变量包裹在局部作用域中，不会泄露成全局变量
-- 创建一个独立的[作用域](https://gitee.com/link?target=https%3A%2F%2Fso.csdn.net%2Fso%2Fsearch%3Fq%3D%E4%BD%9C%E7%94%A8%E5%9F%9F%26spm%3D1001.2101.3001.7020)。这个作用域里面的变量，外面访问不到
 
 ```
 (function b(c){
-- 
Gitee


From ecc531862841fa64b9763a57709e7154c34f7dc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?09=E9=99=88=E7=83=BD=E6=9D=B0sql=E8=BF=9B=E9=98=B6?=
 <3241892760@qq.com>
Date: Wed, 26 Oct 2022 23:42:30 +0800
Subject: [PATCH 3/3] =?UTF-8?q?=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../10.26\345\216\237\345\236\213.md"         | 58 +++++++++++++++++++
 .../10.26\345\216\237\345\236\213.md"         | 46 +++++++++++++++
 2 files changed, 104 insertions(+)
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.26\345\216\237\345\236\213.md"
 create mode 100644 "09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.26\345\216\237\345\236\213.md"

diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.26\345\216\237\345\236\213.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.26\345\216\237\345\236\213.md"
new file mode 100644
index 0000000..a5f4bdc
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.26\345\216\237\345\236\213.md"
@@ -0,0 +1,58 @@
+1.
+
+​        var fun=function(){}
+​        fun.prototype={
+​            name:'perter',
+​            age:25
+​        }
+
+​        var a=new fun();
+​        var b=new fun();
+​        console.log(a.name,b.name);
+​        fun.prototype.name='jack';
+​        console.log(a.name,b.name);
+
+​        //重写原型
+
+​        // fun.prototype={};
+
+​        fun.prototype.name='tom';
+​        console.log(a.name,b.name);
+
+​        // b.constructor.prototype.name='kit';
+​        b.name='kit';
+​        console.log(a.name,b.name);
+2.
+// prototype，__proto__,constructor  有什么关系
+
+2.1
+构造函数原型对象 prototype
+构造函数通过原型分配的函数是所有对象所共享的
+
+JavaScript规定，每一个构造函数都有 一个prototype属性，指向一个对象。
+
+这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有。
+
+我们可以把那些不变的方法，直接定义在prototype对象是哪个，这样所有对象的实例就可以共享这些方法。
+
+2.2
+对象原型_proto__
+对象都会有一个属性_proto__指向构造函数的 prototype 原型对象。
+之所以我们对象可以使用构造函数 prototype 原型对象的属性和方法，就是因为对象有 proto_ 原型的存在。
+_proto__对象原型和原型对象prototype是等价的。
+_proto__对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条线路，但是他是一个非标准属性，因此，实际开发中，不可以使用这个属性，他只是内部指向原型对象prototype。
+
+
+原型的作用：
+数据共享 节约内存内存空间
+实现继承
+
+2.3
+ constructor构造函数
+对象原型（proto_）和构造函数（prototype）原型对象里面都有一个属性contructor属性。
+contructor我们称为构造函数，因为她只会构造函数本身。
+contructor主要用于记录该对象引用于哪个构造函数，他可以让原型对象重新指向原来的构造函数。
+给prototype追加方法，不会覆盖contructor
+给prototype赋值，会覆盖掉conteuctor。
+
+如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数 。
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.26\345\216\237\345\236\213.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.26\345\216\237\345\236\213.md"
new file mode 100644
index 0000000..e663ff3
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.26\345\216\237\345\236\213.md"
@@ -0,0 +1,46 @@
+### 原型和原型链（prototype主体）
+
+#### 1.构造函数
+
+构造函数和普通函数本质上没什么区别，只不过使用了new关键字创建对象的函数，被叫做了构造函数。构造函数的首字母一般是大写，用以区分普通函数，当然不大写也不会有什么错误。
+
+function Person(name, age) {
+   	this.name = name;
+   	this.age = age;
+    this.species = '人类';
+    this.say = function () {
+        console.log("Hello");
+    }
+}
+
+let per1 = new Person('xiaoming', 20);
+
+#### 2.原型对象
+
+在js中，每一个函数类型的数据，都有一个叫做prototype的属性，这个属性指向的是一个对象，就是所谓的原型对象。对于原型对象来说，它有个constructor属性，指向它的构造函数。
+
+最主要的作用就是用来存放实例对象的公有属性和公有方法。
+
+function Person(name, age) {
+    this.name = name;
+    this.age = age;
+}
+
+Person.prototype.species = '人类';
+Person.prototype.say = function () {
+    console.log("Hello");
+}
+
+let per1 = new Person('xiaoming', 20);
+let per2 = new Person('xiaohong', 19);
+
+console.log(per1.species); // 人类 
+console.log(per2.species); // 人类
+
+per1.say(); // Hello
+per2.say(); // Hellow
+这个constructor是原型对象的属性，在这里能被实例对象使用
+
+#### 3.函数也是一种对象
+
+在js中，所有函数都可以看做是Function()的实例，而Person()和Object()都是函数，所以它们的构造函数就是Function()。Function()本身也是函数，所以Function()也是自己的实例，听起来既怪异又合理，但是就是这么回事。
-- 
Gitee