function init() {
    switchBar()
    closeDialog()
    openDialog()
    handleSearch()
    handleLoadMore()
    
}

function switchBar(){
//balabala
}

function closeDialog(){
//balabala
}

function openDialog(){
//balabala
}

function handleSearch(){
//balabala
}

functuon handleLoadMore(){
//balabala
}

function initListDom(){
//balabala
}

init()

function initListDom(){
    let liDomStr = ''
    listArr.forEach(el=>{
        liDomStr += `
            <li>
                ${el.tradeName}
            </li>
        `
    })
    listDom.innerHTML = liDomStr
}

import md5 from './md5'
const app = getApp()
const WX = app.proxy()
module.exports = {
  /**
    * 默认post请求，将小程序的request封装成promise，解决回调嵌套过深的问题
    * @param {String} url 请求路径
    * @param {Object} params 请求参数
    * @param {String} token 身份认证信息标识
    */
  http(url, params) {
    //时间戳
    const requestTimestamp = new Date().getTime();
    //唯一的id
    const requestId = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
      let r = Math.random() * 16 | 0,
        v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    })

    //生成签名
    const paramsArr = Object.keys(params)
    let signStr = ''
    //ASCII排序参数
    paramsArr.sort()
    paramsArr.forEach(el=>{
      signStr += `${el}=${params[el] || ''}&`
    })
    const key = '' //与服务端协商好的key
    //最掉最后一个参数的&
    signStr = signStr.slice(0,-1) + key
    const sign = md5(signStr).toUpperCase()

    const header = {
      'content-type': 'application/json',
      requestTimestamp,
      requestId,
      sign
    }

    //如果token存在，写入请求头
    const userInfo = wx.getStorageSync("userInfo")
    userInfo.token && Object.assign(header, { requestToken: userInfo.token })

    return WX.request({
      url,
      data: params,
      header,
      method: 'POST',
      dataType: 'json',
      responseType: 'text',
    }).then(res => {
      if (res.statusCode == 200) {
        return res.data
      }
      app.toast(res.statusCode)
      return res
    }).catch(err => {
      app.toast(res.statusCode)
      return err
    })
  }

}

import { http } from './http'

const baseUrl = 'http://localhost:3000'//请求的域名

module.exports = {
    //测试
    test(params = { name }) {
        return http(baseUrl + "/api/test", params)
    },
    getUserInfo(params = { code }) {
        return http(baseUrl + "/api/wxLogin", params)
    },
}

import api from "../../utils/api"

onLoad() {
        api.test({name:"kjs"}).then((res)=>{
            console.log(res);
        })
    },

    //生成签名
    const paramsArr = Object.keys(params)
    let signStr = ''
    //ASCII排序参数
    paramsArr.sort()
    paramsArr.forEach(el=>{
      signStr += `${el}=${params[el] || ''}&`
    })
    const key = '' //与服务端协商好的key
    //最掉最后一个参数的&
    signStr = signStr.slice(0,-1) + key
    const sign = md5(signStr).toUpperCase()


``

5. 时间戳
为了防止DDOS的攻击，增加时间戳的请求时间标识来让服务端判断，但是客户端的时间并不可靠

const requestTimestamp = new Date().getTime();

 window.location.href= 'https://github.com/login/oauth/authorize?client_id=50ab343567bd310005df&redirect_uri=http://127.0.0.1:9000'

const code = this.getUrlParams('code')
if(!code) return
const res = await api.sendAuthCode(code)

router.post('/auth', async (req, res, next) => {
    const { code } = req.body
    if (!code) return
    const clientID = '50ab343567bd310005df'
    const clientSecret = 'deea41faa0a55396c16f7679e16e61c2229f2f6a'
    //根据临时code换取令牌
    const tokenResponse = await axios({
        method: 'post',
        url: 'https://github.com/login/oauth/access_token?' +
            `client_id=${clientID}&` +
            `client_secret=${clientSecret}&` +
            `code=${code}`,
        headers: {
            accept: 'application/json'
        }
    });
    const accessToken = tokenResponse.data.access_token;
    if(!accessToken){
        return res.json(tokenResponse.data)
    }
    //使用令牌请求gitHub的接口
    const result = await axios({
        method: 'get',
        url: `https://api.github.com/user`,
        headers: {
            accept: 'application/json',
            Authorization: `token ${accessToken}`
        }
    });
    res.json(result.data)

    //存储用户数据到数据库
    const query = { id:result.data.id }
    const payload = { ...result.data }
    await authController.insert(query, payload)

})

/**
 * @param {String} key 缓存字段
 * @param {Object} value 缓存内容
 * @param {Number} expires 缓存时间/h
 */
