miniprogram/
├── app.js                  # 应用入口
├── app.json                # 全局配置
├── app.wxss                # 全局样式
├── pages/                  # 页面目录（每个页面一个子目录）
│   ├── index/              # 首页
│   │   ├── index.js
│   │   ├── index.wxml
│   │   ├── index.wxss
│   │   └── index.json
│   └── logs/               # 日志页
│       ├── logs.js
│       ├── logs.wxml
│       ├── logs.wxss
│       └── logs.json
├── components/             # 公共组件
│   └── my-header/
│       ├── my-header.js
│       ├── my-header.wxml
│       ├── my-header.wxss
│       └── my-header.json
├── utils/                  # 工具函数
│   └── util.js
├── images/                 # 本地图片（主包限 2MB）
├── vendor/                 # 第三方 SDK
└── sitemap.json            # SEO 配置

{
  "pages": [
    "pages/index/index",
    "pages/logs/logs",
    "pages/user/index"
  ],
  "window": {
    "navigationBarBackgroundColor": "#ffffff",
    "navigationBarTitleText": "我的小程序",
    "navigationBarTextStyle": "black",
    "backgroundColor": "#f8f8f8",
    "enablePullDownRefresh": false
  },
  "tabBar": {
    "color": "#999999",
    "selectedColor": "#1890ff",
    "backgroundColor": "#ffffff",
    "borderStyle": "black",
    "list": [
      { "pagePath": "pages/index/index", "text": "首页", "iconPath": "images/home.png", "selectedIconPath": "images/home-active.png" },
      { "pagePath": "pages/user/index", "text": "我的", "iconPath": "images/user.png", "selectedIconPath": "images/user-active.png" }
    ]
  },
  "style": "v2",
  "sitemapLocation": "sitemap.json",
  "lazyCodeLoading": "requiredComponents"
}

miniprogram/
├── app.js
├── app.json
├── pages/                  # 主包页面
│   └── index/
├── subpkg/                 # 分包 A（games）
│   ├── pages/
│   │   └── game/
│   └── app.json
├── subpkg2/                # 分包 B（profile）
│   ├── pages/
│   │   └── settings/
│   └── app.json
└── components/            # 主包组件

{
  "pages": [ "pages/index/index" ],
  "subPackages": [
    {
      "root": "subpkg/games",
      "name": "games",
      "pages": [
        { "path": "pages/game/index", "lazyLoad": true }
      ]
    },
    {
      "root": "subpkg/profile",
      "name": "profile",
      "pages": [
        { "path": "pages/settings/index" }
      ]
    }
  ],
  "preloadRule": {
    "pages/index/index": {
      "network": "all",
      "packages": ["subpkg/games"]
    }
  }
}

<!-- 基础绑定 -->
<view>{{ message }}</view>

<!-- 运算表达式 -->
<view>{{ a + b }}</view>
<view>{{ flag ? 'yes' : 'no' }}</view>

<!-- 列表渲染（wx:for） -->
<view wx:for="{{ list }}" wx:key="id">
  {{ index }}: {{ item.name }}
</view>

<!-- 条件渲染（wx:if / wx:elif / wx:else） -->
<view wx:if="{{ score >= 90 }}">优秀</view>
<view wx:elif="{{ score >= 60 }}">及格</view>
<view wx:else>不及格</view>

<!-- 模板引用 -->
<import src="../templates/header.wxml" />
<template is="tpl_name" data="{{ ...tplData }}" />

<!-- 组件引用 -->
<my-component propA="{{ value }}" bindmyevent="onMyEvent" />

<!-- 冒泡事件：bind + 事件名 -->
<view bindtap="onTap">点击我</view>

<!-- 非冒泡事件：catch + 事件名 -->
<view catchtap="onCatchTap">阻止冒泡</view>

<!-- 事件传参：data-* 属性 -->
<view data-id="123" data-name="Alice" bindtap="onTap">传参</view>

<!-- input / textarea 双向绑定 -->
<input value="{{ inputValue }}" bindinput="onInput" />

// 对应 JS
onTap(e) {
  const { id, name } = e.currentTarget.dataset;
  console.log(id, name); // 123, Alice
},
onCatchTap(e) {
  // 不会触发父级冒泡
}

/* 支持的选择器 */
.selector {}              /* 类选择器 */
#id {}                    /* id 选择器 */
view {}                   /* 标签选择器 */
view, .class {}           /* 并集 */
view .child {}            /* 后代 */
view > .child {}          /* 子选择器 */

/* 不支持：通配符 *、属性选择器 [attr]、伪类 */

/* iPhone 6: 1px = 2rpx；750 设计稿宽度等于 375rpx */
.box {
  width: 750rpx;     /* 全屏宽度 */
  height: 200rpx;
  padding: 20rpx;
}

/* 在 app.wxss 中定义全局样式 */
page {
  --primary-color: #1890ff;
  background-color: #f5f5f5;
  font-size: 28rpx;
}

/* 局部页面引用 */
@import "./template.wxss";

/* flex 布局 */
.flex-row {
  display: flex;
  flex-direction: row;
  align-items: center;
  justify-content: space-between;
}

