chore(ci): blog sync

coderInwind · coderInwind · commit e5832bf407d6 · 2023-12-23T12:48:56.000Z
diff --git a/data/blog/ES6dixin特xing.mdx b/data/blog/ES6dixin特xing.mdx
@@ -0,0 +1,112 @@
+---
+  title: ES6的新特性
+  date: 2023-12-23T12:48:31Z
+  summary:
+  tags: []
+---
+  
+  ## 数组的解构
+```
+const  arr = ["item1","item2","item3"]
+//当值not defined时给它一个默认值
+const [item1,item2,item3,item4 = "abc"] = arr
+
+console.log(item1,item2,item3,item4);
+//输出item1 item2 item3 abc
+
+console.log(...arr);
+//输出item1 item2 item3
+```
+## 对象的解构
+```
+const obj = {
+  name: "in wind",
+  age: 18,
+  height: 18.8,
+};
+const {name,age,height} = obj
+
+console.log(name,age,height);
+//输出in wind 18 18.8
+//配置别名和默认值
+const {sex:mySex = "男"} = obj
+
+console.log(mySex);
+//输出 男
+```
+## const/let
+const定义的是一个常量，定义的值是不可以被修改的
+那为什么定义一个对象或者数组的时候，可以修改对象的属性或者数组的某个值呢
+因为const定义对象或者数组的时候，保存的是他们的内存地址，指向堆中创建出的的数组或对象
+进行修改时，该指针并不会改变
+let定义一个变量
+## var和let/const的区别
+1、var能重复定义，而let和const不行
+2、var会造成变量提升，即在声明变量之前能被访问，而let和const没有变量提升，虽然他被创建出来了，但不能被访问到
+## 块级作用域
+function(){} {} if(){} for(){}等
+## 暂时性死区
+```
+var a = "abc"
+if(true){
+//在一个块级作用域内，如果在let和const之前使用声明的变量，就会产生暂时性死区
+	console.log(a)
+	let a = "cba"
+}
+```
+## for of 和 for in
+```
+const arr = [1,2,3,4,5]
+const obj = {a:"aaa",b:"bbb",c:"ccc"}
+//for of遍历数组
+for(const item of arr){
+  console.log(item);
+//输出数组的值1,2,3,4,5
+}
+//for of遍历对象会报错，因为没有迭代器对象
+for(const item in arr){
+	console.log(item);
+//输出数组的key
+}
+
+for(const item in obj){
+	console.log(item)
+//输出对象的key
+}
+```
+## 模板字符串
+```
+//模板字符串
+const name = "inwind"
+console.log(`这是${name}的博客`)
+//输出 这是inwind的博客
+
+//标签模块字符串
+function foo(m,n,y){
+  console.log(m,n,y);
+//输出[ '我是', '身高', '米' ] inwind 18.8
+}
+const name = "inwind"
+const height = 18.8
+foo`我是${name}身高${height}米
+```
+## 函数参数的默认值
+基本的就不提了，说一些细节
+```
+函数的length
+function foo(a,b,c="1.88"){
+  
+}
+console.log(foo.length);
+//被设置默认值的参数是不会被算的函数length里的
+```
+## 函数的剩余参数
+```
+function foo(a,b,...args){
+	console.log(args)
+//输出['c','d','e','f','g']
+}
+
+foo("a","b","c","d","e","f","g")
+```
+  
diff --git a/data/blog/hanshudikelihua.mdx b/data/blog/hanshudikelihua.mdx
@@ -0,0 +1,69 @@
+---
+  title: 函数的柯里化
+  date: 2023-12-23T12:48:50Z
+  summary:
+  tags: []
+---
+  
+  ## 柯里化？
+函数的柯里化指的是把一个有多个参数的函数转换成一个只接收部分参数，其他参数由该函数里返回的函数接收的函数
+例：
+```
+function foo(x,y,z){
+  console.log(x+y+z);
+}
+foo(2,3,4)
+
+function bar1(x){
+  return function(y){
+    return function(z){
+      return x+y+z
+    }
+  }
+}
+console.log(bar(2)(3)(4));
+
+//可以写成箭头函数
+const bar2 = (x) =>{
+	return (y)=>{
+		return (z)=>{
+			return x+y+z
+		}
+	}
+}
+
+再简化
+const bar = (x) => (y) => (z) => x + y + z;
+
+console.log(bar(2)(3)(4));
+```
+## 为什么要柯里化
+目的是让各个函数的职责变得单一
+## 实现一个柯里化的工具函数
+```
+function currying(fn) {
+  //返回处理过的柯里化函数
+  function curried1(...args1) {
+    //当参数个数达到传入的参数个数，就执行
+    if (args1.length >= fn.length) {
+      return fn.apply(this,args1)
+    }else{
+      //没有达到，进行递归处理参数
+      return function curried2(...args2){
+        return curried1.apply(this,([...args1,...args2]))
+      }
+    }
+  }
+  return curried1;
+}
+
+function add(x, y, z) {
+  return x + y + z;
+}
+
+let newCurrying = currying(add);
+
+console.log(newCurrying(10)(20)(30));
+//输出60
+```
+  
diff --git a/data/blog/shousipromise（er）.mdx b/data/blog/shousipromise（er）.mdx
@@ -0,0 +1,61 @@
+---
+  title: 手撕promise（二）
+  date: 2023-12-23T12:47:57Z
+  summary:
+  tags: []
+---
+  
+  ## 手撕promise
+```
+const STATUS_PENDING = "pending";
+const STATUS_RESOLVE = "fulfilled";
+const STATUS_REJECT = "rejected";
+
+class Mypromise {
+  constructor(executor) {
+    this.status = STATUS_PENDING;
+    this.value = null;
+    this.reason = null;
+
+    const resolve = (value) => {
+      if (this.status === STATUS_PENDING) {
+        queueMicrotask(()=>{
+          this.status === STATUS_RESOLVE;
+          this.value = value;
+          this.onFulfilled(this.value);
+        })
+      }
+    };
+    const reject = (value) => {
+      if (this.status === STATUS_PENDING) {
+        queueMicrotask(()=>{
+          this.status === STATUS_REJECT;
+          this.value = value;
+          this.onReject(this.value);
+        })
+      }
+    };
+    executor(resolve, reject);
+  }
+
+  then(onFulfilled, onReject) {
+    this.onFulfilled = onFulfilled;
+    this.onReject = onReject;
+  }
+}
+
+const promise = new Mypromise((resolve, reject) => {
+    resolve("测试resolve")
+    reject("测试reject")
+});
+
+promise.then(
+  (res) => {
+    console.log(res);
+  },
+  (err) => {
+    console.log(err);
+  }
+);
+```
+  
