@lwys-pkg-releaser/node-bullshit-generator/lib/随机常用.js

Port of menzi11/BullshitGenerator@github.com to JavaScript

"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

/**
 * 随机相关的函数
 * @author Dobby233Liu
 */
var 随机常用 = /*#__PURE__*/function () {
  function 随机常用() {
    _classCallCheck(this, 随机常用);
  }

  _createClass(随机常用, null, [{
    key: "\u53D6\u968F\u673A\u5C0F\u6570",
    value:
    /**
     * 返回0-1之间的随机小数
     * @returns {number}
     */
    function 取随机小数() {
      return Math.random();
    }
    /**
     * 返回0-最大数之间的随机整数，不包括最大数
     * @param {number} 最大数
     * @returns {number}
     */

  }, {
    key: "\u53D6\u968F\u673A\u6570",
    value: function 取随机数(最大数) {
      return Math.floor(this.取随机小数() * 最大数);
    }
    /**
     * 在数组中选择一个随机的元素
     * @param {any[]} 数组
     * @returns {any}
     */

  }, {
    key: "\u778E\u9009\u4E00\u4E2A",
    value: function 瞎选一个(数组) {
      return 数组[this.取随机数(数组.length)];
    }
    /**
     * 洗乱一个数组中的内容，而不影响原数组
     * @param {any[]} 数组
     * @returns {any[]}
     * @see {@link https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array}
     */

  }, {
    key: "\u6D17\u724C",
    value: function 洗牌(数组) {
      var 洗牌后数组 = 数组.slice();

      for (var i = 洗牌后数组.length - 1; i > 0; i--) {
        var j = this.取随机数(i + 1);
        var _ref = [洗牌后数组[j], 洗牌后数组[i]];
        洗牌后数组[i] = _ref[0];
        洗牌后数组[j] = _ref[1];
      }

      return 洗牌后数组;
    }
    /**
     * 返回一个伪迭代器，其将（重复度次重复并）洗牌过的数组中的元素按顺序返回，
     * 完毕后再次（重复度次重复并）洗牌数组并从头开始；
     * 使用伪迭代器是因为 JavaScript 引擎的莫名限制
     * @param {any[]} 数组
     * @param {number} 重复度
     * @returns {Object}
     */

  }, {
    key: "\u6D17\u724C\u904D\u5386",
    value: function 洗牌遍历(数组) {
      var 重复度 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
      if (数组.length < 1) throw Error("Invaild array");
      var 洗牌后数组 = [];
      var i = 0;

      for (var ii = 0; ii < 重复度; ii++) {
        洗牌后数组 = 洗牌后数组.concat(数组);
      }

      洗牌后数组 = this.洗牌(洗牌后数组);
      return {
        next: function __next__() {
          var ret = 洗牌后数组[i++];

          if (i >= 洗牌后数组.length) {
            洗牌后数组 = this.洗牌(洗牌后数组);
            i = 0;
          }

          return {
            value: ret,
            done: false
          };
        }.bind(this)
      };
    }
  }]);

  return 随机常用;
}();

module.exports = 随机常用;