目录

正则

合法的URL

邮箱、电话

字符串方法

千位分割：num.slice(render, len).match(/\d{3}/g).join(',')

版本号比较

判断回文

json/Object

遍历

自身属性

for...in+hasOwnProperty(key)

Object.获取数组(obj)：Object.keys，Object.values ，Object.entries

+原型链

for...in

嵌套深：递归->栈

正则

合法的URL

URL结构一般包括协议、主机名、主机端口、路径、请求信息、哈希

1. 域名不区分大小写："www"子域名（可选）、二级域名、"com"顶级域名
2. 只能包含字母（a-z、A-Z）、数字（0-9）和连字符（-）（但-不能再首尾）

https://www.bilibili.com/video/BV1F54y1N74E/?spm_id_from=333.337.search-card.all.click&vd_source=6fd32175adc98c97cd87300d3aed81ea
//开始:                     ^
//协议:                     http(s)?:\/\/
//域名:                     [a-zA-Z0-9]+-[a-zA-Z0-9]+|[a-zA-Z0-9]+
//顶级域名 如com cn,2-6位:   [a-zA-Z]{2,6}
//端口 数字:                (:\d+)?
//路径 任意字符 如 /login:   (\/.+)?
//哈希 ? 和 # ，如?age=1:    (\?.+)?(#.+)?
//结束:                      $
//     https://           www.bilibili                com    /video/BV1F54y1N74E  ?spm..            
/^(http(s)?:\/\/)?(([a-zA-Z0-9]+-[a-zA-Z0-9]+|[a-zA-Z0-9]+)\.)+([a-zA-Z]{2,6})(:\d+)?(\/.+)?(\?.+)?(#.+)?$/.test(url)

邮箱、电话

// 电话号码格式：(XXX) XXX-XXXX 或 XXX-XXX-XXXX 或 XXXXXXXXXX
function isValidPhoneNumber(phoneNumber) {
    const phoneRegex = /^(\(\d{3}\)\s?|\d{3}[-.\s]?)?\d{3}[-.\s]?\d{4}$/;
    return phoneRegex.test(phoneNumber);
}

// 示例
console.log(isValidPhoneNumber("(123) 456-7890"));  // true
console.log(isValidPhoneNumber("123-456-7890"));    // true
console.log(isValidPhoneNumber("1234567890"));       // true
console.log(isValidPhoneNumber("12345"));            // false

function isValidEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

// 示例
console.log(isValidEmail("user@example.com"));        // true
console.log(isValidEmail("user@.com"));               // false
console.log(isValidEmail("invalid.email@domain"));    // false

字符串方法

千位分割：num.slice(render, len).match(/\d{3}/g).join(',')

  const format = (n) => {
        let num = n.toString() // 拿到传进来的 number 数字 进行 toString
        let len = num.length // 在拿到字符串的长度
        // 当传进来的结果小于 3 也就是 千位还把结果返回出去 小于3 不足以分割
        if (len < 3) {
            return num
        } else {
            let render = len % 3 //传入 number 的长度 是否能被 3 整除
            if (render > 0) { // 说明不是3的整数倍
                return num.slice(0, render) + ',' + num.slice(render, len).match(/\d{3}/g).join(',')
            } else {
                return num.slice(0, len).match(/\d{3}/g).join(',')
            }
        }
    }

    let str = format(298000)
    console.log(str)

版本号比较

/**
 * 解法一：分割截取
 * 思路：
 *（1）先根据.号分割成字符串数组，获取两个数组中的最大长度值，
 *（2）按顺序遍历比较，详细过程看以下代码
 * 时间复杂度：O(max(n, m))
 * 空间复杂度：O(max(n, m))
 */
export function compare(version1, version2){
    const arr1 = version1.split('.')
    const arr2= version2.split('.')
    const maxLen = Math.max(arr1.length, arr2.length)
    
    for (let i = 0; i < maxLen; i++) {
        // arr1[i] - '0' ，js 会强制转换成 number 然后相减
        // 例如：（'01' - '0'）， 结果是 1 （number 类型）
        // @ts-ignore
        const num1 = arr1[i] ? parseInt(arr1[i]): 0 
        // @ts-ignore
        const num2 = arr2[i] ? parseInt(arr2[i]): 0
        if (num1 > num2) return 1
        if (num1 < num2) return -1
    }
    
    return 0
} 

判断回文

function isPalindrome(str) {
    return str === str.split('').reverse().join('');
}

json/Object

遍历

自身属性

for...in+hasOwnProperty(key)

for (let key in myObject) {
  if (myObject.hasOwnProperty(key)) {
    console.log(key, myObject[key]);
  }
}

Object.获取数组(obj)：Object.keys，Object.values ，Object.entries

const myObject = { a: 1, b: 2, c: 3 };

Object.keys(myObject).forEach(key => {
  console.log(key, myObject[key]);
});

Object.values(myObject).forEach(value => {
  console.log(value);
});

Object.entries(myObject).forEach(([key, value]) => {
  console.log(key, value);
});

+原型链

for...in

嵌套深：递归->栈

//递归
function recursion() {
    let res;
    res+=recursion(...);
    return res;
}
//栈
function iterative() {
    let res;
    const stack = [root]; 
    while (stack.length > 0) {
        const current = stack.pop(); 
        res+=...
        stack.push();
    }
    return res;
}

递归方法可能会导致 "栈溢出" 错误，js有一个限制，防止函数调用自身太多次。

// 示例使用
const a = {
    num: NaN,
    children: [
        { num: 10, children: [] },
        { num: 'not a number', children: [
            { num: '3', children: [] }
        ]}
    ]
};

//递归
function sumNumbers(obj) {
    let sum = 0;

    const num=Number(current.num)
    if (typeof num=== 'number'&& !isNaN(num)) {
       sum += num
    }
    if (Array.isArray(obj.children)) {
        for (const child of obj.children) {
            sum += sumNumbers(child);
        }
    }

    return sum;
}
//栈
function sumNumbersIterative(root) {
    let sum = 0;
    const stack = [root]; 
    while (stack.length > 0) {
        const current = stack.pop(); 
        const num=Number(current.num)
        if (typeof num=== 'number'&& !isNaN(num)) {
            sum += num
        }

        if (Array.isArray(current.children)) {
            for (const child of current.children) {
                stack.push(child);
            }
        }
    }

    return sum;
}



console.log(sumNumbersIterative(a)); // 应输出13