Une brève discussion sur la façon de s'assurer que chaque page du mini programme est connectée

Comment s'assurer que chaque page de l'applet WeChat a été connectée ? Cet article vous présentera la méthode du mini programme pour vous assurer que chaque page est connectée. J'espère que cela vous sera utile !

Dans un mini programme WeChat, il y a une page d'accueil, une page personnelle, des pages de liste, des pages de détails, etc. La plupart de ces pages peuvent être partagées. Lorsque la page partagée est ouverte par un autre utilisateur, comment cette page garantit-elle que l'utilisateur est connecté ?

Il existe de nombreuses solutions sur Internet qui ajoutent une interception au package de requête. S'il n'y a pas de token, appelez la requête de connexion pour obtenir le token avant de continuer. Il n'y a rien de mal à cette solution. Faites juste attention à une chose. Lorsque plusieurs requêtes sont déclenchées sur une page en même temps, une fois toutes les requêtes interceptées, elles sont placées dans un tableau. Après avoir obtenu le jeton, parcourez simplement le tableau. tableau une requête à la fois.

Mais cette exigence est un peu plus compliquée. Par exemple, pour l'applet d'une chaîne de dépanneurs, la plupart des pages doivent avoir un magasin (car il est nécessaire d'obtenir l'inventaire, le prix, etc. des produits actuels du magasin en fonction du magasin) . Ce magasin appelle le backend en fonction du positionnement actuel obtenu depuis l'interface, il serait trop compliqué de l'encapsuler dans la requête pour le moment.

Solution

Tout d'abord, nous avons remarqué que la connexion et l'obtention du poste sont asynchrones avec notre demande de page. Nous devons nous assurer que la demande de page a lieu après la connexion et l'obtention du poste, mais si nous écrivons. chaque page Encore une fois, la maintenabilité sera trop mauvaise. Nous pouvons donc extraire un moyen de le faire. Le code est donc comme ceci :

const app = getApp()
Page({
  data: {
    logs: []
  },
  onLoad() {
    app.commonLogin(()=>{
        // 处理页页面请求
    })
  }
})

Faire cela semble résoudre notre problème, mais réfléchissez-y à nouveau, si vous voulez en faire plus, comme le traitement unifié de onShareAppMessage pour chaque page, mais je ne veux pas le faire sur chaque page. Réécrivez chaque page. De plus, je souhaite mettre en place moi-même une surveillance pour chaque page.

Autre solution

Nous pouvons voir l'applet WeChat, chaque page est une Page(), puis nous pouvons ajouter un shell à l'extérieur de cette Page, et nous pouvons avoir une MyPage pour remplacer cette Page, sans plus loin, voici le code :

tool.js Code associé