export default class LocalCache {
    constructor() {
        this.now = new Date().getTime()
    }

    setItem(key, value, expires) {
        expires && Object.assign(value, {
            expiresTime: this.now + parseInt(Number(expires) * 60 * 60 * 1000)
        })
        wx.setStorageSync(key, value);
    }

    getItem(key) {
        const value = wx.getStorageSync(key)
        if (!value.expiresTime) return value
        return value.expiresTime >= this.now
            ? value
            : wx.removeStorageSync(key);
    }

    removeItem(key) {
        wx.removeStorageSync(key);
    }

    clearAll() {
        wx.clearStorageSync();
    }
}

//app.js
import LocalCache from './utils/cache'

App({
  localCache : new LocalCache()
})

app.localCache.setItem('test',{name:'kjs'},1)

const data = app.localCache.getItem('test')

app.localCache.removeItem('test')
``

#mongo.conf文件

# 新增的数据库的文件夹路径，根据自己的安装路径填写
dbpath=D:\Program Files\MongoDB\Server\4.2\data
# 新增的日志记录文件
logpath=D:\Program Files\MongoDB\Server\4.2\log\mongo.log
#错误日志采用追加模式
logappend=true
#启用日志文件，默认启用
journal=true
#这个选项可以过滤掉一些无用的日志信息，若需要调试使用请设置为false
quiet=true
#端口号 默认为27017
port=27017

mongod.exe --config "//此处为第一步配置的mongo.conf文件的路径" --install 

net start mongodb
//显示启动成功即可通过 http://localhost:27017/ 访问

mongod --config "//此处为第一步配置的mongo.conf文件的路径 + mongo.conf"  --install --serviceName "mongodb"

net start mongodb 

$ npm install --save-dev jest @vue/test-utils

// package.json
{
  "scripts": {
    "test": "jest"
  }
}

 // ...
  "jest": {
    "moduleFileExtensions": [
      "js",
      "json",
      // 告诉 Jest 处理 `*.vue` 文件
      "vue"
    ],
    "transform": {
      // 用 `vue-jest` 处理 `*.vue` 文件
      ".*\\.(vue)$": "vue-jest"
    }
  }

npm i - D @babel/core @babel/preset-env babel-core@^7.0.0-bridge.0 babel-jest

//.babelrc
{
    "presets": [["@babel/preset-env", { "modules": false }]],
    "env": {
      "test": {
        "presets": [["@babel/preset-env", { "targets": { "node": "current" } }]]
      }
    }
  }


//package.json
{
  // ...
  "jest": {
    // ...
    "transform": {
      // ...
      // 用 `babel-jest` 处理 js
      "^.+\\.js$": "<rootDir>/node_modules/babel-jest"
    }
    // ...
  }
}

<template>
  <div>
    {{ count }}
    <button @click="increment">自增</button>
  </div>
</template>

<script>
  export default {
    data() {
      return {
        count: 0
      }
    },

    methods: {
      increment() {
        this.count++
      }
    }
  }
</script>

import Vue from 'vue'
import { shallowMount } from '@vue/test-utils'
import Counter from '../src/Counter.vue'

describe('Counter.vue', () => {
  it('increments count when button is clicked', async () => {
    const wrapper = shallowMount(Counter)
    wrapper.find('button').trigger('click')
    await Vue.nextTick()
    expect(wrapper.find('div').text()).toMatch('1')
  })
})

npm run test

 "window": {
    "navigationStyle":"custom"
  },

//navBar.js
const app = getApp()
const { navBarInfo  } = app.globalData
//整个头部的高度 = 导航条的高度+上边距+下边距
const topHeight = navBarInfo.height + navBarInfo.paddingTop + navBarInfo.paddingBottom
 

 wx.login({
            timeout:10000,
            success: (res) => {
                wx.request({
                    url: '/api/getOpenid',
                    data: {code: res.code},
                    header: {'content-type':'application/json'},
                    method: 'POST',
                    dataType: 'json',
                    responseType: 'text',
                    success: (result) => {
                        wx.request({
                            url: '/api/getUserInfo',
                            data: {},
                            header: {'content-type':'application/json'},
                            method: 'GET',
                            dataType: 'json',
                            responseType: 'text',
                            success: (res) => {
                                wx.setStorage({
                                    key: 'userInfo',
                                    data: res.data,
                                    success: (result) => {
                                        
                                    },
                                    fail: () => {},
                                    complete: () => {}
                                });
                                  
                            },
                            fail: () => {},
                            complete: () => {}
                        });
                          
                    },
                    fail: () => {},
                    complete: () => {}
                });
                  
            },
            fail: () => {},
            complete: () => {}
        });

  /**
   * 传入小程序的api，转成promise
   * 第一版，传入整个小程序的api函数
   * @param {Function} fn 小程序的api 
   * @return {Function} 返回的promise函数
   */
  promisify: (fn) => {
    return (args = {}) => {
      return new Promise((resovled, rejected) => {
        args.success = res => {
          resovled(res)
        }
        args.fail = err => {
          rejected(err)
        }
        fn(args)
      })
    }
  },

