snippets

记录在公众号，或者开发过程中遇到的一些有意思的代码片段

1、创建一个函数来判断给定的表达式中的大括号是否闭合，返回 True/False，对于空字串，返回 True

function isBalanced(exp){
    let info = exp.split('');
    let stack = [];
    for(let i = 0; i < info.length; ++i){
        let el = info[i];
        if(el === '{'){
            stack.push('{');
        }else if(el === '}'){
            if(stack.length === 0){
                return false;
            }
            stack.pop();
        }
    }
    return stack.length === 0;
}

2、实现函数 isBalanced，用 true 或 false 表示给定的字符串的括号是否平衡（一一对应）。注意了是要支持三种类型的括号{}，[]，和()。带有交错括号的字符串应该返回 false

const isBalanced = str => {
    const map = new Map([
        ['{', '}'],
        ['[', ']'],
        ['(', ')']
    ]);
    let stack = [];
    for(let i = 0; i < str.length; ++i){
        let node = str[i];
        if(map.has(node)){
            stack.push(node);
        }else if([...map.values()].includes(node)){
            if(stack[stack.length-1] !== [...map.entries()].filter(el => el[1] === node).pop().shift()){
                return false
            }
            stack.pop()
        }
    }
    return stack.length === 0
}

3、再次扩充一下这道题目。要求严格限制括号的顺序，即中括号外围只能是大括号，内部只能是小括号。也即：括号只能以大括号、中括号、小括号的顺序只能前面的包含后面的，不能后面的包含前面的

const isStrictBalanced= str => {
    const map = new Map([
        ['{', '}'],
        ['[', ']'],
        ['(', ')']
    ]);
    let stack = [];
    let keys = [...map.keys()], values = [...map.values()];
    for(let i = 0; i < str.length; ++i){
        let node = str[i];
        if(map.has(node)){
            if(stack.length){
                let arr = [node, [...stack].pop()].map(el => keys.indexOf(el))
                if(arr[0] < arr[1]){
                    return false;
                }
            }
            stack.push(node);
        }else if(values.includes(node)){
            let needKey = [...map.entries()].filter(el => el[1] === node).pop().shift();
            if(needKey !== [...stack].pop()){
                return false
            }
            stack.pop()
        }
    }
    return stack.length === 0
}

4.快速过滤掉数据的假值

const compact = arr => arr/filter(Boolean)

5.双位运算符~~

对正数来说替代Math.floor()

~~4.9 === 4 //true

对负数来说替代Math.ceil()

~~-4.9 === -4 //true

6.取整|0,效果跟~~一样

1.3|0 //1
-1.9|0 //0

7.判断奇偶&1

!!(3&1)//true
!!(2&1)//false

遍历到为 true

let obj={'key1':'v1','key2':'v2','key3':'v3','key0':'v0'};
Reflect.ownKeys(obj).reduce(
    (prev, name) => {
        console.log(name);
        return prev || obj[name] ==='v2';
        },
    false
  );
  let state=false
  for(key in obj){
       console.log(key);
       if(obj[name] ==='v2'){
           state= true;
           break
       }
  }
  Reflect.ownKeys(obj).map(name=> obj[name] ==='v2'&& true)
  for(let i=0;i<Reflect.ownKeys(obj).length;i++){
       console.log(key);
       if(obj[name] ==='v2'){
           break
       }
  }