Answer 1

宏观微观？我记得承诺的执行是在setimeout之前（好像），异步/ AWAIT是基于承诺的

宏观吧，我其实就是比较奇怪，等待前面的代码都跳出了线程吗，还是单纯就等待后面的执行跳出了线程，也可能是我表达有问题，为啥等待以及前面代码的都会先打印然后才是跳出线程执行外面的，最后才执行的await下面的代码。

就像setimeout是1,2,3这样的顺序来的，但是promise是1.1,1.2,promise是微观的，async，await基于promise也大概和promise一样
恩，这个其实是了解的，就是Async/Await的有点没吃透，Await前面的语句 和Await后面的语句，两者间的差异， 就是为啥不是await 的内容 先输出 然后await上面和下面再输出

几乎同样的疑问，，，我搞不懂为什么await下面的代码会在script end之后输出，，我以为是在async2执行完就会执行的 然后才执行 script end，，，，不太懂

Answer 2

var arr2 = ['b','a','c','d','o']
arr2.sort()

输出["a", "b", "c", "d", "o"]，因为没有函数时会进行UTF-16编码的比较，小的排前面，
当需要对数字从大到小排序时，一般要加入函数

var arr = [3, 15, 8, 29, 102, 22];
arr.sort((a,b)=>a-b);

a-b小于0时，会把a和b的位置互换，所以这样排序会把大的数放后面，小的放前面
题目对数字直接用了sort（），没有加函数，会进行UTF-16编码的比较，
所以答案是：
[102, 15, 22, 29, 3, 8]

Answer 3

连续元素分类

// 得到一个两数之间的随机整数，包括两个数在内
function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
}
// 随机生成10个整数数组, 排序, 去重
let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 99) });
initArr.sort((a, b) => { return a - b });
initArr = [...(new Set(initArr))];

// 连续元素分类放入数组
let continueArr = [], tempArr = [];
initArr.map((e, index) => {
    tempArr.push(e);
    if (initArr[index+1] !== ++e) {
        continueArr.push(tempArr);
        tempArr = [];
    }
});
console.log(continueArr);

学到了 Array.from 竟然还有第二个参数

还有第三个参数，哈哈哈哈哈

Answer 4

监听dom的value变化 去更新 obj
obj的数据发生变化 去更新 dom

---

普通简易版本：

    名字：<input type="text"><br/>
    你的名字: <p></p>


    <script type="text/javascript">
      var obj = {
        name: ''
      }
      Object.defineProperty(obj, 'name', {
        set: function(value) {
          document.getElementById('name').value = value
          document.getElementById('pName').innerHTML = value
        }
      })
      document.getElementById('name').addEventListener('input', function(e){
        obj.name = e.target.value
      })

    </script>

proxy版本 好像没啥特殊的:

    名字：<input type="text"><br/>
    你的名字: <p></p>


    
    <script type="text/javascript">
      // Proxy
      var obj = {
        name: ''
      }
      var proxyObj = new Proxy(obj, {
        get: function(target, key, receiver) {
          return Reflect.get(target, key, receiver)
        },
        set: function(target, key, value, receiver) {
          if (key === 'name') {
            document.getElementById('name').value = value
            document.getElementById('pName').innerHTML = value
          }
          return Reflect.set(target, key, value, receiver)
        }
      })

      document.getElementById('name').addEventListener('input', function(e){
        proxyObj.name = e.target.value
      })
    </script>

Answer 5

@libin1991 楼主，我是否可以贡献一题，实现 JSON.stringify 方法

Answer 6

为什么不能监听数组的变化？

function(obj, key) {
  let val = obj[key];
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get() {
      console.log('in get');
      return val;
    },
    set(newVal) {
      if (newVal === val) {
        return;
      }
      val = newVal;
    }
  });
}
var a = [1, 2, 3]
defineReactive(a, 0)
a[0] = 5 // in get

这有什么问题？

Answer 7

@shizhihua666 以同步的方式实现异步，不是说他是同步

Answer 8

function indexOf(arr,target,start=0){
     if(start<0) start+=arr.length;
     if(start>=arr.length) return -1;
     for(let i=start;i<arr.length;++i){
        if(arr[i]===target) return i;
  }
  return -1;
}