/* 单行省略 */
.ellipsis {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

/* 多行省略 */
.line-clamp-2 {
  display: -webkit-box;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 2;
  overflow: hidden;
}

// app.js
App({
  globalData: {
    userInfo: null,
    baseUrl: 'https://api.example.com'
  },
  onLaunch() {
    console.log('小程序启动');
  }
});

// page.js
Page({
  data: {
    name: '微信小程序',
    count: 0
  },
  onLoad(options) {
    // 页面加载，options 为路由参数
    console.log(options.id);
  },
  onShow() { /* 页面显示 */ },
  onReady() { /* 页面首次渲染完成 */ },
  onHide() { /* 页面隐藏 */ },
  onUnload() { /* 页面卸载 */ },
  onPullDownRefresh() { /* 下拉刷新 */ },
  onReachBottom() { /* 上拉触底 */ },
  methods: {
    addCount() {
      this.setData({ count: this.data.count + 1 });
    }
  }
});

// ❌ 错误：每次都传整个列表
this.setData({ list: newList });

// ✅ 正确：按路径更新（减少数据传输量）
this.setData({ 'list[0].name': '新名字' });

// ✅ 正确：合并更新
this.setData({
  count: this.data.count + 1,
  'user.name': 'Alice',
  'arr[0]': itemData
});

// ✅ 正确：预先合并再 setData（一次合并，一次更新）
const update = {};
update['list[' + index + '].read'] = true;
this.setData(update);

Component({
  properties: {
    title: { type: String, value: '' },
    items: { type: Array, value: [] }
  },
  data: {},
  lifetimes: {
    created() { /* 组件实例创建 */ },
    attached() { /* 组件进入页面节点树 */ },
    ready() { /* 组件布局完成 */ },
    moved() { /* 组件被移动 */ },
    detached() { /* 组件离开页面节点树 */ }
  },
  pageLifetimes: {
    show() { /* 组件所在页面显示 */ },
    hide() { /* 组件所在页面隐藏 */ }
  },
  methods: {
    onTap() { this.triggerEvent('customevent', { value: 123 }); }
  }
});

// behaviors/my_behavior.js
module.exports = Behavior({
  data: { shared: 'shared data' },
  methods: { sharedMethod() { console.log('shared'); } }
});

// 组件中使用
Component({
  behaviors: [require('../behaviors/my_behavior.js')]
});

// async/await（需基础库 2.8+）
async fetchData() {
  try {
    const res = await wx.cloud.callContainer({ path: '/api/list' });
    this.setData({ list: res.data });
  } catch (err) {
    console.error(err);
  }
}

// 解构
const { id, name } = e.currentTarget.dataset;

App({
  onLaunch(options) {
    // 小程序初始化（冷启动）
    // options.scene, options.query, options.path
  },
  onShow(options) {
    // 小程序启动或从后台切回前台
  },
  onHide() {
    // 小程序进入后台（home 键、切换应用）
  },
  onError(error) {
    // 线上错误监听
    console.error(error);
  },
  onPageNotFound(res) {
    // 页面不存在时触发
    wx.redirectTo({ url: 'pages/index/index' });
  },
  onUnhandledRejection(res) {
    // 未处理的 Promise 拒绝
  }
});

Page({
  data: { content: '' },

  onLoad(query) {
    // 页面加载时调用（只触发一次）
    // query: 路由参数
    this.loadData(query.id);
  },

  onShow() {
    // 页面显示（每次切回页面都触发）
  },

  onReady() {
    // 页面初次渲染完成（只触发一次）
  },

  onHide() {
    // 页面隐藏（navigateTo/redirectTo/tab 切换）
  },

  onUnload() {
    // 页面卸载（navigateBack/redirectTo/close）
  },

  onPullDownRefresh() {
    // 下拉刷新（需在 app.json window.enablePullDownRefresh: true）
    this.fetchData().then(() => wx.stopPullDownRefresh());
  },

  onReachBottom() {
    // 上拉触底
    this.loadMore();
  },

  onPageScroll(Object) {
    // 页面滚动（慎用，避免在 scroll-view 中使用）
  },

  onShareAppMessage() {
    // 分享配置
    return { title: '分享标题', path: '/pages/index/index?id=123' };
  },

  onResize() { /* 屏幕旋转 */ },
  onTabItemTap(item) { /* tabBar 点击 */ }
});

Component({
  lifetimes: {
    created() { /* 实例创建，可设置 data */ },
    attached() { /* 节点树挂载完毕 */ },
    ready() { /* 渲染完成 */ },
    moved() { /* 组件被移动 */ },
    detached() { /* 离开节点树 */ }
  },
  // 所在页面生命周期（可选）
  pageLifetimes: {
    show() { /* 页面显示 */ },
    hide() { /* 页面隐藏 */ },
    resize(size) { /* 页面尺寸变化 */ }
  }
});

用户打开小程序
    │
    ▼
app.onLaunch()
    │
    ▼
page.onLoad() ──────────────────────────────────→ 用户切后台
    │                                              │
    ▼                                              ▼
page.onShow()                                  app.onHide()
    │
    ▼
page.onReady()
    │
    ▼
用户交互（可随时触发）
    │
    ├─→ page.onHide() (navigateTo/tab切换)
    │
    ├─→ page.onUnload() (navigateBack/redirectTo)
    │
    ├─→ page.onPullDownRefresh()
    │
    └─→ page.onReachBottom()

<view class="container">
  <view class="card">内容卡片</view>
</view>

<scroll-view
  scroll-y
  scroll-top="{{ scrollTop }}"
  scroll-into-view="{{ toView }}"
  bindscroll="onScroll"
  lower-threshold="100"
  bindscrolltolower="onReachBottom"
>
  <view id="item-100">锚点内容</view>
</scroll-view>

<swiper
  indicator-dots
  autoplay="{{ true }}"
  interval="3000"
  circular
  bindchange="onSwiperChange"
>
  <swiper-item wx:for="{{ banners }}">
    <image src="{{ item.imageUrl }}" mode="aspectFill" />
  </swiper-item>
</swiper>

<movable-area style="width: 300px; height: 300px;">
  <movable-view x="{{ x }}" y="{{ y }}" direction="all" bindchange="onMove">
    可拖动内容
  </movable-view>
</movable-area>

<!-- 开放能力按钮 -->
<button
  open-type="share"
  size="default"
  type="primary"
  plain="{{ false }}"
  disabled="{{ false }}"
  loading="{{ false }}"
  bindgetuserinfo="onGetUserInfo"
>分享</button>

<!-- 微信开放能力列表 -->
<!--
  contact            → 客服消息
  share              → 分享
  getPhoneNumber     → 获取手机号
  getUserInfo        → 获取用户信息
  launchApp          → 打开 App
  openSetting        → 打开设置页
  feedback           → 反馈
  chooseAvatar       → 选择头像
-->

<input
  type="text"
  password="{{ false }}"
  placeholder="请输入"
  value="{{ inputValue }}"
  bindinput="onInput"
  bindfocus="onFocus"
  bindblur="onBlur"
  bindconfirm="onConfirm"
  maxlength="140"
  cursor-spacing="10"
/>

<!-- type 可选：text/number/idcard/digit/safe-password -->

<textarea
  value="{{ content }}"
  placeholder="请输入内容"
  maxlength="500"
  auto-height
  bindinput="onTextareaInput"
  style="min-height: 200rpx;"
/>

<!-- 普通选择器 -->
<picker mode="selector" range="{{ array }}" bindchange="onChange">
  <view>{{ array[index] }}</view>
</picker>

<!-- 时间选择器 -->
<picker mode="time" value="{{ time }}" start="09:00" end="18:00" bindchange="onTimeChange">
  <view>选择时间: {{ time }}</view>
</picker>

<!-- 日期选择器 -->
<picker mode="date" value="{{ date }}" start="2020-01-01" end="2030-12-31" fields="day" bindchange="onDateChange">
  <view>选择日期: {{ date }}</view>
</picker>

<!-- 多列选择器 -->
<picker mode="multiSelector" range="{{ multiArray }}" bindchange="onMultiChange">
  <view>{{ multiArray[0][multiIndex[0]] }} - {{ multiArray[1][multiIndex[1]] }}</view>
</picker>

<checkbox-group bindchange="onCheckboxChange">
  <label wx:for="{{ options }}" wx:key="id">
    <checkbox value="{{ item.id }}" checked="{{ item.checked }}" />
    {{ item.name }}
  </label>
</checkbox-group>

<radio-group bindchange="onRadioChange">
  <label wx:for="{{ options }}" wx:key="id">
    <radio value="{{ item.id }}" />
    {{ item.name }}
  </label>
</radio-group>

<switch checked="{{ switchChecked }}" bindchange="onSwitchChange" />
<slider min="0" max="100" value="{{ sliderVal }}" show-value bindchange="onSliderChange" />

<form bindsubmit="onFormSubmit" bindreset="onFormReset">
  <input name="username" placeholder="用户名" />
  <input name="password" password placeholder="密码" />
  <button form-type="submit">提交</button>
  <button form-type="reset">重置</button>
</form>

onFormSubmit(e) {
  console.log(e.detail.value); // { username: '...', password: '...' }
}

<image
  src="{{ imgUrl }}"
  mode="aspectFill"
  lazy-load="{{ true }}"
  show-menu-by-longpress
  binderror="onImgError"
  bindload="onImgLoad"
/>

<video
  src="{{ videoUrl }}"
  poster="{{ posterUrl }}"
  controls
  autoplay="{{ false }}"
  loop="{{ false }}"
  muted="{{ false }}"
  enable-danmu
  danmu-list="{{ danmuList }}"
  bindtimeupdate="onTimeUpdate"
  bindended="onEnded"
  enable-play-gesture="{{ true }}"
  show-fullscreen-btn
>
</video>

<camera
  device-position="back"
  flash="auto"
  binderror="onCameraError"
  style="width: 100%; height: 400rpx;"
/>
<button bindtap="takePhoto">拍照</button>

const ctx = wx.createCameraContext();
ctx.takePhoto({
  quality: 'high',
  success: (res) => this.setData({ tempPhotoPath: res.tempImagePath })
});

<editor
  id="editor"
  placeholder="输入内容..."
  bindinput="onEditorInput"
  read-only="{{ false }}"
/>

<navigator
  url="/pages/detail/index?id={{ id }}"
  open-type="navigateTo"
  hover-class="none"
>
  跳转详情
</navigator>

<functional-page-navigator
  name="chooseAddress"
  version="develop"
  bindsuccess="onChooseAddressSuccess"
  bindfail="onChooseAddressFail"
>
  选择收货地址
</functional-page-navigator>

<map
  latitude="{{ latitude }}"
  longitude="{{ longitude }}"
  scale="14"
  markers="{{ markers }}"
  polyline="{{ polylines }}"
  circles="{{ circles }}"
  controls="{{ controls }}"
  show-location
  include-points="{{ includePoints }}"
  bindmarkertap="onMarkerTap"
  bindtap="onMapTap"
  style="width: 100%; height: 500rpx;"
/>

// markers 格式
markers: [{
  id: 1,
  latitude: 31.230416,
  longitude: 121.473701,
  title: '上海',
  iconPath: '/images/marker.png',
  width: 30,
  height: 30,
  callout: {
    content: '上海',
    color: '#333',
    fontSize: 14,
    borderRadius: 4,
    padding: 8,
    display: 'ALWAYS',
    bgColor: '#fff'
  }
}]

<icon type="success" size="40" color="#07c160" />
<!-- type: success/success_no_circle/info/warn/waiting/cancel/search/clear -->

<progress percent="60" show-info stroke-width="6" color="#07c160" />

<rich-text nodes="{{ htmlString }}" />

// 支持 HTML string 或 node 数组
this.setData({
  htmlString: '<p style="color:#999">内容</p>'
});

<open-data type="userNickName" lang="zh_CN" />
<open-data type="userAvatarUrl" />
<open-data type="userGender" />
<open-data type="userCity" />

<!-- 需在 app.json 添加 web-view 域名白名单 -->
<web-view src="https://example.com/page.html" bindmessage="onWebViewMessage" />

// 保留当前页面，跳转（非 tabBar）
wx.navigateTo({ url: '/pages/detail/index?id=123' });

// 关闭当前页面，跳转（非 tabBar）
wx.redirectTo({ url: '/pages/detail/index' });

// 跳转 tabBar 页面
wx.switchTab({ url: '/pages/index/index' });

// 关闭所有页面，打开
wx.reLaunch({ url: '/pages/index/index' });

// 返回上一页
wx.navigateBack({ delta: 1 });

// 获取当前页面栈
const pages = getCurrentPages();
const currentPage = pages[pages.length - 1];

// 同步存储
wx.setStorageSync('token', 'abc123');
wx.setStorageSync('user', { name: 'Alice', age: 18 });

// 异步存储
wx.setStorage({ key: 'token', data: 'abc123' });

// 同步读取
const token = wx.getStorageSync('token');
const user = wx.getStorageSync('user');

// 异步读取
wx.getStorage({ key: 'token', success: (res) => console.log(res.data) });

// 同步/异步删除
wx.removeStorageSync('token');
wx.removeStorage({ key: 'token' });

// 清空
wx.clearStorageSync();
wx.clearStorage();

// 获取存储信息
wx.getStorageInfo({
  success: (res) => {
    console.log(res.keys);      // ['token', 'user']
    console.log(res.currentSize); // 当前大小（KB）
    console.log(res.limitSize);    // 限制大小（KB）
  }
});

// ⚠️ 必须在 app.json 配置合法域名（开发阶段可勾选"不校验..."）
wx.request({
  url: 'https://api.example.com/user/profile',
  method: 'GET',
  data: { id: 123 },
  header: {
    'content-type': 'application/json',
    'Authorization': 'Bearer ' + wx.getStorageSync('token')
  },
  success: (res) => {
    if (res.statusCode === 200) {
      this.setData({ profile: res.data });
    } else if (res.statusCode === 401) {
      // token 过期，跳转登录
      wx.redirectTo({ url: '/pages/login/index' });
    }
  },
  fail: (err) => {
    wx.showToast({ title: '网络请求失败', icon: 'none' });
    console.error(err);
  },
  complete: () => {
    this.setData({ loading: false });
  }
});

// ⚠️ request 最大并发 10 个，超过会等待
// ⚠️ 超时时间默认 60s，最长 120s

// utils/request.js
const BASE_URL = 'https://api.example.com';

function request({ url, data, method = 'GET', needAuth = true }) {
  return new Promise((resolve, reject) => {
    const header = { 'content-type': 'application/json' };
    if (needAuth) {
      const token = wx.getStorageSync('token');
      if (!token) return reject({ errMsg: 'no_token' });
      header['Authorization'] = `Bearer ${token}`;
    }

    wx.showLoading({ title: '加载中...' });
    wx.request({
      url: BASE_URL + url,
      data,
      method,
      header,
      success: (res) => {
        if (res.statusCode === 200) {
          resolve(res.data);
        } else if (res.statusCode === 401) {
          wx.removeStorageSync('token');
          wx.redirectTo({ url: '/pages/login/index' });
          reject(res);
        } else {
          wx.showToast({ title: res.data.message || '请求失败', icon: 'none' });
          reject(res);
        }
      },
      fail: reject,
      complete: () => wx.hideLoading()
    });
  });
}

module.exports = { request };

// 获取系统信息
wx.getSystemInfo({
  success: (res) => {
    console.log(res.brand, res.model, res.system);
    console.log(res.statusBarHeight, res.screenHeight);
    console.log(res.windowWidth, res.windowHeight);
    // iPhone X: statusBarHeight=44, 底部安全区需注意
  }
});

// 获取设备信息（更快，不依赖网络）
wx.getDeviceInfo?.(); // 基础库 2.25+

// 剪贴板
wx.setClipboardData({ data: '复制内容' });
wx.getClipboardData({
  success: (res) => console.log(res.data)
});

// 扫码
wx.scanCode({
  onlyFromCamera: false,
  success: (res) => console.log(res.result)
});

// 振动
wx.vibrateShort({ type: 'light' }); // 短振动
wx.vibrateLong(); // 长振动（400ms）

// 屏幕亮度
wx.setScreenBrightness({ value: 0.5 });
wx.getScreenBrightness({
  success: (res) => console.log(res.value)
});

// 保持屏幕常亮
wx.setKeepScreenOn({ keepScreenOn: true });

// 打电话
wx.makePhoneCall({ phoneNumber: '400-xxx-xxxx' });

// 发送邮件（需 App 配合）
wx.env && wx.env.openEmail?.();

// 获取当前位置
wx.getLocation({
  type: 'wgs84',       // wgs84 | gcj02（国测局坐标，地图默认）
  altitude: false,     // 是否返回海拔（基础库 1.2+）
  isHighAccuracy: true, // 开启高精度定位（基础库 2.9+）
  success: (res) => {
    console.log(res.latitude, res.longitude);
    console.log(res.speed, res.accuracy);
  },
  fail: (err) => {
    if (err.errMsg.includes('auth deny')) {
      wx.showModal({ title: '提示', content: '需要位置权限，请在设置中开启' });
    }
  }
});

// 打开地图选择位置（带交互）
wx.chooseLocation({
  success: (res) => {
    console.log(res.name, res.address, res.latitude, res.longitude);
  }
});

// 打开内置地图查看位置
wx.openLocation({
  latitude: 31.230416,
  longitude: 121.473701,
  name: '上海',
  address: '上海市黄浦区',
  scale: 15
});

// 选择图片
wx.chooseImage({
  count: 9,           // 默认 9
  sizeType: ['original', 'compressed'], // 原图/压缩
  sourceType: ['album', 'camera'],      // 相册/相机
  success: (res) => {
    const paths = res.tempFilePaths;
    console.log(paths); // 临时文件路径（本地有效）
  }
});

// 预览图片
wx.previewImage({
  current: urls[0],
  urls: urls  // 需要是 https 图片
});

// 保存图片到相册
wx.saveImageToPhotosAlbum({
  filePath: tempFilePath,
  success: () => wx.showToast({ title: '保存成功' })
});

// 保存文件到本地
wx.saveFile({
  tempFilePath: res.tempFilePath,
  success: (res) => {
    console.log(res.savedFilePath);
  }
});

// 获取文件信息
wx.getFileInfo({
  filePath: 'http://...', // 本地或 https 路径
  success: (res) => console.log(res.size, res.digest)
});

// toast（自动消失）
wx.showToast({ title: '操作成功', icon: 'success', duration: 2000 });
wx.showToast({ title: '网络异常', icon: 'error', duration: 2000 });
wx.showToast({ title: '提示信息', icon: 'none', duration: 2000 });

// modal 对话框
wx.showModal({
  title: '确认删除',
  content: '确定要删除这条记录吗？',
  confirmColor: '#07c160',
  success: (res) => {
    if (res.confirm) console.log('用户点击确定');
    if (res.cancel) console.log('用户点击取消');
  }
});

// loading 遮罩
wx.showLoading({ title: '加载中...', mask: true });
setTimeout(() => wx.hideLoading(), 3000);

// actionSheet 底部菜单
wx.showActionSheet({
  itemList: ['选项1', '选项2', '选项3'],
  success: (res) => console.log(res.tapIndex)
});

// 导航栏加载状态
wx.showNavigationBarLoading();
wx.hideNavigationBarLoading();

// 页面滚动
wx.pageScrollTo({ scrollTop: 0, duration: 300 });

// ⚠️ 方式一：WXS 响应式动画（推荐，脱离主线程，更流畅）
// ⚠️ 方式二：Animation API（注意与 Skyline 不兼容）

// Animation 方式
const animation = wx.createAnimation({
  transformOrigin: '50% 50%',
  duration: 300,
  timingFunction: 'ease'
});

this.animation = animation;

// 连续动画链
animation.opacity(0).scale(0.8).step();
animation.opacity(1).scale(1).step();
this.setData({ animation: animation.export() });

// 单帧设置
this.setData({
  animationData: animation.rotate(180).step().export()
});

// 方式一：button 触发（推荐）
// wxml
<button open-type="getUserInfo" bindgetuserinfo="onGetUserInfo">获取用户信息</button>

// js
onGetUserInfo(e) {
  if (e.detail.errMsg.includes('ok')) {
    const userInfo = e.detail.userInfo;
    const encryptedData = e.detail.encryptedData;
    const iv = e.detail.iv;
    // 发送给后端解密
    this.loginWithBackend(userInfo, encryptedData, iv);
  } else {
    wx.showToast({ title: '需要授权才能继续', icon: 'none' });
  }
}

// 方式二：主动检查 + 请求（wx.getSetting）
wx.getSetting({
  success: (res) => {
    if (!res.authSetting['scope.userLocation']) {
      wx.authorize({
        scope: 'scope.userLocation',
        success: () => { /* 已授权 */ },
        fail: () => {
          // 用户拒绝 → 引导打开设置
          wx.showModal({
            title: '提示',
            content: '需要位置权限，请在设置中打开',
            success: (modalRes) => {
              if (modalRes.confirm) {
                wx.openSetting();
              }
            }
          });
        }
      });
    } else {
      // 已授权，直接获取
      this.getLocation();
    }
  }
});

// wxml
<button open-type="getPhoneNumber" bindgetphonenumber="onGetPhoneNumber">绑定手机号</button>

// js
onGetPhoneNumber(e) {
  if (e.detail.errMsg === 'getPhoneNumber:ok') {
    wx.request({
      url: 'https://api.example.com/auth/decodePhone',
      method: 'POST',
      data: {
        code: e.detail.code  // 服务端用 code 换取手机号
      }
    });
  }
}

<button open-type="chooseAvatar" bindchooseavatar="onChooseAvatar">选择头像</button>

onChooseAvatar(e) {
  const { avatarUrl } = e.detail;
  // 上传头像到服务器
  wx.uploadFile({
    url: 'https://api.example.com/upload',
    filePath: avatarUrl,
    name: 'avatar',
    success: (res) => {
      console.log(JSON.parse(res.data).url);
    }
  });
}

┌─────────────┐         ┌─────────────┐         ┌─────────────┐
│   小程序     │         │   微信平台   │         │   后端服务器  │
└──────┬──────┘         └──────┬──────┘         └──────┬──────┘
       │                       │                       │
       │  1. wx.login()        │                       │
       │───────────────────────►│                       │
       │  拿到 code            │                       │
       │◄───────────────────────│                       │
       │                       │                       │
       │  2. 发送 code + iv + encryptedData            │
       │──────────────────────────────────────────────►│
       │                       │         3. 用 code 换  │
       │                       │      openid + session │
       │                       │◄──────────────────────│
       │                       │         4. 解密获取    │
       │                       │      unionid/userInfo  │
       │  5. 返回 openid/session_key/ticket             │
       │◄──────────────────────────────────────────────│
       │                       │                       │
       │  6. 存储 session，标记登录态                   │
       │                       │                       │

// utils/auth.js

/**
 * 微信小程序登录
 * @returns {Promise<{token: string, userInfo: object}>}
 */
function wxLogin() {
  return new Promise((resolve, reject) => {
    // 1. 获取 code
    wx.login({
      success: (loginRes) => {
        if (!loginRes.code) return reject(new Error('未获取到 code'));

        // 2. 获取用户信息（可选，button 触发更合规）
        wx.getUserProfile({
          desc: '用于完善用户资料',
          success: (userRes) => {
            // 3. 发送到后端
            wx.request({
              url: `${BASE_URL}/auth/wx-login`,
              method: 'POST',
              data: {
                code: loginRes.code,
                encryptedData: userRes.encryptedData,
                iv: userRes.iv,
                rawData: userRes.rawData,
                signature: userRes.signature
              },
              success: (res) => {
                if (res.statusCode === 200 && res.data.token) {
                  // 4. 存储 token 和用户信息
                  wx.setStorageSync('token', res.data.token);
                  wx.setStorageSync('userInfo', res.data.userInfo);
                  resolve(res.data);
                } else {
                  reject(new Error(res.data.message || '登录失败'));
                }
              },
              fail: reject
            });
          },
          fail: (err) => {
            wx.showToast({ title: '需要授权才能继续', icon: 'none' });
            reject(err);
          }
        });
      },
      fail: reject
    });
  });
}

/**
 * 检查登录态（带自动登录）
 */
function checkSession() {
  return new Promise((resolve, reject) => {
    wx.checkSession({
      success: () => resolve(true),
      fail: () => {
        // session 过期，重新登录
        wxLogin().then(resolve).catch(reject);
      }
    });
  });
}

/**
 * 获取当前 token（带自动续期检查）
 */
function getToken() {
  const token = wx.getStorageSync('token');
  if (!token) return null;
  checkSession().catch(() => {
    wx.removeStorageSync('token');
    wx.removeStorageSync('userInfo');
  });
  return token;
}

/**
 * 登出
 */
function logout() {
  wx.removeStorageSync('token');
  wx.removeStorageSync('userInfo');
  wx.removeStorageSync('openid');
}

module.exports = { wxLogin, checkSession, getToken, logout };

// pages/index/index.js
const { getToken, checkSession } = require('../../utils/auth');

Page({
  data: { userInfo: null, isLogin: false },

  onLoad() {
    this.checkLogin();
  },

  async checkLogin() {
    const userInfo = wx.getStorageSync('userInfo');
    if (!userInfo) return;

    try {
      await checkSession();
      this.setData({ userInfo, isLogin: true });
    } catch (err) {
      this.setData({ userInfo: null, isLogin: false });
    }
  },

  async onLogin() {
    try {
      const { wxLogin } = require('../../utils/auth');
      const result = await wxLogin();
      this.setData({ userInfo: result.userInfo, isLogin: true });
      wx.showToast({ title: '登录成功' });
    } catch (err) {
      wx.showToast({ title: '登录失败', icon: 'none' });
    }
  }
});

// utils/interceptor.js

function requestWithAuth(options) {
  const token = wx.getStorageSync('token');
  if (token) {
    options.header = options.header || {};
    options.header['Authorization'] = `Bearer ${token}`;
  }

  return new Promise((resolve, reject) => {
    wx.request({
      ...options,
      fail: reject
    });
  });
}

// app.js - 全局拦截
App({
  onLaunch() {
    // 全局 request 封装或使用第三方库如 Fly.js / Taro-request
  }
});

{
  "pages": [
    "pages/index/index",
    "pages/user/index"
  ],
  "subPackages": [
    {
      "root": "subpkg/games",
      "name": "games",
      "pages": [
        { "path": "pages/index/index", "lazyLoad": true },
        { "path": "pages/detail/index" }
      ]
    },
    {
      "root": "subpkg/shop",
      "pages": [
        { "path": "pages/cart/index" },
        { "path": "pages/order/index" }
      ]
    }
  ]
}

// ❌ 无法直接跳转到分包页面（分包 root 外层需要用相对路径）
wx.navigateTo({ url: '/pages/index/index' }); // 主包

// ✅ 分包内跳转
wx.navigateTo({ url: 'pages/detail/index' }); // 相对路径

// ✅ 从主包跳转到分包页面（可以用绝对路径）
wx.navigateTo({ url: '/subpkg/games/pages/index/index' });

// ✅ 分包内跳转到其他分包（需要用绝对路径）
wx.navigateTo({ url: '/subpkg/shop/pages/cart/index' });

// ✅ 分包内 switchTab（主包 tabBar 页面）
wx.switchTab({ url: '/pages/index/index' });

// app.json
{
  "preloadRule": {
    "pages/index/index": {
      "network": "all",      // all | wifi
      "packages": ["subpkg/games"]
    },
    "pages/user/index": {
      "network": "wifi",
      "packages": ["subpkg/shop"]
    }
  }
}

{
  "root": "subpkg/independent",
  "independent": true
}

// cloudfunctions/common/utils.js
const cloud = require('wx-server-sdk');
cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV }); // 自动使用当前环境