/**
   * 处理合并参数
   */
  handlePageParamMerge(arg) {
    let numargs = arg.length; // 获取被传递参数的数值。
    let data = {}
    let page = {}
    for (let ix in arg) {
      let item = arg[ix]
      if (item.data && typeof (item.data) === 'object') {
        data = Object.assign(data, item.data)
      }
      if (item.methods && typeof (item.methods) === 'object') {
        page = Object.assign(page, item.methods)
      } else {
        page = Object.assign(page, item)
      }
    }
    page.data = data
    return page
  }

  /***
   * 合并页面方法以及数据, 兼容 {data:{}, methods: {}} 或 {data:{}, a:{}, b:{}}
   */
  mergePage() {
    return this.handlePageParamMerge(arguments)
  }

  /**
   * 处理组件参数合并
   */
  handleCompParamMerge(arg) {
    let numargs = arg.length; // 获取被传递参数的数值。
    let data = {}
    let options = {}
    let properties = {}
    let methods = {}
    let comp = {}
    for (let ix in arg) {
      let item = arg[ix]
      // 合并组件的初始数据
      if (item.data && typeof (item.data) === 'object') {
        data = Object.assign(data, item.data)
      }
      // 合并组件的属性列表
      if (item.properties && typeof (item.properties) === 'object') {
        properties = Object.assign(properties, item.properties)
      }
      // 合组件的方法列表
      if (item.methods && typeof (item.methods) === 'object') {
        methods = Object.assign(methods, item.methods)
      }
      if (item.options && typeof (item.options) === 'object') {
        options = Object.assign(options, item.options)
      }
      comp = Object.assign(comp, item)
    }
    comp.data = data
    comp.options = options
    comp.properties = properties
    comp.methods = methods
    return comp
  }

  /**
   * 组件混合 {properties: {}, options: {}, data:{}, methods: {}}
   */
  mergeComponent() {
    return this.handleCompParamMerge(arguments)
  }

  /***
   * 合成带watch的页面
   */
  newPage() {
    let options = this.handlePageParamMerge(arguments)
    let that = this
    let app = getApp()

    //增加全局点击登录判断
    if (!options.publicCheckLogin){
      options.publicCheckLogin = function (e) {
        let pages = getCurrentPages()
        let page = pages[pages.length - 1]
        let dataset = e.currentTarget.dataset
        let callback = null

        //获取回调方法
        if (dataset.callback && typeof (page[dataset.callback]) === "function"){
          callback = page[dataset.callback]
        }
        // console.log('callback>>', callback, app.isRegister())
        //判断是否登录
        if (callback && app.isRegister()){
          callback(e)
        }
        else{
          wx.navigateTo({
            url: '/pages/login/login'
          })
        }
      }
    }

    const { onLoad } = options
    options.onLoad = function (arg) {
      options.watch && that.setWatcher(this)
      onLoad && onLoad.call(this, arg)
    }

    const { onShow } = options
    options.onShow = function (arg) {
      if (options.data.noAutoLogin || app.isRegister()) {
        onShow && onShow.call(this, arg)
        //页面埋点
        app.ga({})
      }
      else {
        wx.navigateTo({
          url: '/pages/login/login'
        })
      }
    }

    return Page(options)
  }

  /**
   * 合成带watch等的组件
   */
  newComponent() {
    let options = this.handleCompParamMerge(arguments)
    let that = this
    const { ready } = options
    options.ready = function (arg) {
      options.watch && that.setWatcher(this)
      ready && ready.call(this, arg)
    }
    return Component(options)
  }

  /**
    * 设置监听器
    */
  setWatcher(page) {
    let data = page.data;
    let watch = page.watch;
    Object.keys(watch).forEach(v => {
      let key = v.split('.'); // 将watch中的属性以'.'切分成数组
      let nowData = data; // 将data赋值给nowData
      for (let i = 0; i < key.length - 1; i++) { // 遍历key数组的元素，除了最后一个！
        nowData = nowData[key[i]]; // 将nowData指向它的key属性对象
      }

      let lastKey = key[key.length - 1];
      // 假设key===&#39;my.name&#39;,此时nowData===data[&#39;my&#39;]===data.my,lastKey===&#39;name&#39;
      let watchFun = watch[v].handler || watch[v]; // 兼容带handler和不带handler的两种写法
      let deep = watch[v].deep; // 若未设置deep,则为undefine
      this.observe(nowData, lastKey, watchFun, deep, page); // 监听nowData对象的lastKey
    })
  }

  /**
   * 监听属性 并执行监听函数
   */
  observe(obj, key, watchFun, deep, page) {
    var val = obj[key];
    // 判断deep是true 且 val不能为空 且 typeof val===&#39;object&#39;（数组内数值变化也需要深度监听）
    if (deep && val != null && typeof val === &#39;object&#39;) {
      Object.keys(val).forEach(childKey => { // 遍历val对象下的每一个key
        this.observe(val, childKey, watchFun, deep, page); // 递归调用监听函数
      })
    }
    var that = this;
    Object.defineProperty(obj, key, {
      configurable: true,
      enumerable: true,
      set: function (value) {
        if (val === value) {
          return
        }
        // 用page对象调用,改变函数内this指向,以便this.data访问data内的属性值
        watchFun.call(page, value, val); // value是新值，val是旧值
        val = value;
        if (deep) { // 若是深度监听,重新监听该对象，以便监听其属性。
          that.observe(obj, key, watchFun, deep, page);
        }
      },
      get: function () {
        return val;
      }
    })
  }

Code de la page :

app.tool.newPage({
  data: {
    // noAutoLogin: false
  },
  onShow: function () {
    // 在这里写页面请求逻辑
  }
}

Le dernier code

est exécuté en ligne depuis longtemps. Vous pouvez suivre le package newPage dans l'outil. . Ajoutez vos propres besoins. En bref, je suis ici pour vous donner une idée. Si vous avez une meilleure idée, partagez-la.

【Recommandations d'apprentissage associées : Tutoriel de développement de mini-programmes】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!