Question

我有以下嵌套对象

const ERR_CODES = {
    INVALID_CONSUMER_ID: {
        code: 1000,
        message: 'Invalid Consumer ID',
    },
    INVALID_MOBILE: {
        code: 1001,
        message: 'Invalid Mobile Number',
    },
    INVALID_ZIPCODE: {
        code: 1002,
        message: 'Invalid Zipcode',
    },
    INVALID_FIRST_NAME: {
        code: 1000,
        message: 'First Name',
    },
}

我想在两个对象具有相同代码时抛出错误，例如示例消费者ID和名字都有1000个错误代码。通过我的ERR_CODES obj查看是否有任何代码重复的最快方法是什么？

Answer 1

您可以使用地图来跟踪代码并与之进行比较，如果代码已经是地图的一部分，您可能会抛出错误。

Answer 2

创建一个包含所有代码的数组，然后获取所有唯一代码。如果长度相等，则没有重复。如果唯一代码数组较短，则会重复。

const ERR_CODES = {
    INVALID_CONSUMER_ID: {
        code: 1000,
        message: 'Invalid Consumer ID',
    },
    INVALID_MOBILE: {
        code: 1001,
        message: 'Invalid Mobile Number',
    },
    INVALID_ZIPCODE: {
        code: 1002,
        message: 'Invalid Zipcode',
    },
    INVALID_FIRST_NAME: {
        code: 1000,
        message: 'First Name',
    },
};

const codes = Object.keys(ERR_CODES).map(err => ERR_CODES[err].code)

const uniq_codes = codes.reduce((p, c) => {
    if (p.indexOf(c) < 0) p.push(c);
    return p;
}, []);

console.log(codes.length == uniq_codes.length);

Answer 3

由于您只需要检查是否重复了任何代码，我会选择Set来存储您的所有代码：

let codes_num = Object.keys(ERR_CODES).map(elem => {
    return ERR_CODES[elem].code;
});

let codes = new Set(codes_num);

由于Set的属性，重复的元素被丢弃。出于这个原因，像这样简单的检查：

Object.keys(ERR_CODES).length == codes.size

将告诉您是否找到了重复的代码。

Answer 4

可能不是最快的方式，而是一种方法

const ERR_CODES = {
    INVALID_CONSUMER_ID: {
        code: 1000,
        message: 'Invalid Consumer ID',
    },
    INVALID_MOBILE: {
        code: 1001,
        message: 'Invalid Mobile Number',
    },
    INVALID_ZIPCODE: {
        code: 1002,
        message: 'Invalid Zipcode',
    },
    INVALID_FIRST_NAME: {
        code: 1000,
        message: 'First Name',
    },
};

function isValid(data) {
    try{
    Object.keys(data).reduce((obj, key) => {
       if (data[key].code in obj) {
          throw new Error(`Duplicate code: ${data[key].code}`);
       } else {
          obj[data[key].code] = 'found';
       }
       return obj;
    }, {});
    } catch(e) {
       console.log(e.message);
       return false;
    }
    return true;
}

console.log(isValid(ERR_CODES));

Answer 5

我将采用filter方法检查密钥是否存在多次。

使用过滤器，我们可以使用2个过滤器并检查返回数组的大小来获取重复项的列表。如果长度大于1，那意味着我们发现重复。

＆＃13;

const ERR_CODES = {
  INVALID_CONSUMER_ID: {
    code: 1000,
    message: 'Invalid Consumer ID',
  },
  INVALID_MOBILE: {
    code: 1001,
    message: 'Invalid Mobile Number',
  },
  INVALID_ZIPCODE: {
    code: 1002,
    message: 'Invalid Zipcode',
  },
  INVALID_FIRST_NAME: {
    code: 1000,
    message: 'First Name',
  },
}

let codes = Object.values(ERR_CODES)

let result = codes.filter(item => codes.filter(i => i.code == item.code).length > 1)

console.log(result)

if(result.length > 0) {
  // We have duplicates throw error here
  console.error('Duplicate codes')
}

＆＃13;

Answer 6

我对最快解决方案的考虑只会迭代ERR_CODES一次，并且一旦发现重复就会中断：

const codes = new Set();

for (err in ERR_CODES) { 
  const {code} = ERR_CODES[err]; 
  if (codes.has(code)) { 
    console.error(`Duplicate code: ${code}`); 
    break; 
  } 
  codes.add(code); 
}

查看对象是否在嵌套对象中重复的最快方法

6 个答案: