@ivujs/i-utils 1.1.18 → 2.1.0

package/dist/cjs/string/index.cjs

@@ -0,0 +1,361 @@
+'use strict';
+
+/**
+ * @module 字符串
+ */
+/* 字符串处理 */
+/**
+ * 字符串中是否包含指定的元素
+ * @param {string} value 包含的元素
+ * @param {string} str 查找的字符串
+ * @returns {boolean} 返回true和false
+ */
+function inString(value, str) {
+    return str.includes(value);
+}
+/**
+ * 去除字符串前后位置空格
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function trim(value) {
+    return value.replace(/(^\s*)|(\s*$)/g, "");
+}
+/**
+ * 去除字符串开始位置的空格
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function trimStart(value) {
+    return value.replace(/(^\s*)/g, "");
+}
+/**
+ * 去除字符串结束位置的空格
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function trimEnd(value) {
+    return value.replace(/(\s*$)/g, "");
+}
+/**
+ * 去除字符串中全部的空格
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function trimAll(value) {
+    return value.replace(/\s+/g, "");
+}
+/**
+ * 替换所有指定字符串为新的字符串
+ * @param {string} value 参数
+ * @param {string} oldSubstr 需要替换的字符串
+ * @param {string} newSubstr 替换后的字符串
+ * @returns {string} 返回处理后的字符串
+ */
+function replaceAll(value, oldSubstr, newSubstr) {
+    return value.replace(new RegExp(oldSubstr, "gm"), newSubstr);
+}
+/* 字符串转换 */
+/**
+ * 字符串转大写
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toUpperCase(value) {
+    return String(value).toLocaleUpperCase();
+}
+/**
+ * 字符串转小写
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toLowerCase(value) {
+    return String(value).toLocaleLowerCase();
+}
+/**
+ * 转为 snake_case 下划线命名
+ * @description 支持 驼峰命名，短横命名，帕斯卡命名
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toSnakeCase(value) {
+    // 驼峰
+    if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        return value.replace(/([A-Z])/g, "_$1").toLowerCase();
+    }
+    // 短横
+    if (value.indexOf("-") > 0) {
+        return value.replace(/-/g, "_").toLowerCase();
+    }
+    // 帕斯卡
+    if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        value = value.charAt(0).toLowerCase() + value.slice(1);
+        return value.replace(/([A-Z])/g, "_$1").toLowerCase();
+    }
+}
+/**
+ * 转为 kebab-case 短横命名
+ * @description 支持 下划线，驼峰命名，帕斯卡命名
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toKebabCase(value) {
+    // 下划线
+    if (value.indexOf("_") > 0) {
+        return value.replace(/_/g, "-").toLowerCase();
+    }
+    // 驼峰
+    if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        return value.replace(/([A-Z])/g, "-$1").toLowerCase();
+    }
+    // 帕斯卡
+    if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        const newStr = value.charAt(0).toLowerCase() + value.slice(1);
+        return newStr.replace(/([A-Z])/g, "-$1").toLowerCase();
+    }
+}
+/**
+ * 转为 camelCase 驼峰命名
+ * @description 支持 下划线命名，短横命名，帕斯卡命名
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toCamelCase(value) {
+    // 下划线
+    if (value.indexOf("_") > 0) {
+        return value.replace(/\_(\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+    }
+    // 短横
+    else if (value.indexOf("-") > 0) {
+        return value.replace(/\-(\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+    }
+    // 帕斯卡
+    else if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        return value.charAt(0).toLowerCase() + value.slice(1);
+    }
+    // 返回自身
+    else {
+        return value;
+    }
+}
+/**
+ * 转为 PascalCase 帕斯卡命名
+ * @description 支持 下划线命名，短横命名，驼峰命名
+ * @param {string} value 参数
+ * @returns {string} 返回处理后的字符串
+ */
+function toPascalCase(value) {
+    // 下划线
+    if (value.indexOf("_") > 0) {
+        const newStr = value.replace(/\_(\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+        return newStr.charAt(0).toUpperCase() + newStr.slice(1);
+    }
+    // 短横
+    else if (value.indexOf("-") > 0) {
+        const newStr = value.replace(/\-(\w)/g, function (all, letter) {
+            return letter.toUpperCase();
+        });
+        return newStr.charAt(0).toUpperCase() + newStr.slice(1);
+    }
+    // 驼峰
+    else if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+    // 返回自身
+    else {
+        return value;
+    }
+}
+/* 字符串格式化 */
+/**
+ * 数字前补齐0达到指定位数
+ * @description 相当于原生的 padStart(2,'0')
+ * @param {number|string} value 补零的数字
+ * @param {number} maxLength 补齐0后的最大长度，默认2位
+ * @returns {string} 返回补0后指定位数的字符串
+ */
+function zeroStart(value, maxLength = 2) {
+    let len = value.toString().length;
+    while (len < maxLength) {
+        value = "0" + value;
+        len++;
+    }
+    return value;
+}
+/**
+ * 数字后补齐0达到指定位数
+ * @description 相当于原生的 padEnd(2,'0')
+ * @param {number|string} value 补零的数字
+ * @param {number} maxLength 补齐0后的最大长度，默认2位
+ * @returns {string} 返回补0后指定位数的字符串
+ */
+function zeroEnd(value, maxLength = 2) {
+    let len = value.toString().length;
+    while (len < maxLength) {
+        value = value + "0";
+        len++;
+    }
+    return value;
+}
+/**
+ * 格式化为标题样式
+ * @param {string} value 字符串值
+ * @returns {string} 返回格式化后的标题样式
+ */
+function formatTitle(value) {
+    if (!value)
+        return "";
+    return value
+        .split(/(?=[A-Z])|[\.\-\s_]/)
+        .map((s) => s.trim())
+        .filter((s) => !!s)
+        .map((s) => toPascalCase(s.toLowerCase()))
+        .join(" ");
+}
+/**
+ * 格式化字符串模版
+ * @param {string} value 字符串值
+ * @param {Object} data 模版数据
+ * @returns {string} 返回格式化后的模版字符串
+ */
+function formatTemplate(value, data) {
+    if (!value)
+        return "";
+    return Array.from(value.matchAll(/\{\{(.+?)\}\}/g)).reduce((acc, match) => {
+        return acc.replace(match[0], data[match[1]]);
+    }, value);
+}
+/**
+ * 格式化千分位数字
+ * @description 支持任意数据传参，如果非数字则不会格式化，并返回原数据
+ * @param {number|string} num 数字
+ * @returns {string} 返回格式化后的千分位数字
+ */
+function formatThousand(num) {
+    if (!parseFloat(String(num)))
+        return String(num);
+    num = String(num);
+    const regex = num.indexOf(".") > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g;
+    return num.replace(regex, "$1,");
+}
+/**
+ * 格式化人民币金额大写
+ * @param {number|string} money 金额
+ * @returns {string} 返回金额大写
+ */
+function formatRmbChinese(money) {
+    // 汉字的数字
+    const cnNums = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
+    // 基本单位
+    const cnIntRadiance = ["", "拾", "佰", "仟"];
+    // 对应整数部分扩展单位
+    const cnIntUnits = ["", "万", "亿", "兆"];
+    // 对应小数部分单位
+    const cnDecUnits = ["角", "分", "毫", "厘"];
+    // 整数金额时后面跟的字符
+    const cnInteger = "整";
+    // 整型完以后的单位
+    const cnIntLast = "元";
+    // 最大处理的数字
+    const maxNum = Number("999999999999999.9999");
+    // 金额整数部分
+    let integerNum;
+    // 金额小数部分
+    let decimalNum;
+    // 输出的中文金额字符串
+    let chineseStr = "";
+    // 分离金额后用的数组，预定义
+    let parts;
+    if (money === "") {
+        // 不能用==
+        return "";
+    }
+    money = parseFloat(String(money));
+    if (money >= maxNum) {
+        // 超出最大处理数字，抛出异常
+        throw new Error("Calculated number overflow!");
+    }
+    if (money === 0) {
+        chineseStr = cnNums[0] + cnIntLast + cnInteger;
+        return chineseStr;
+    }
+    // 转换为字符串
+    money = money.toString();
+    if (money.indexOf(".") === -1) {
+        integerNum = money;
+        decimalNum = "";
+    }
+    else {
+        parts = money.split(".");
+        integerNum = parts[0];
+        decimalNum = parts[1].substr(0, 4);
+    }
+    // 获取整型部分转换
+    if (parseInt(integerNum, 10) > 0) {
+        let zeroCount = 0;
+        const IntLen = integerNum.length;
+        for (let i = 0; i < IntLen; i++) {
+            const n = integerNum.substr(i, 1);
+            const p = IntLen - i - 1;
+            const q = p / 4;
+            const m = p % 4;
+            if (n === "0") {
+                zeroCount++;
+            }
+            else {
+                if (zeroCount > 0) {
+                    chineseStr += cnNums[0];
+                }
+                // 归零
+                zeroCount = 0;
+                chineseStr += cnNums[parseInt(n)] + cnIntRadiance[m];
+            }
+            if (m === 0 && zeroCount < 4) {
+                chineseStr += cnIntUnits[q];
+            }
+        }
+        chineseStr += cnIntLast;
+    }
+    // 小数部分
+    if (decimalNum !== "") {
+        const decLen = decimalNum.length;
+        for (let i = 0; i < decLen; i++) {
+            const n = decimalNum.substr(i, 1);
+            if (n !== "0") {
+                chineseStr += cnNums[Number(n)] + cnDecUnits[i];
+            }
+        }
+    }
+    if (chineseStr === "") {
+        chineseStr += cnNums[0] + cnIntLast + cnInteger;
+    }
+    else if (decimalNum === "") {
+        chineseStr += cnInteger;
+    }
+    return chineseStr;
+}
+
+exports.formatRmbChinese = formatRmbChinese;
+exports.formatTemplate = formatTemplate;
+exports.formatThousand = formatThousand;
+exports.formatTitle = formatTitle;
+exports.inString = inString;
+exports.replaceAll = replaceAll;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toLowerCase = toLowerCase;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.toUpperCase = toUpperCase;
+exports.trim = trim;
+exports.trimAll = trimAll;
+exports.trimEnd = trimEnd;
+exports.trimStart = trimStart;
+exports.zeroEnd = zeroEnd;
+exports.zeroStart = zeroStart;

package/dist/cjs/url/index.cjs

@@ -0,0 +1,261 @@
+'use strict';
+
+var regexp = require('../constants/regexp.cjs');
+var index = require('../validate/index.cjs');
+var index$1 = require('../array/index.cjs');
+
+/**
+ * @module 浏览器Url
+ */
+/**
+ * 获得协议名
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回协议名
+ */
+function getProtocol(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[1] || "";
+    }
+}
+/**
+ * 获得主机地址
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回主机地址
+ */
+function getHost(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return (match[2] || "") + (match[3] ? ":" + match[3] : "");
+    }
+}
+/**
+ * 获得主机名称
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回主机名称
+ */
+function getHostName(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[2] || "";
+    }
+}
+/**
+ * 获得端口号
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回端口号
+ */
+function getPort(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[3] || "";
+    }
+}
+/**
+ * 获得地址路径
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回地址路径
+ */
+function getUrlPath(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[4] || "";
+    }
+}
+/**
+ * 获得hash字符串
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回hash字符串
+ */
+function getUrlHash(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[6] || "";
+    }
+}
+/**
+ * 获得查询参数字符串
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回查询参数字符串
+ */
+function getSearchString(url = window.location.href) {
+    const match = url.match(regexp.REGEXP.URL);
+    if (match) {
+        return match[5] || "";
+    }
+}
+/**
+ * 查询参数字符串中是否包含某个参数
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @returns {boolean} 返回结果
+ */
+function hasSearchParam(url = window.location.href, name) {
+    const params = parseSearchParam(url);
+    return params[name] !== undefined;
+}
+/**
+ * 查询参数字符串中获得某个参数的值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @returns {string} 返回查询到的值
+ */
+function getSearchParam(url = window.location.href, name = "") {
+    name = name.replace(/[[\]]/g, "\\$&");
+    url = getSearchString(url) || "";
+    const reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
+    const match = url.substring(0).match(reg);
+    if (match) {
+        return decodeURIComponent(match[2]);
+    }
+}
+/**
+ * 查询参数字符串中设置某个参数的值
+ * @param {string} name 参数名
+ * @param {string|number|Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
+ * @param {string} url url地址，默认当前url地址
+ * @returns {string} 返回查询参数字符串
+ */
+function setSearchParam(url = window.location.href, name = "", value) {
+    const params = parseSearchParam(url);
+    params[name] = value;
+    // 返回替换后的url
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + stringifySearchParam(params));
+}
+/**
+ * 查询参数字符串转为对象
+ * @param {string} url url地址，默认当前url地址
+ * @returns {Object} 返回参数对象
+ */
+function parseSearchParam(url = window.location.href) {
+    const searchString = getSearchString(url) || "";
+    const searchArr = searchString.split("&");
+    const param = {};
+    for (let i = 0; i < searchArr.length; i++) {
+        const arr = searchArr[i].split("=");
+        param[decodeURIComponent(arr[0])] = decodeURIComponent(arr[1] || "");
+    }
+    return param;
+}
+/**
+ * 对象转为查询参数字符串
+ *  @param {Object} params 参数对象
+ *  @param {string} url url地址，如果不为空，则会拼接好查询参数字符串的url地址
+ *  @returns {string} 返回参数字符串
+ */
+function stringifySearchParam(params, url = "") {
+    if (typeof params !== "object")
+        return params;
+    const arr = [];
+    for (const key in params) {
+        const value = params[key];
+        if (index.isArray(value)) {
+            for (let i = 0; i < value.length; ++i) {
+                arr.push(encodeURIComponent(key + "[" + i + "]") + "=" + encodeURIComponent(value[i]));
+            }
+        }
+        else {
+            arr.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
+        }
+    }
+    // 如果url不为空，则会返回拼接好url字符串
+    if (url) {
+        return url.replace(/(\?.+?)(?=#|$)/, "?" + arr.join("&"));
+    }
+    else {
+        return arr.join("&");
+    }
+}
+/**
+ * 查询参数字符串中在最前面追加新参数和值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @param {string|number|Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
+ * @returns {string} 返回查询参数字符串
+ */
+function prependSearchParam(url = window.location.href, name, value) {
+    const searchArr = (getSearchString(url) || "").split("&") || [];
+    if (Array.isArray(value)) {
+        const arr = [];
+        for (let i = 0; i < value.length; i++) {
+            arr.push(`${encodeURIComponent(name)}[${i}]=${encodeURIComponent(value[i])}`);
+        }
+        searchArr.unshift(...arr);
+    }
+    else {
+        searchArr.unshift(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+    }
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
+}
+/**
+ * 查询参数字符串中在某个参数的前面追加新参数和值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @param {string|number|Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
+ * @param {string} beforeParam 在前面追加参数的名称
+ * @returns {string} 返回查询参数字符串
+ */
+function prependToSearchParam(url = window.location.href, beforeParam, name, value) {
+    const searchArr = (getSearchString(url) || "").split("&");
+    const beforeIndex = searchArr.findIndex((v) => v.includes(beforeParam));
+    const beforeArr = index$1.arrayInsertBefore(searchArr, beforeIndex, `${name}=${value}`);
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + beforeArr.join("&"));
+}
+/**
+ * 查询参数字符串中在最后面追加新参数和值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @param {string,number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
+ * @returns {string} 返回查询参数字符串
+ */
+function appendSearchParam(url = window.location.href, name, value) {
+    const searchArr = (getSearchString(url) || "").split("&");
+    searchArr.push(`${name}=${value}`);
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
+}
+/**
+ * 查询参数字符串中在某个参数的后面追加新参数和值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @param {string,number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
+ * @param {string} afterName 在后面追加参数的名称
+ * @returns {string} 返回查询参数字符串
+ */
+function appendToSearchParam(url = window.location.href, afterName, name, value) {
+    const searchArr = (getSearchString(url) || "").split("&");
+    const beforeIndex = searchArr.findIndex((v) => v.includes(afterName));
+    const afterArr = index$1.arrayInsertAfter(searchArr, beforeIndex, `${name}=${value}`);
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + afterArr.join("&"));
+}
+/**
+ * 查询参数字符串中移除某个参数和值
+ * @param {string} url url地址，默认当前url地址
+ * @param {string} name 参数名
+ * @returns {string} 返回查询参数字符串
+ */
+function removeSearchParam(url = window.location.href, name) {
+    const searchArr = (getSearchString(url) || "").split("&");
+    const delIndex = searchArr.findIndex((v) => v.includes(name));
+    if (delIndex > -1) {
+        searchArr.splice(delIndex, 1);
+    }
+    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
+}
+
+exports.appendSearchParam = appendSearchParam;
+exports.appendToSearchParam = appendToSearchParam;
+exports.getHost = getHost;
+exports.getHostName = getHostName;
+exports.getPort = getPort;
+exports.getProtocol = getProtocol;
+exports.getSearchParam = getSearchParam;
+exports.getSearchString = getSearchString;
+exports.getUrlHash = getUrlHash;
+exports.getUrlPath = getUrlPath;
+exports.hasSearchParam = hasSearchParam;
+exports.parseSearchParam = parseSearchParam;
+exports.prependSearchParam = prependSearchParam;
+exports.prependToSearchParam = prependToSearchParam;
+exports.removeSearchParam = removeSearchParam;
+exports.setSearchParam = setSearchParam;
+exports.stringifySearchParam = stringifySearchParam;