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

Port of menzi11/BullshitGenerator@github.com to JavaScript

"use strict";

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

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: "\u662F\u5426\u4EE5\u5B57\u7B26\u4E32\u7ED3\u675F",
    value:
    /**
     * 检测字符串结尾是否有检测列表中的任意一段文字
     * @param {String} 字符串
     * @param {String[]} 检测列表
     * @returns {Boolean}
     */
    function 是否以字符串结束(字符串, 检测列表) {
      var _iterator = _createForOfIteratorHelper(检测列表),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var i = _step.value;

          if (字符串.endsWith(i)) {
            return true;
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }

      return false;
    }
    /**
     * 把对象中所有元素覆盖到镜像上，不影响传入的镜像
     * @param {Object} 对象
     * @param {Object} 镜像
     * @returns {Object}
     */

  }, {
    key: "\u5408\u5E76\u5BF9\u8C61",
    value: function 合并对象(对象, 镜像) {
      var 合成 = 镜像;

      for (var i in 对象) {
        if (i != "__proto__") {
          合成[i] = 对象[i];
        }
      }

      return 合成;
    }
    /**
     * 检测段落是否有换行符（适合使用加段函数）
     * @param {string} 段
     * @returns {boolean}
     * @see 加段
     */

  }, {
    key: "\u80FD\u52A0\u6BB5",
    value: function 能加段(段) {
      return 段.includes("\n");
    }
    /**
     * 将段中的所有段落添加到文章里
     * @param {string[]} 文章
     * @param {string} 段
     * @returns {string}
     */

  }, {
    key: "\u52A0\u6BB5",
    value: function 加段(文章, 段) {
      var 分段 = 段.trimEnd().split("\n");
      文章 = 文章.concat(分段);
      return 文章;
    }
    /**
     * 返回数组中的最后一个元素
     * @param {any[]} 数组
     * @returns {any}
     */

  }, {
    key: "\u6700\u540E\u4E00\u9879",
    value: function 最后一项(数组) {
      return 数组[数组.length - 1];
    }
    /**
     * 返回文章中所有段落的长度
     * @param {string[]} 文章
     * @param {boolean} 加换行符长度 - 如果为真，把隐性的换行符也算在内
     * @returns {number}
     */

  }, {
    key: "\u603B\u957F",
    value: function 总长(文章) {
      var 加换行符长度 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      var 换行符号长 = "\n".length;
      var 长 = 0;

      for (var i in 文章) {
        长 += 文章[i].length + (加换行符长度 ? 换行符号长 : 0);
      }

      return 长;
    }
  }]);

  return 常用;
}();

module.exports = 常用;