// 云函数入口
const db = cloud.database();
const _ = db.command;
const $ = _.aggregate;

// 前端 - 增删改查
wx.cloud.init(); // 在 app.js 中初始化一次

// 插入
wx.cloud.database().collection('users').add({
  data: { name: 'Alice', age: 18, createTime: db.serverDate() }
}).then(res => console.log(res._id));

// 查询
wx.cloud.database().collection('users')
  .where({ name: 'Alice' })
  .field({ name: true, age: true })
  .orderBy('createTime', 'desc')
  .skip(0)
  .limit(20)
  .get()
  .then(res => this.setData({ list: res.data }));

// 更新（字段更新）
wx.cloud.database().collection('users')
  .doc(id)
  .update({ data: { age: _.inc(1) } }); // 原子递增

// 删除
wx.cloud.database().collection('users').doc(id).remove();

// 上传文件
wx.cloud.uploadFile({
  cloudPath: 'avatars/' + Date.now() + '.png',
  filePath: tempFilePath, // 临时文件路径
  success: (res) => console.log(res.fileID)
});

// 下载文件获取临时链接
wx.cloud.getTempFileURL({
  fileList: [fileID1, fileID2],
  success: (res) => {
    res.fileList.forEach(item => {
      if (item.status === 0) {
        console.log(item.tempFileURL); // https URL
      }
    });
  }
});

// 删除文件
wx.cloud.deleteFile({ fileList: [fileID] });

// cloudfunctions/login/index.js
const cloud = require('wx-server-sdk');
cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV });

exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext();
  const { code } = event;

  // 调用微信接口获取 openid
  const res = await cloud.cloudbase.callContainer({
    service: 'auth',
    path: '/code2session',
    method: 'GET',
    data: { appid: wxContext.APPID, code, grant_type: 'authorization_code' }
  });

  return {
    openid: res.openid,
    sessionKey: res.session_key,
    appid: wxContext.APPID
  };
};

GET https://api.weixin.qq.com/cgi-bin/token
    ?grant_type=client_credential
    &appid=APPID
    &secret=APPSECRET

{
  "access_token": "ACCESS_TOKEN",
  "expires_in": 7200
}

// utils/wxToken.js
const axios = require('axios');
const { appid, secret } = require('../config');

let cachedToken = null;
let tokenExpireTime = 0;

async function getAccessToken() {
  const now = Date.now();
  // 提前 5 分钟刷新
  if (cachedToken && now < tokenExpireTime - 5 * 60 * 1000) {
    return cachedToken;
  }

  const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${appid}&secret=${secret}`;
  const res = await axios.get(url);

  if (res.data.access_token) {
    cachedToken = res.data.access_token;
    tokenExpireTime = now + res.data.expires_in * 1000;
    return cachedToken;
  }
  throw new Error('获取 access_token 失败: ' + JSON.stringify(res.data));
}

module.exports = { getAccessToken };

GET https://api.weixin.qq.com/sns/jscode2session
    ?appid=APPID
    &secret=SECRET
    &js_code=CODE
    &grant_type=authorization_code

{
  "openid": "oUpF8uMuAJO_M2pxb1Q9zNjWeS6o",
  "session_key": "tiihtNczf5jlfXJpVJ...",
  "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL",   // 满足条件才返回
  "errcode": 0,
  "errmsg": "ok"
}

// services/wxAuth.js
const axios = require('axios');
const { appid, secret } = require('../config');

async function code2Session(code) {
  const url = `https://api.weixin.qq.com/sns/jscode2session?appid=${appid}&secret=${secret}&js_code=${code}&grant_type=authorization_code`;
  const res = await axios.get(url);
  if (res.data.errcode) {
    throw new Error(`code2Session 失败: ${res.data.errmsg}`);
  }
  return res.data; // { openid, session_key, unionid? }
}

