var array = [{name:'武汉'}, {name: '北京'}, {name:'上海'}, {name:'天津'}];
var resultArray = array.sort(
    function compareFunction(param1, param2) {
        return param1.name.localeCompare(param2.name,"zh");
    }
);
console.log(resultArray);

import {observable, computed} from "mobx";

class OrderLine {
    @observable price = 0;
    @observable amount = 1;

    constructor(price) {
        this.price = price;
    }
  // computed 不支持箭头函数的写法
    @computed get total() {
        return this.price * this.amount;
    }
}

// 请求底部的 table Plan 绑定数据
@action fetchShopPlanList = (): ActionResponse => {
    const [begin, end] = this.dateRange;
    return http
        .post(ApiBaseinfo_Admin_Restaurant_restaurantID_menuCalendarByDateRange, {
            ':restaurantID': globalStore.currentShopID,
            begin,
            end,
        })
        .then(({ error, data }) => {
            if (error) {
                return { error };
            }

            runInAction(() => {
                const { menuCalendarList } = data;
                // 遍历筛选绑定菜单项
                this.boundObj = menuCalendarList.reduce((preObj, mealPlan) => {
                    const { color, name, date } = mealPlan;
                    if (color) {
                        preObj[`${date}_${name}`] = color;
                    }

                    return preObj;
                }, {});
                // 在一个请求的 action中直接去修改 state,可能会存在mobx 检测不到的情况，需要包裹 runInAction
                this.shopCalendarList = data.menuCalendarList;
            });

            return { data };
        });
};

(function () {
  'use strict';
  // =>  Object.hasOwnProperty   用于判断某个成员是否在对象内
  var hasOwn = {}.hasOwnProperty;
  function classNames () {
     // 存储 className 值
    var classes = [];

    // 循环实参， arguments就是实际调用函数传入的参数，类似数组
    for (var i = 0; i < arguments.length; i++) {
      // 获取实参value
      var arg = arguments[i];

      // 跳过false条件 => false, null, undefined, NaN, 空, ...
      if (!arg) continue;

      // 判断传入参数的类型
      var argType = typeof arg;

      // 如果参数的类型是 string 或者 number
      if (argType === 'string' || argType === 'number') {
        // 直接追加到classes数组后面
        classes.push(arg);

      // 如果参数是数组并且长度大于0
      } else if (Array.isArray(arg) && arg.length) {
        // 调用自身函数，利用apply可以将数组转成字符串
        var inner = classNames.apply(null, arg);

        // 现在是一个字符串，隐士判断布尔值
        if (inner) {
          // 追加到数组后面
          classes.push(inner);
        }
      // 如果传入的参数是对象
      } else if (argType === 'object') {
        // 对object进行遍历
        for (var key in arg) {
          // 判断key是否存在arg对象内并且key的值隐士转换为true
          if (hasOwn.call(arg, key) && arg[key]) {
            // 将值追加到classes数组后面
            classes.push(key);
          }
        }
      }
    }
    // 将数组连接成字符串以空格拼接  => a b c
    return classes.join(' ');
  }

  // 如果是node.js环境运行
  if (typeof module !== 'undefined' && module.exports) {
    classNames.default = classNames;
    module.exports = classNames;

  // 如果用的requirejs模块管理 AMD
  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
    define('classnames', [], function () {
    return classNames;
  });

  // 否则运行于浏览器环境
  } else {
    window.classNames = classNames;
  }
}());

fetch('./api/person.json')
  .then(
    function(response) {
      if (response.status !== 200) {
        console.log('Looks like there was a problem. Status Code: ' +
          response.status);
        return;
      }

      // Examine the text in the response
      // 将返回数据 Json 化
      response.json().then(function(data) {
        console.log(data);
      });
    }
  )
  .catch(function(err) {
    console.log('Fetch Error :-S', err);
  });

  1. .json()返回一个被解析为JSON格式的`promise`对象，当获取成功时，我们使用 json() 读取并解析数据

const automator = require('miniprogram-automator')

describe('index', () => {
  let miniProgram
  let page

  beforeAll(async () => {
    miniProgram = await automator.launch({
      projectPath: 'path/to/miniprogram-demo'
    })
    page = await miniProgram.reLaunch('/page/component/index')
    await page.waitFor(500)
  }, 30000)

  afterAll(async () => {
    await miniProgram.close()
  })
})

npm install miniprogram-automator --save-dev