//使用
const wxLogin = promisify(wx.login)
const wxRequest = promisify(wx.request)
const wxSetStorage = promisify(wx.setStorage)
wxLogin()
  .then(res => {
    return wxRequest({
      url: "/api/getOpenid",
      data: { code: res.code },
      header: { 'content-type': 'application/json' },
      method: 'GET',
      dataType: 'json',
      responseType: 'text',
    })
  })
  .then(res => {
    return wxRequest({
      url: "/api/getUserInfo",
      data: { openid: res.openid },
      header: { 'content-type': 'application/json' },
      method: 'GET',
      dataType: 'json',
      responseType: 'text',
    })
  })
  .then(res => {
    return wxSetStorage({
      key: 'userInfo',
      data: res.data,
    })
  })
  .then(res=>{
    //弹窗提醒 or 做啥都行
  })

  /**
 * 将小程序的api代理成promise形式第二版
 * @return {Object} 返回一个proxy函数，代理wx这个对象
 * 然后当这个代理对象使用小程序api时，会把原生的api转成promise对象
 * @example const WX = proxy() 
 * WX.showToast({title:'666'}).then(res=>WX.showLoading())
 */
  proxy: () => {
    function promisify(fn) {
      return (args = {}) => {
        return new Promise((resovled, rejected) => {
          wx[fn]({
            ...args,
            success: resovled,
            fail: rejected,
          })
        })
      }
    }
    return new Proxy(wx, {
      get: (target, prop) => {
        return promisify(prop)
      }
    })

  }

//使用
const app = getApp()

const WX = app.proxy()
WX.login()
  .then(res => {
    return WX.request({
      url: "/api/getOpenid",
      data: { code: res.code },
      header: { 'content-type': 'application/json' },
      method: 'GET',
      dataType: 'json',
      responseType: 'text',
    })
  })
  .then(res => {
    return WX.request({
      url: "/api/getUserInfo",
      data: { openid: res.openid },
      header: { 'content-type': 'application/json' },
      method: 'GET',
      dataType: 'json',
      responseType: 'text',
    })
  })
  .then(res=>{
    return WX.setStorage({
      key: 'userInfo',
      data: res.data,
    })
  })
  .then(res=>{
    //弹窗提醒 or 做啥都行
  })

async function handleLogin() {
    const app = getApp()
    const WX = app.proxy()
    const res = await WX.login()

    const loginIngo = await WX.request({
        url: "/api/getOpenid",
        data: { code: res.code },
        header: { 'content-type': 'application/json' },
        method: 'GET',
        dataType: 'json',
        responseType: 'text',
    })

    const userInfo = await WX.request({
        url: "/api/getUserInfo",
        data: { openid: loginIngo.openid },
        header: { 'content-type': 'application/json' },
        method: 'GET',
        dataType: 'json',
        responseType: 'text',
    })

    await WX.setStorage({
        key: 'userInfo',
        data: userInfo,
    })

}

//app.json
 "permission": {
    "scope.userLocation": {
      "desc": "你的位置信息将用于小程序定位"
    }
  },
  "requiredBackgroundModes": [
    "location"
  ]

<view class="confirm-dialog" wx:if="{{isShowConfirm}}">
        <view class="inner">
            <text>我们需要您的手机号授权信息</text>
            <view class="confirm-footer">
                <view class="btn" bindtap="handleCancel">
                    拒绝
                </view>
                <button open-type="getPhoneNumber" bindgetphonenumber="getPhoneNumber">
                    确认
                </button>
            </view>
        </view>
    </view>

export default {
    data() {
        return {
            count: 1      
        }
    },
    watch: {
        count(newVal) {
            console.log('count 新值：'+newVal)
        }
    }
}

export default {
    data() {
        return {
            count: 1      
        }
    },
    created() {
        this.$watch('count', function(){
            console.log('count 新值：'+newVal)
        })
    }
}

let unwatchFn = this.$watch('count', function(){
    console.log('count 新值：'+newVal)
})
this.count = 2 // log: count 新值：2
unwatchFn()
this.count = 3 // 没有打印