/**
 * 解密 getUserInfo 返回的 encryptedData
 * 依赖：npm install crypto-js
 */
const CryptoJS = require('crypto-js');

function decryptUserInfo(encryptedData, iv, sessionKey) {
  const key = CryptoJS.enc.Base64.parse(sessionKey);
  const ivBytes = CryptoJS.enc.Base64.parse(iv);
  const encrypted = CryptoJS.enc.Base64.parse(encryptedData);

  const decrypted = CryptoJS.AES.decrypt(
    { ciphertext: encrypted },
    key,
    { iv: ivBytes, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
  );

  const jsonStr = CryptoJS.enc.Utf8.stringify(decrypted);
  return JSON.parse(jsonStr);
}

module.exports = { code2Session, decryptUserInfo };

POST https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=ACCESS_TOKEN
Content-Type: application/json

{ "code": "PHONE_CODE" }

{
  "errcode": 0,
  "errmsg": "ok",
  "phone_info": {
    "phoneNumber": "18888888888",
    "purePhoneNumber": "18888888888",
    "countryCode": "86",
    "watermark": { "appid": "APPID", "timestamp": 1234567890 }
  }
}

小程序前端              商户后端               微信支付平台
    │                     │                      │
    │  点击支付            │                      │
    │─────────────────────►│                      │
    │                     │  1.统一下单            │
    │                     │──────────────────────►│
    │                     │  prepay_id            │
    │                     │◄──────────────────────│
    │  2.返回支付参数      │                      │
    │◄────────────────────│                      │
    │  3.wx.requestPayment│                      │
    │─────────────────────────────────────────────►│
    │                     │                      │ 4.支付结果通知
    │                     │◄──────────────────────│
    │  5.展示结果          │                      │

POST https://api.mch.weixin.qq.com/v3/pay/transactions/jsapi

Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"xxx\",nonce_str=\"xxx\",signature=\"xxx\",timestamp=\"xxx\",serial_no=\"xxx\"
Content-Type: application/json

{
  "appid": "wx1234567890abcdef",
  "mchid": "1230000109",
  "description": "商品描述",
  "out_trade_no": "order_20240101_001",
  "notify_url": "https://api.example.com/wxpay/notify",
  "amount": {
    "total": 1,
    "currency": "CNY"
  },
  "payer": {
    "openid": "oUpF8uMuAJO_M2pxb1Q9zNjWeS6o"
  }
}

{
  "prepay_id": "wx201410272009395522657a690389489100"
}

// 后端返回签名后的支付参数
wx.requestPayment({
  timeStamp: '1414561699',
  nonceStr: '5K8264ILTKCH16CQ2502SI8ZNMTM67VS',
  package: 'prepay_id=wx201410272009395522657a690389489100',
  signType: 'RSA',          // V3 用 RSA，V2 用 MD5
  paySign: 'signature...',
  success: (res) => { wx.showToast({ title: '支付成功' }); },
  fail: (err) => { wx.showToast({ title: '支付失败', icon: 'none' }); }
});

// routes/wxpay.js
const express = require('express');
const app = express();

app.post('/wxpay/notify', express.raw({ type: 'application/json' }), (req, res) => {
  const { event_type, resource } = req.body;
  // 1. 验签（使用微信支付平台证书）
  // 2. 解密 resource.ciphertext（AES-256-GCM）
  // 3. 处理业务逻辑（更新订单状态）
  // 4. 返回成功响应

  res.json({ code: 'SUCCESS', message: '成功' });
});

GET https://api.mch.weixin.qq.com/v3/pay/transactions/out-trade-no/{out_trade_no}?mchid={mchid}

POST https://api.mch.weixin.qq.com/v3/refund/domestic/refunds

{
  "out_trade_no": "order_20240101_001",
  "out_refund_no": "refund_001",
  "reason": "商品质量问题",
  "amount": {
    "refund": 1,
    "total": 1,
    "currency": "CNY"
  }
}

POST https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=ACCESS_TOKEN

{
  "touser": "oUpF8uMuAJO_M2pxb1Q9zNjWeS6o",
  "template_id": "TEMPLATE_ID",
  "page": "pages/order/index?id=123",
  "data": {
    "thing1": { "value": "您购买的课程已上线" },
    "date2": { "value": "2024-01-01 14:00" },
    "phrase3": { "value": "已发货" }
  },
  "miniprogram_state": "formal"   // developer | trial | formal
}

const { getAccessToken } = require('../utils/wxToken');

async function sendSubscribeMessage(openid, templateId, data, page = '') {
  const token = await getAccessToken();
  const url = `https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=${token}`;

  const res = await axios.post(url, {
    touser: openid,
    template_id: templateId,
    page: page,
    data: data,
    miniprogram_state: 'formal'
  });

  if (res.data.errcode !== 0) {
    console.error('订阅消息发送失败:', res.data);
  }
  return res.data;
}

POST https://api.weixin.qq.com/wxa/msg_sec_check?access_token=ACCESS_TOKEN

{
  "content": "要检测的文本",
  "version": 2,          // 使用 V2 接口（支持开放内容）
  "scene": 1             // 1:资料 2:评论 3:论坛 4:社交日志
}

{
  "errcode": 0,          // 0 = 正常，87014 = 疑似违规
  "errmsg": "ok",
  "result": {
    "suggest": "pass",   // pass | review（需人工） | block（违规）
    "label": 200          // 200:正常 100:低俗 20001:涉政 ...
  }
}

POST https://api.weixin.qq.com/wxa/img_sec_check?access_token=ACCESS_TOKEN
Content-Type: multipart/form-data

const FormData = require('form-data');
const fs = require('fs');

async function checkImage(filePath) {
  const token = await getAccessToken();
  const form = new FormData();
  form.append('media', fs.createReadStream(filePath));

  const res = await axios.post(
    `https://api.weixin.qq.com/wxa/img_sec_check?access_token=${token}`,
    form,
    { headers: form.getHeaders() }
  );
  return res.data.errcode === 0; // true = 安全
}

POST https://api.weixin.qq.com/wxa/media_check_async?access_token=ACCESS_TOKEN

{
  "media_url": "https://example.com/audio.mp3",
  "media_type": 2,     // 1:音频 2:图片
  "version": 2
}

POST https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=ACCESS_TOKEN

{
  "scene": "uid=123&ref=share",   // 最多 32 个字符
  "page": "pages/index/index",     // 必须是已发布的页面路径
  "width": 430,
  "auto_color": false,
  "line_color": { "r": 0, "g": 0, "b": 0 },
  "is_hyaline": false              // 是否为透明底色
}

const axios = require('axios');
const fs = require('fs');
const { getAccessToken } = require('../utils/wxToken');

async function generateQRCode(scene, page) {
  const token = await getAccessToken();
  const res = await axios.post(
    `https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=${token}`,
    { scene, page, width: 430 },
    { responseType: 'arraybuffer' }
  );

  const filePath = `./qrcodes/${scene}.png`;
  fs.writeFileSync(filePath, res.data);
  return filePath;
}

POST https://api.weixin.qq.com/cgi-bin/wxaapp/createwxaqrcode?access_token=ACCESS_TOKEN

{
  "path": "pages/index/index?id=123",   // 带参数路径
  "width": 430
}

POST https://api.weixin.qq.com/shop/delivery/send?access_token=ACCESS_TOKEN

{
  "order_id": 123456789,
  "delivery_id": "DELIVERY_ID",
  "waybill_id": "1234567890",
  "delivery_status": 1          // 1:已发货
}

POST https://api.weixin.qq.com/shop/order/confirm_receive?access_token=ACCESS_TOKEN