JS: 使用字典比遍历数组更快吗？

Question

我正在使用Nodejs构建一些程序，需要在内存中跟踪大量的用户。此外，我将拥有一个按id过滤用户的函数。代码看起来会像这样：

const users = [
    {
        id: 1,
        name: 'John',
        friends: [3, 6, 8]
    },
    {
        id: 2,
        name: 'Mark',
        friends: [567, 23]
    }
]

function getUserById(userId) {
    const user = users.filter(user => user.id === userId);
    return user[0];
}

问题是，这个版本是否普遍更快(每个键都是用户ID)：

const users = {
    1: {
        id: 1,
        name: 'John',
        friends: [3, 6, 8]
    },
    2: {
        id: 2,
        name: 'Mark',
        friends: [567, 23]
    }
}

function getUserById(userId) {
   return users[userId];
}

我的直觉告诉我字典更快。事实是什么呢？

- i.brod

---

假设有10万个用户。 - i.brod

你的10万用户会感激你使用数据库。如果你真的需要将它们存储在内存中，也许你想看看Redis。 - Max

这个状态将被用来跟踪通过SocketIO连接的用户，这就是为什么使用内存的原因。 - i.brod

Answer 1

对象中的键查找时间不能保证。它可能也是O(n)，但大多数引擎会优化为O(1)，如果你动态地多次查找一个键。过滤数组的时间复杂度是O(n)，然而.find()平均速度快两倍：

  return users.find(user => user.id === userId);

现在唯一保证O(log n)查找的数据结构是Map：

 const userMap = new Map(users.map(u => [u.id, u]));
 console.log(userMap.get("test"));

如果你计划在非常大的规模下（100k 是很大的），我会建议把这个任务移到数据库中，因为它可以针对这些任务进行重度优化。MongoDB 很容易采用，Redis 速度非常快，还有许多其他选择。

- Jonas Wilms

---

关于数据库：这不仅仅是一个网站用户列表，而是通过SocketIO连接的用户列表。这就是为什么我需要有一个内存跟踪。 - i.brod

@sheff2k1 那么我会直接将另一个属性存储到套接字对象中。 - Jonas Wilms

是的，我计划在每个套接字上放置一个“userData”属性，但我仍然需要跟踪所有连接的套接字，以便有时执行一些特定于套接字的任务。 - i.brod

@sheff2k1 将用户移至数据库还可以让您并行运行多个Nodejs Websockets，这将超越内存nodejs服务器中的单个线程。 - Jonas Wilms

是的，这是一个很好的观点。请注意，我已经在SQL数据库中拥有了用户。这个状态对象只是一种在套接字和已登录用户之间创建一些关联的方式（登录系统与SocketIO完全分离）。 - i.brod

Answer 2

我写了一个小脚本，可以复制粘贴到控制台，并显示这个问题的实际数据，并在实践中验证Jonas Wilms的答案。

function random_int_from_range(x, y) {
return (x + Math.floor(Math.random() * (y - x + 1)));
}

function generate_name(length_min, length_max) {
  var letters = 'abcdefghijklmnopqrstuvwxyz';
  var name_array = [];

  for (var i = 0; i <= random_int_from_range(length_min, length_max); i ++) {
      name_array.push(letters.charAt(Math.floor(Math.random() * letters.length +1)));
  }

  return name_array.join('')
}

function generate_friends_array(length_min, length_max, num_users) {
  friends_array = [];
  for (var i = 0; i < random_int_from_range(length_min, length_max); i++) {
    friends_array.push(random_int_from_range(0, num_users - 1))
  }

  return friends_array
}

function generate_users_dict(num_users) {
  var users = {};
  for (var i = 0; i < num_users; i++) {
    users[i] = {
        'id': i,
        'name': generate_name(4,6),
        'friends': generate_friends_array(0, 20, num_users)
    }
  }

  return users
}

function generate_users_list_from_dict(users_dict) {
  var users_list = [];

  for (var key in  users_dict) {
    users_list.push(users_dict[key]);
  }

  return users_list;
}

function get_diff_in_seconds_from_two_milisecond_values(early_value, late_value) {
  return (late_value - early_value) / 1000
}

function get_user_by_id_from_dict(users_dict, user_id) {
  return users_dict[user_id]
}

function get_user_by_id_from_list(users_list, user_id) {
  const users = users_list.filter(user => user.id === user_id);
  return users[0]
}

function get_time_for_retrieval_of_item_from_object(object, object_length) {
  var function_names = ['get_user_by_id_from_dict', 'get_user_by_id_from_list'];
  var random_id = random_int_from_range(0, object_length - 1);
  var function_name = '';

  if (Array.isArray(object)) {
    function_name = function_names[1];
  }
  else {
    function_name = function_names[0];
  }

  var time_before_retrieval = new Date().getTime();
  window[function_name](object, random_id);
  var time_after_retrieval = new Date().getTime();

  return get_diff_in_seconds_from_two_milisecond_values(time_before_retrieval, 
  time_after_retrieval);
}

function test_retrieval_times(number_of_users, tests_num, object_type) {
  var users_dict = generate_users_dict(number_of_users);
  var users_list = generate_users_list_from_dict(users_dict);
  var times_array = [];
  var object = '';

  if (object_type == 'dict') {
    object = users_dict;
  }
  else {
    object = users_list;
  }

  for (var i = 0; i < tests_num; i++) {
    times_array.push(get_time_for_retrieval_of_item_from_object(object, 
    number_of_users));
  }

  return times_array;
}

function get_average_retrieval_time(object_type, number_of_users, 
                                    numbers_of_retrievals) {
  var retrieval_times = test_retrieval_times(number_of_users, numbers_of_retrievals, 
                                             object_type);
  var sum = 0;

  for (var i = 0; i < retrieval_times.length; i++) {
    sum += retrieval_times[i];
  }

  console.log('average retrieval time for ' +  object_type + ': ' + sum / 
              numbers_of_retrievals);
}

var number_of_users = parseInt(prompt("Please enter object size", "1000000"));
var number_of_retrievals = parseInt(prompt("Please enter number of retrievals", 
                                    "100"));

get_average_retrieval_time('dict', number_of_users, number_of_retrievals);
get_average_retrieval_time('list', number_of_users, number_of_retrievals);

测试结果将被打印到控制台。

- Ariel Ferdman

Answer 3

使用一个包含10,000个对象的列表。

我发现字典查找比数组的.find方法快得多。

https://jsbench.me/u1ll3uib1t/1

有趣的是，Map和Set是最快的，其次是plain obj {}，而arrays则远远落后。

- Jack