mounted() {
  window.addEventListener('resize', this.resizeHandler)
},
destroyed() {
  window.removeEventListener('resize', this.resizeHandler)
},
methods:{
  resizeHandler(){
    // do something
  }
}

watch: {
  screenWidth(val) {
    // 为了避免频繁触发resize函数导致页面卡顿，使用定时器
    if (!this.timer) {
      // 一旦监听到的screenWidth值改变，就将其重新赋给data里的screenWidth
      this.screenWidth = val
      this.timer = true
      const that = this
      setTimeout(function() {
        // 打印screenWidth变化的值
        console.log(that.screenWidth)
        that.timer = false
        // do something
      }, 400)
    }
  }
},
mounted () {
  // 监听页面大小变化
  const that = this
  window.onresize = () => {
    return (() => {
      window.screenWidth = document.body.clientWidth
      that.screenWidth = window.screenWidth
    })()
  }
}

//先引入
//如果项目使用了element-ui，可以直接引用，或者copy一份放在自己的代码里
import { addResizeListener, removeResizeListener } from 'element-ui/src/utils/resize-event';

export default {
  mounted(){
    //可以在mounted这个钩子里初始化事件
    addResizeListener(this.$el, this.resizeListener);
  },
  methods:{
    resizeListener(){
      //do something
    }
  },
  //生命周期结束时销毁事件
  destroyed() {
    if (this.resizeListener) removeResizeListener(this.$el, this.resizeListener);
  }
}

import fmtEvent from "mini-ali-ui-rpx/es/_util/fmtEvent";
const noop = function noop() {};
Component({
  mixins: [],
  data: {
    ctx: null,
    points: [],
    signImage: ''
  },
  props: {
    show:false,
    animation:true,
    zIndex:100,
    title:'手写签名',
    cancelButtonText:'取消',
    confirmButtonText:'完成',
    onCancel:noop,
    onConfirm:noop,
    width: 300,
    height: 225,
    dpr: 2
  },
  didMount() {
    //获得Canvas的上下文
    this.data.ctx = dd.createCanvasContext('sign');
    //设置线的颜色
    this.data.ctx.setStrokeStyle("#000");
    //设置线的宽度
    this.data.ctx.setLineWidth(3);
    //设置线两端端点样式更加圆润
    this.data.ctx.setLineCap('round');
    //设置两条线连接处更加圆润
    this.data.ctx.setLineJoin('round');
    this.data.ctx.scale(this.props.dpr,this.props.dpr)
    this.data.ctx.save()
  },
  didUpdate() {},
  didUnmount() {},
  methods: {
    // 画布的触摸移动开始手势响应
    start (e) {
      //获取触摸开始的 x,y
      // this.data.ctx.save()
      console.log(e)
      let point = { x: e.changedTouches[0].x, y: e.changedTouches[0].y }
      this.$spliceData({points: [0, 0 ,point ]})
    },
    // 画布的触摸移动手势响应
    move (e) {
      let point = { x: e.touches[0].x, y: e.touches[0].y }
      this.$spliceData({points: [this.data.points.length, 0 ,point ]})
      if (this.data.points.length >= 2) {
        this.draw();
      }
    },
    // 画布的触摸移动结束手势响应
    end (e) {
      // console.log("触摸结束",e);
      //清空轨迹数组
      this.setData({
        points: []
      })
      this.data.ctx.save()
    },
    // 画布的触摸取消响应
    cancel (e) {
      console.log("触摸取消" + e);
    },
    // 画布的长按手势响应
    tap(e) {
      console.log("长按手势" , e);
    },
    error(e) {
      console.log("画布触摸错误" + e);
    },
    //绘制
    draw() {
      let point1 = this.data.points[0];
      let point2 = this.data.points[1];
      this.$spliceData({points: [0, 1 ]})
      this.data.ctx.moveTo(point1.x, point1.y);
      this.data.ctx.lineTo(point2.x, point2.y);
      this.data.ctx.stroke();
      this.data.ctx.draw();
    },
    //清除操作
    clearClick() {
      //清除画布
      // console.log(this.data.points)
      this.data.ctx.save();
      //非常重要,没有就会有问题
      this.data.ctx.beginPath()
      this.data.ctx.clearRect(0, 0,this.props.width, this.props.height);

      this.data.ctx.draw();
    },
    //保存图片
    saveClick() {
      const that = this;
      this.data.ctx.toTempFilePath({
        success(res) {
          console.log(res)
          that.setData({
            signImage: res.filePath
          })
        },
      });
    },
    onCancel(e){
      const event = fmtEvent(this.props, e);
      this.props.onCancel(event);
    },
    onConfirm(e){
      this.saveClick()
      e.detail.value = this.data.signImage
      const event = fmtEvent(this.props, e);
      this.props.onConfirm(event);
    },
  },
});

const p = Promise.all([p1, p2, p3]);

function sleep(t){
  console.log(t)
  return new Promise(resolve => {
    setTimeout(()=>{
      console.log(t+'运行结束')
      resolve()
    },t)
  })
}
// 这时我需要调用sleep两次,这两次调用需要同时进行,并在两次调用都返回值后打印总运行时间
function f(){
  const start = new Date().getTime()
  Promise.all([sleep(2000),sleep(1000)]).then(res=>{
    const end = new Date().getTime()
    const time = (end - start)/1000
    console.log('总共运行时间为'+time)
  })
}
f()
// > 2000
// > 1000
// > "1000运行结束"
// > "2000运行结束"
// > "总共运行时间为2.001"

async function f(){
  const start = new Date().getTime()
  // 少了.then()的链式调用，代码清晰了不少
  await Promise.all([sleep(2000),sleep(1000)])
  const end = new Date().getTime()
  const time = (end - start)/1000
  console.log('总共运行时间为'+time)
}

async function sleep(t){
  console.log(t)
  await new Promise(resolve => {
    setTimeout(()=>{
      console.log(t+'运行结束')
      resolve()
    },t)
  })
}

const superagent = require('superagent');
const NUM_RETRIES = 3;

async function test() {
  let i;
  for (i = 0; i < NUM_RETRIES; ++i) {
    try {
      await superagent.get('http://google.com/this-throws-an-error');
      break;
    } catch(err) {}
  }
  console.log(i); // 3
}

test();

setTimeout(function() {
  console.log(1)
}, 0);
new Promise(function executor(resolve) {
  console.log(2);
  for( var i=0 ; i<10000 ; i++ ) {
    i == 9999 && resolve();
  }
  console.log(3);
}).then(function() {
  console.log(4);
});
console.log(5);