uniapp项目实践总结(二十一)日常开发方法汇总

导语：在跨端应用的日常的开发过程中|经常要用到一些全局通用方法|下面就整理一下我经常用的方法|仅供参考。

目录

• 路由拦截
• 数据处理
• 文本转换
• 禁用手势
• 缓存管理
• 权限列表
• 系统通知
• 案例展示

路由拦截

主要是uni.addInterceptor添加拦截器和uni.removeInterceptor移除拦截器两个 API 实现。

• 添加拦截器

// 添加拦截器
uni.request({
   
  url: "request/login", //仅为示例|并非真实接口地址。
  success: (res) => {
   
    console.log(res.data);
    // 打印： {code:1,...}
  },
});

uni.addInterceptor("request", {
   
  invoke(args) {
   
    // request 触发前拼接 url
    args.url = "https://www.example.com/" + args.url;
  },
  success(args) {
   
    // 请求成功后|修改code值为1
    args.data.code = 1;
  },
  fail(err) {
   
    console.log("interceptor-fail", err);
  },
  complete(res) {
   
    console.log("interceptor-complete", res);
  },
});

uni.addInterceptor({
   
  returnValue(args) {
   
    // 只返回 data 字段
    return args.data;
  },
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

• 删除拦截器

uni.removeInterceptor("request");
1

例如：检测登录

• 检测路由权限

// scripts/utils.js
// 检测登录
function checkLogin(url) {
   
  // 登录白名单
  let noLogin = ["/pages/index/open-app", "/pages/index/chat"],
    result = !noLogin.includes(url),
    token = uni.getStorageSync("token");
  if (result && !token) {
   
    return true;
  }
  return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 添加路由拦截器

import utils from "./scripts/utils.js";

uni.addInterceptor("navigateTo", {
   
  invoke(e) {
   
    console.log(e);
    let isLogin = utils.checkLogin(e.url);
    if (isLogin) {
   
      utils.navigate({
   
        type: "redir",
        url: `/pages/index/chat?redirectUrl=${
     e.url}`,
      });
      return false;
    }
    return true;
  },
  success(res) {
   
    console.log("success:", res);
  },
  fail(err) {
   
    console.log("fail:", err);
  },
  complete(doc) {
   
    console.log("complete:", doc);
  },
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

数据处理

敏感词过滤替换方法

有时候涉及评论等方面的内容|需要对敏感词进行过滤|下面就是一个简单的方法来检测并且过滤敏感词。

• 中文分词方法封装

// /scripts/utils
function mineJieba(str) {
   
  class WordTree {
   
    root = null;
    stop = {
   
      你: 1,
      我: 1,
      它: 1,
    };
    constructor() {
   
      this.root = new NodeAs(null);
    }

    // 将unicode转成utf-8的三字节
    toBytes(word) {
   
      let result = [];
      for (let i = 0; i < word.length; i++) {
   
        let code = word.charCodeAt(i);
        if (code < 0x80) {
   
          result.push(code);
        } else {
   
          result = result.concat(this.toUTF8(code));
        }
      }
      return result;
    }

    toUTF8(code) {
   
      let byte1 = 0xe0 | ((code >> 12) & 0x0f),
        byte2 = 0x80 | ((code >> 6) & 0x3f),
        byte3 = 0x80 | (code & 0x3f);
      return [byte1, byte2, byte3];
    }

    toUTF16(b1, b2, b3) {
   
      let byte1 = (b1 << 4) | ((b2 >> 2) & 0x0f),
        byte2 = ((b2 & 0x03) << 6) | (b3 & 0x3f),
        utf16 = ((byte1 & 0x00ff) << 8) | byte2;
      return utf16;
    }

    // 添加每个词到trie
    add(word) {
   
      let node = this.root,
        bytes = this.toBytes(word),
        len = bytes.length;
      for (let i = 0; i < len; i++) {
   
        let c = bytes[i];
        if (!(c in node.childs)) {
   
          node.childs[c] = new NodeAs(c);
        }
        node = node.childs[c];
      }
      node.asWord();
    }

    // 按字节在trie树中搜索
    search(bytes) {
   
      let node = this.root,
        len = bytes.length,
        result = [],
        word = [],
        j = 0;
      for (let i = 0; i < len; i++) {
   
        let c = bytes[i],
          childs = node.childs;
        if (!(c in childs)) {
   
          return result;
        }

        if (c < 0x80) {
   
          word.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88