相关疑难解决方法(0)

我正在检查一个变量,例如foo,与多个值的相等性.例如,

if( foo == 1 || foo == 3 || foo == 12 ) {
    // ...
}

关键是这个繁琐的任务代码相当多.我想出了以下内容:

if( foo in {1: 1, 3: 1, 12: 1} ) {
    // ...
}

但这并不完全吸引我,因为我必须为对象中的项目提供冗余值.

有没有人知道对多个值进行相等检查的正确方法？

这可能是因为集合对Javascript来说相对较新,但是我无法在StackO或其他任何地方找到一篇文章来讨论Javascript中两者之间的性能差异.那么,两者之间在性能方面有什么不同？具体来说,当涉及删除,添加和迭代时.

indexOf是简单地遍历数组还是做更快的事情？我知道这取决于实现,但Chrome或Firefox有什么作用？

在v8实现检索/查找是否为O(1)这是一个公平的假设吗？

(我知道标准并不保证)

安全代码new Set()可能如下所示:

let items = [];
for (let item of set)
  if (isBad(item))
    items.push(item);
for (let item of items)
  set.delete(item)

我可以简化代码:

for (let item of set)
  if (isBad(item))
    set.delete(item);

安全代码new Map()可能如下所示:

let keys = [];
for (let [key, val] of map)
  if (isBadKey(key) || isBadValue(val))
    keys.push(key);
for (let key of keys)
  map.delete(key)

我可以简化代码:

for (let [key, val] of map)
  if (isBadJey(key) || isBadValue(val))
    map.delete(key)

所以我知道 Javascript Maps 有一定数量的键可以存储（大约 16.7 M ）。

我试图测试我是否可以（以一种非常丑陋的方式）从数组中删除最旧的元素。我注意到无论我做什么，实际上并不是地图大小成为限制因素，而是我所做的操作数量限制了我。

下面是一个示例代码：

const map = new Map();
let i = 0;

while (true) {
  i++;

  set(i, i);

  if (i % 1000 === 0)
    console.log('INSERTED: ', i, 'KEYS', 'MAP SIZE :', map.size);
}

function set(key, value) {
  if (map.size > 16770000) {
    Array.from(map.keys()).slice(0, 10000).forEach(key => map.delete(key));
    console.log('DELETED, current map size:', map.size);
  }

  try {
    map.set(key, value);
  } catch (e) {
    console.log('MAP SIZE:', map.size, 'INSERTED:', key);
    throw e;
  }
}

当您运行代码段时，只需检查您的控制台。您应该注意的是最后（当抛出异常时）您将获得 Map Size 和 INSERTED。地图大小将是一个变量（取决于您删除的元素数量，在本例中为 …

我在一个答案中看到该Set.has()方法是O（1）和Array.indexOf()O（n）。

var a = [1, 2, 3, 4, 5];
a.indexOf(5);          


s = new Set(a);
s.has(5);              //Is this O(1)?

Set.has()真的是O（1）吗？

我很高兴Map在我的 JavaScript 代码库中使用索引访问，但我刚刚偶然发现了这个基准：https ://stackoverflow.com/a/54385459/365104

我也在这里重新创建了它： https: //jsben.ch/HOU3g

benchmark 所做的基本上就是用 1M 个元素填充一个映射，然后迭代它们。

我希望 Map 和 Object 的结果是相同的，但它们有很大不同 - 有利于 Object。

这是预期的行为吗？可以解释一下吗？是因为订购要求吗？或者因为map正在做一些键散列？或者只是因为 Map 允许任何对象作为键（我希望它使用指针地址作为键，这不需要任何哈希）？Map 和 Object 索引算法有什么区别？

这是非常出乎意料和令人沮丧的 - 基本上我将不得不恢复到老式的“对象作为地图”编码风格。

更新#1

正如评论中所建议的，对象可能会优化为数组（因为它是从零开始的整数索引）。

将迭代顺序从sizeto 0-Object更改为快 2 倍。当使用字符串作为索引时，Map 的性能提高了 2 倍。

出于好奇，我决定确认我的信念：就插入/添加和查找而言，Set实现比Object（在google chrome中运行）要快。我的结果有点令人困惑。

x = {};
y = new Set();

console.time('Insert into Object');
for (var i = 0; i < 1000000; i++) {
    x[i] = 0;
}
console.timeEnd('Insert into Object');

console.time('Insert into Set');
for (i = 0; i < 1000000; i++) {
    y.add(i);
}
console.timeEnd('Insert into Set');

var t = 0;

console.time('Retrieve from Object');
for (i = 0; i < 1000000; i++) {
    t = x[i];
}
console.timeEnd('Retrieve from Object');

console.time('Retrieve from Set');
for (i = 0; i < 1000000; i++) …

这是关于我在亚马逊采访时与面试官进行的辩论.

我来创建一个对象:

var Obj = {};
Obj['SomeProperty'] = function ( ) { console.log("Accessed some property"); };
Obj[69] = true;

JavaScript中是否有任何保证当我随后访问这两个属性时Obj['SomeProperty'],Obj[69]以及相应的值function ( ) { console.log("Accessed some property"); };并69在O(1)时间内查找？我知道接入运营商[]提供了一个经验丰富的程序员的印象是,他处理一个O(1)查找结构,但不能将它有可能为一个JavaScript引擎来实现Object的方式,使得性能不为O抬头(1 )？

我想在不改变原始数组的情况下计算给定数组中的唯一值，但解决方案必须在time complexity of O(n). 到目前为止，所有我见过的解决方案，有time complexity of O(n^2) 喜欢这里。我在解决方案的逻辑中找不到错误。我是数据结构和算法的新手，想要一个简单的解决方案。

我的代码 -

const countUniqueValues = (arr) =>{
    if(arr.length === 0){
        return console.log(arr.length);
    }else if(arr.length === 1){
        return console.log(arr.length);
    }

    const unique = [];
    let i = 0;
    for( let j = 1; j < arr.length; j++){
        if(arr[i] !== arr[j]){
            i ++;
            unique.push(arr[i]);
        }
    }
    return console.log(unique);
}

//test cases
countUniqueValues([1,1,1,1,1,2]) // 2
countUniqueValues([1,2,3,4,4,4,7,7,12,12,13]) // 7
countUniqueValues([]) // 0
countUniqueValues([-2,-1,-1,0,1]) // 4

错误的输出 -

[ 1 ] …