Question

每个用户在一个对象中都有一个数组（该主对象随时可以在其中包含多达3,000个数组，并且还在不断增长）。

在数组中包含用户名和用户发送的最后4条消息（消息使用快速哈希方法进行哈希处理）。较旧的消息被推出。

将新消息添加到数组时，将检查所有元素以查看是否相等。会有更好的方法做到这一点。我肯定有一个带有嵌套数组的大型对象会有点慢吗？

let messagescont = {}
 if (!messagescont.hasOwnProperty("a" + message.author.id)){
 //add new user to object
 messagescont["a" + message.author.id] = [{data})
 }else{
 //user has object
  messagescont["a" + message.author.id].push({data})
     if(messagescont["a" + message.author.id].length > 4){
         messagescont["a" + message.author.id].splice(0,1)
         let hashtable = [];
         messagescont["a" + message.author.id].forEach(messages => 
         hashtable.push(messages.data.hash))
         const arraysame = !!hashtable.reduce(function (a,b){ return (a === b)? a : NaN;});
     }
 }

数据对象看起来像这样

    const data = {
        hash: hashCode(message.content),  
        username: message.author.username,
        userid: message.author.id,
    }

那个数组/对象/数组混乱

   {username [{data},{data},{data}],
   username2 [{data},{data},{data} }

Answer 1

类似于@epascarello的注释中暗示：如果没有可衡量的性能问题，请不必担心。不过，这是一个略微优化的版本。

const messagesPerAuthor = {};
const contKey = "a" + message.author.id; // Avoid recomputing this value 6 times
if (!messagesPerAuthor[contKey]) {
  messagesPerAuthor[contKey] = [];
}
messagesPerAuthor[contKey].push({ data });
if (messagesPerAuthor[contKey].length > 4) {
  messagesPerAuthor[contKey].splice(0, 1);
}
let hasDuplicate = false;
if (messagesPerAuthor[contKey].length > 1) {
  // No need to bother with the `.some` indication if there's only one message
  const hashesSeen = {}; // could also be a `new Set()` for more modern browsers
  hasDuplicate = messagesPerAuthor[contKey].some(message => {
    const seen = hashesSeen[message.data.hash]; // true if we had seen this hash before
    hashesSeen[messages.data.hash] = true;
    return seen; // returning a truthy value will early-exit the `some` loop.
  });
}

在for(var i = 0; i < messagesPerAuthor[contKey].length; i++)中使用普通的break样式循环可能比some更快，但是由于FP样式正在流行...：）

从大型对象添加和删除数组

1 个答案: