chore(ci): blog sync

coderInwind · coderInwind · commit 70f050329f1a · 2023-12-23T12:50:11.000Z
diff --git a/data/blog/Async、Awiteyuanli.mdx b/data/blog/Async、Awiteyuanli.mdx
@@ -0,0 +1,85 @@
+---
+  title: Async、Awite原理
+  date: 2023-12-23T12:50:11Z
+  summary:
+  tags: []
+---
+  
+  我想在异步中调用一个异步，在在这个异步中调用一个异步
+```
+function require(url) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        resolve(url);
+      }, 2000);
+    });
+  }
+
+require("url").then((res) => {
+  require(res + "url2").then((res) => {
+    require(res + "url3").then((res) => {
+      console.log(res);
+    });
+  });
+});
+```
+
+回调地狱产生了，显然这个不是一个好的办法，有更好的办法
+```
+//方案一
+require("url")
+  .then((res) => {
+    return require(res+"url2");
+  })
+  .then((res) => {
+    return require(res+"url3");
+  })
+  .then((res) => {
+    console.log(res);
+  });
+	
+//promise+generator
+function* urlGenerator() {
+  const res1 = yield require("url");
+  const res2 = yield require(res1+"url2")
+  yield require(res2+"url3")
+}
+//怎么还是回调地狱
+const generator = urlGenerator();
+generator.next().value.then((res) =>{
+  generator.next(res).value.then(res=>{
+    generator.next(res).value.then(res=>{
+      console.log(res);
+    })
+  })
+});
+//使用递归来实现
+function execGenerator(generatorFn) {
+  const generator = generatorFn();
+  function exec(res) {
+    const result = generator.next(res);
+    if (result.done) {
+      return result.value;
+    }
+    result.value.then((res) => {
+      exec(res);
+    });
+  }
+  exec();
+}
+execGenerator(urlGenerator)
+
+//其实并不需要那么的复杂
+async function urlGenerator() {
+  const res1 = await require("url");
+  const res2 = await require(res1 + "url2");
+  const res3 = await require(res2 + "url3");
+  console.log(res3);
+}
+
+urlGenerator()
+```
+## async/awite
+async/awite的本质就是promise和generator
+async里面的被awite的异步代码会同步执行
+  
diff --git a/data/blog/ES6dixin特xing（er）.mdx b/data/blog/ES6dixin特xing（er）.mdx
@@ -0,0 +1,64 @@
+---
+  title: ES6的新特性（二）
+  date: 2023-12-23T12:49:13Z
+  summary:
+  tags: []
+---
+  
+  ## Symbol
+```
+//symbol能生成一个独一无二的值,可以给该值添加一个描述
+let a = Symbol("ada")
+console.log(a.description);
+```
+symbol可以作为对象的key
+symbol.for()/symbol.keyfor()
+## 数据结构Set
+set里面不会出现相同的元素，可以用于数组去重
+```
+const set = new Set()
+//add：添加一个元素
+set.add(1)
+set.add(2)
+set.add(1)
+console.log(set);
+//输出Set(2) { 1, 2 }
+
+//delete：删除一个元素
+set.delete(1)
+console.log(set);
+//输出Set(1) { 2 }
+
+//clear：清空所有元素
+set.clear()
+console.log(set);
+//Set(0) {  }
+
+//has：是否包含某个元素
+set.has(2)
+//包含返回true，不包含返回false
+```
+## 数据结构weakSet
+？？？weakSet和set有啥区别？
+weakSet只能存放对象类型，并且对对象的引用是个弱引用，没办法做遍历操作
+？？？什么是弱引用？
+对于浏览器而言，弱引用相当于这个指向不存在，还是会被垃圾回收
+弱引用存在的意义在于能让其访问到相应的值
+## 数据结构Map
+用于存储映射关系，对象中是不允许对象类型作为key的，而在map中可以
+```
+let obj1 = {name:"inwind"}
+let obj2 = {height:18.8}
+
+let map = new Map([[obj1,"123"],[obj2,"456"]])
+console.log(map);
+//输出Map(2) { { name: 'inwind' } => '123', { height: 18.8 } => '456' }
+```
+方法map.set()、map.get、map.has()、map.delete()、map.clear()、
+### map和object有什么区别
+map是可迭代对象，object不是，可以用Object.entries()、Object.keys()、Object.value进行迭代
+map的key可以是任意值，而object的值只能是string或者symbol
+map里存放有几个键值对可以通过Map.size轻松获取，而object只能自行获取
+## 数据结构weakMap
+key只能是对象，存放的对象的引用是个弱引用
+  
diff --git a/data/blog/ES6dixin特xing（san）.mdx b/data/blog/ES6dixin特xing（san）.mdx
@@ -0,0 +1,131 @@
+---
+  title: ES6的新特性（三）
+  date: 2023-12-23T12:49:31Z
+  summary:
+  tags: []
+---
+  
+  ## Array.prototype.includes
+判断数组中是否存在该元素
+arr.includes(判断的元素,从第几个下标开始)
+## 平方运算符
+计算3的3次方
+3**3
+## Object.value()
+之前有一个Object.key方法能拿到对象所有的key
+这个是与之对应的拿到对象所有的value
+## Object.entries()
+将对象的键值对放入数组
+```let obj = {
+  name:"inwind",
+  age:18,
+  height:18.8
+}
+
+console.log(Object.entries(obj));
+```
+## String.prototype.padStart和String.prototype.padEnd
+```const text = "我是inwind"
+const newtext = text.padStart(15,"*")
+//使用*将字符串从开头填充到十五位
+console.log(newtext);
+
+const text = "我是inwind"
+const newtext = text.padEnd(15,"*")
+//使用*将字符串从结尾填充到15位
+console.log(newtext);
+```
+## Array.prototype.flat和Array.prototype.flatMap
+```
+const arr = [1,[2,3],[4,5,[6,7],8],9,10]
+//给对应数组降维，默认值是1
+const newArr = arr.flat()
+console.log(newArr);
+```
+flatMap顾名思义，flat和map的结合。。。
+## Object.fromEntries
+之前的文章提到object.entrises可以把一个对象键值对转化为数组并由数组包裹
+而fromEntries可以将这种格式转回成对象
+```
+const obj = {name:"inwind",age:18,height:1.88}
+const newObj = Object.entries(obj)
+console.log(newObj);
+//输出[ [ 'name', 'inwind' ], [ 'age', 18 ], [ 'height', 1.88 ] ]
+
+const oldObj = Object.fromEntries(newObj)
+console.log(oldObj);
+//输出{ name: 'inwind', age: 18, height: 1.88 }
+```
+## String.prototype.trimStart和String.prototype.trimEnd
+与trim同理，去除字符串前面的空格or后面的空格
+## bigInt
+Number.MAX_SAFE_INTEGER可以获取到js中数的最大值为9007199254740991，不能再继续往上计算
+而使用bigInt类型可以，
+```
+const bigInt = 9007199254740991n
+console.log(Number(bigInt+7n));
+```
+## ??逻辑空运算符
+```
+let a = null
+//当前面一个为null或undfined时，执行后面一个
+let b = a ?? "default value"
+
+console.log(b);
+```
+## 可选链
+```
+let obj = {
+  name:"inwind",
+  friend:{
+    name:"katom",
+  }
+}
+//当查找不到某个值时，返回undfined
+console.log(obj.friend?.name);
+console.log(obj.friend?.age);
+```
+## globalThis
+获取当前的全局对象
+在浏览器环境下获取的是window，在node环境下获取的是global
+## finalizationRegistry类
+你可以在里面注册一个对象，在对象被GC垃圾回收时时，会回调传入的函数
+```
+let obj = {name:"inwind",height:18.8}
+    const finalization = new FinalizationRegistry(()=>{
+      console.log("被销毁了");
+    })
+//注册一个对象，可以传入一个值，这个值被作为回调函数的参数
+  finalization.register(obj,"value")
+  obj = null
+```
+## weakRef对引用类型建立一个弱引用
+```
+//用以上代码来进行验证，多添加一个引用，该对象依旧被销毁，可见这是一个弱引用
+let obj = { name: "inwind", height: 18.8 };
+let info = new WeakRef(obj)
+const finalization = new FinalizationRegistry(() => {
+	console.log("被销毁了");
+});
+
+finalization.register(obj, "value");
+obj = null;
+```
+如果想获取弱引用对象的属性，不能直接获取，
+如获取name,要使用info.deref().name获取
+## 新的运算符
+* 1、||= 逻辑或赋值运算
+* 2、&&= 逻辑与赋值运算
+* 3、??= 逻辑空赋值运算
+```
+let a = undefined
+a||="default value"
+//相当于a=a||"default value"
+
+a&&="default value"
+//相当于a=a&&"default value"
+
+a??="default value"
+//相当于a=a??"default value"
+```
+  
diff --git a/data/blog/diedaiqiheshengchengqi.mdx b/data/blog/diedaiqiheshengchengqi.mdx
@@ -0,0 +1,102 @@
+---
+  title: 迭代器和生成器
+  date: 2023-12-23T12:49:47Z
+  summary:
+  tags: []
+---
+  
+  ## 什么是迭代器
+迭代器（iterator）能让我们在某个数据结构上进行遍历的对象
+在 JavaScript 中，迭代器是一个对象，它定义一个序列，并在终止时可能返回一个返回值。 更具体地说，迭代器是通过使用 next() 方法实现迭代器协议（Iterator protocol）的任何一个对象，该方法为无参数或者一个参数的函数
+该方法返回具有两个属性的对象： value，这是序列中的 next 值；和 done ，如果已经迭代到序列中的最后一个值，则它为 true 。如果 value 和 done 一起存在，则它是迭代器的返回值。
+一旦创建，迭代器对象可以通过重复调用next（）显式地迭代。 迭代一个迭代器被称为消耗了这个迭代器，因为它通常只能执行一次。 在产生终止值之后，next（）返回{done：true}。
+```
+//实现一个迭代器
+const arr = ['aaa','bbb','ccc','ddd']
+
+let i = 0
+const iterator = {
+  next:function(){
+    if(i<arr.length){
+      return {done:false,value:arr[i++]}
+    }else{
+      return {done:true,value:undefined}
+    }
+  }
+}
+
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+```
+## 可迭代对象
+若一个对象拥有迭代行为（即能返回一个迭代器），比如在 for...of 中会循环哪些值，那么那个对象便是一个可迭代对象。一些内置类型，如 Array 或 Map 拥有默认的迭代行为，而其他类型（比如Object）则没有。
+为了实现可迭代，一个对象必须实现返回一个迭代器，这意味着这个对象（或其原型链中的任意一个对象）必须具有一个带 Symbol.iterator 键（key）的属性。
+```
+const iteratorObj = {
+  arr: ["aaa", "bbb", "ccc", "ddd"],
+  [Symbol.iterator]: function () {
+    let i = 0;
+    //返回一个迭代器
+    return {
+      next:() => {
+        if (i < this.arr.length) {
+          return { done: false, value: this.arr[i++] };
+        } else {
+          return { done: true, value: undefined };
+        }
+      },
+    };
+  },
+};
+
+const iterator = iteratorObj[Symbol.iterator]();
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+//此时就解除了一个之前的疑惑，为什么for of遍历不了一个对象，因为对象不是一个可迭代对象
+for(let item of iteratorObj){
+  console.log(item);
+}
+
+//创建一个数组，数组里会内置有可迭代对象
+let arr = ["aaa", "bbb", "ccc", "ddd"];
+console.log(arr[Symbol.iterator]);
+let iterator = arr[Symbol.iterator]()
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+console.log(iterator.next());
+```
+## 会自动生成迭代器的数据结构或对象
+String、Array、Set、Map、arguments、NodeLsit
+#生成器（generator）
+虽然自定义的迭代器是一个有用的工具，但由于需要显式地维护其内部状态，因此需要谨慎地创建。生成器函数提供了一个强大的选择：它允许你定义一个包含自有迭代算法的函数， 同时它可以自动维护自己的状态。 生成器函数使用 function*语法编写。 最初调用时，生成器函数不执行任何代码，而是返回一种称为Generator的迭代器。 通过调用生成器的下一个方法消耗值时，Generator函数将执行，直到遇到yield关键字。
+上面是 mdn 的解释，通俗的来讲，yield就是形成了一个个断点
+```
+//生成器
+function*generatorFn(){
+
+  console.log("代码执行开始");
+
+  const a = 2
+  yield a
+  
+  const b = 3
+  yield b
+  console.log("代码执行完毕");
+  return "asdasdas"
+}
+
+let generator = generatorFn()
+console.log(generator.next());
+//next()可以传入一个参数，这个参数会作为上一个yield的返回值
+console.log(generator.next());
+console.log(generator.next()); 
+```、
+  
