File Explorer

1const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;2const binRegex = /^0b[01]+$/;3const octRegex = /^0o[0-7]+$/;4const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;5 6const consider = {7    hex: true,8    binary: false,9    octal: false,10    leadingZeros: true,11    decimalPoint: "\.",12    eNotation: true,13    //skipLike: /regex/,14    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))15};16 17export default function toNumber(str, options = {}) {18    options = Object.assign({}, consider, options);19    if (!str || typeof str !== "string") return str;20 21    let trimmedStr = str.trim();22 23    if (trimmedStr.length === 0) return str;24    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;25    else if (trimmedStr === "0") return 0;26    else if (options.hex && hexRegex.test(trimmedStr)) {27        return parse_int(trimmedStr, 16);28    } else if (options.binary && binRegex.test(trimmedStr)) {29        return parse_int(trimmedStr, 2);30    } else if (options.octal && octRegex.test(trimmedStr)) {31        return parse_int(trimmedStr, 8);32    } else if (!isFinite(trimmedStr)) { //Infinity33        return handleInfinity(str, Number(trimmedStr), options);34    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation35        return resolveEnotation(str, trimmedStr, options);36    } else {37        //separate negative sign, leading zeros, and rest number38        const match = numRegex.exec(trimmedStr);39        // +00.123 => [ , '+', '00', '.123', ..40        if (match) {41            const sign = match[1] || "";42            const leadingZeros = match[2];43            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros44            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.45                str[leadingZeros.length + 1] === "."46                : str[leadingZeros.length] === ".";47 48            //trim ending zeros for floating number49            if (!options.leadingZeros //leading zeros are not allowed50                && (leadingZeros.length > 151                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))) {52                // 00, 00.3, +03.24, 03, 03.2453                return str;54            }55            else {//no leading zeros or leading zeros are allowed56                const num = Number(trimmedStr);57                const parsedStr = String(num);58 59                if (num === 0) return num;60                if (parsedStr.search(/[eE]/) !== -1) { //given number is long and parsed to eNotation61                    if (options.eNotation) return num;62                    else return str;63                } else if (trimmedStr.indexOf(".") !== -1) { //floating number64                    if (parsedStr === "0") return num; //0.065                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.7900066                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;67                    else return str;68                }69 70                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;71                if (leadingZeros) {72                    // -009 => -973                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str74                } else {75                    // +976                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str77                }78            }79        } else { //non-numeric string80            return str;81        }82    }83}84 85const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;86function resolveEnotation(str, trimmedStr, options) {87    if (!options.eNotation) return str;88    const notation = trimmedStr.match(eNotationRegx);89    if (notation) {90        let sign = notation[1] || "";91        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";92        const leadingZeros = notation[2];93        const eAdjacentToLeadingZeros = sign ? // 0E.94            str[leadingZeros.length + 1] === eChar95            : str[leadingZeros.length] === eChar;96 97        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;98        else if (leadingZeros.length === 199            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {100            return Number(trimmedStr);101        } else if (leadingZeros.length > 0) {102            // Has leading zeros — only accept if leadingZeros option allows it103            if (options.leadingZeros && !eAdjacentToLeadingZeros) {104                trimmedStr = (notation[1] || "") + notation[3];105                return Number(trimmedStr);106            } else return str;107        } else {108            // No leading zeros — always valid e-notation, parse it109            return Number(trimmedStr);110        }111    } else {112        return str;113    }114}115 116/**117 * 118 * @param {string} numStr without leading zeros119 * @returns 120 */121function trimZeros(numStr) {122    if (numStr && numStr.indexOf(".") !== -1) {//float123        numStr = numStr.replace(/0+$/, ""); //remove ending zeros124        if (numStr === ".") numStr = "0";125        else if (numStr[0] === ".") numStr = "0" + numStr;126        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);127        return numStr;128    }129    return numStr;130}131 132function parse_int(numStr, base) {133    const str = numStr.trim();134    if (base === 2 || base === 8) numStr = str.substring(2);135 136    if (parseInt) return parseInt(numStr, base);137    else if (Number.parseInt) return Number.parseInt(numStr, base);138    else if (window && window.parseInt) return window.parseInt(numStr, base);139    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");140}141 142/**143 * Handle infinite values based on user option144 * @param {string} str - original input string145 * @param {number} num - parsed number (Infinity or -Infinity)146 * @param {object} options - user options147 * @returns {string|number|null} based on infinity option148 */149function handleInfinity(str, num, options) {150    const isPositive = num === Infinity;151 152    switch (options.infinity.toLowerCase()) {153        case "null":154            return null;155        case "infinity":156            return num; // Return Infinity or -Infinity157        case "string":158            return isPositive ? "Infinity" : "-Infinity";159        case "original":160        default:161            return str; // Return original string like "1e1000"162    }163}