applet d'appel asynchrone Proxy encapsulé micro-canal

Sur le dos est écrit:

Je n'ai pas fait les étudiants dos en ici !

// utils/async.js

function wxPromisify(fn) {
    return async function(args) {
        return new Promise((resolve, reject) => {
            fn({
                ...(args || {}),
                success: res => resolve(res),
                fail: err => reject(err)
            });
        });
    };
}

export function toAsync(names) {
    return (names || [])
        .map(name => (
            {
                name,
                member: wx[name]
            }
        ))
        .filter(t => typeof t.member === "function")
        .reduce((r, t) => {
            r[t.name] = wxPromisify(wx[t.name]);
            return r;
        }, {});
}

// pages/somepage/somepage.js

import { toAsync } = require("../../utils/async");

// ...

const awx = toAsync(["login", "request"]);
await awx.login();
await awx.request({...});

Ce forfait n'a pas encore été?

Cette reprise n'est pas le même paquet. Parce que, dans un petit programme écrit à plusieurs toAsyncappels, vraiment ennuyeux na!

---

Un package peut, appeler partout? Can! Toutes les méthodes sont utilisées pour encapsuler le temps d'initialisation. Cependant, il y aura inévitablement des omissions.

Un package peut, appeler autour, vous n'avez pas besoin d'initialiser?

Can! Proxy recours Grand Dieu:

// utils/asyncjs

function wxPromisify(fn) { ... }    // 前面已经定义过了

export function asyncProxy(target) {
    return new Proxy(target, {
        cache: {},
        get(it, prop) {
            const aFn = this.cache[prop];
            if (aFn) { return aFn; }
            const v = it[prop];
            if (typeof v !== "function") {
                return v;
            }
            return this.cache[prop] = wxPromisify(v);
        }
    });
}

// app.js
import { asyncProxy } from "./utils/async";

App({
    onLaunch: function() {
        wx.awx = asyncProxy(wx);
        // ....
    }
})

// pages/somepage/somepage
// ...
const { awx } = wx;
await awx.login();
await awx.request({...});

---

explication:

Du fait awxun proxy wxobjet, appel awx.login()temps, appelez l'agent est en fait de get(wx, "login")trouver utilisé à la place des wx.loginchoses.

La logique du code ci - dessus, début cachea été utilisé pour trouver wxPromisify()les résultats de l' encapsulation, le cas échéant, retour direct, sinon, le paquet en fonction du premier réseau Promise, stocké cache, puis revenir.

Description du point intuitive, quelque chose comme ceci:

awx.login();
   ^^^^^^
   get(wx, "login")

Enfin, sur une question: comme wx.request()le cas de cette avait une valeur de retour, comment empaqueter?

---

Comme cet article, point a **