相关疑难解决方法(0)

我试图探索 JavaScript与普通按键访问Object相比如何执行。我在JSBEN.CH上运行了以下 3 段代码。MapSet

对象

const object = {};

for (let i = 0; i < 10000; ++i) {
    object[`key_${i}`] = 1;
}

let result = 0;
  
for (let i = 0; i < 10000; ++i) {
    result += object[`key_${i}`];
}

地图

const map = new Map();

for (let i = 0; i < 10000; ++i) {
    map.set(`key_${i}`, 1);
}

let result = 0;

for (let i = 0; i < 10000; ++i) { …

我读了一些关于javascript字典实现的问题和答案,但它们不符合我的要求:

• 字典必须能够将对象作为键
• 这些值必须由[] -operator访问

所以我提出了在Object.prototype中覆盖"valueOf"方法的想法,如下所示:

   Object.__id__ = 0;
   Object.prototype.valueOf = function() {
      if(!this.__id__)
         this.__id__ = ++Object.__id__;
       return "__id__" + this.__id__;
   }
   Object.prototype.toString = Object.prototype.valueOf;

   //test   
   var x = {p1: "5"};
   var y = [6];
   var z = {};
   z[x] = "7";
   z[y] = "8";
   console.log(z[x], z[y]);

我用google-chrome进行了测试,看起来效果很好,但我有点怀疑,这是否会带来一些弊端,因为它很容易实现.

考虑到valueOf方法在整个代码中没有用于其他目的,您认为有任何缺点吗？

我想使用 Map 而不是对象映射来声明一些键和值。但是 Typescript 似乎不支持 ES6 Map 的索引类型，这是正确的吗？有什么解决方法吗？

此外，我还希望使值类型安全，以便映射中的每个条目都具有与键对应的值的正确类型。

这是一些伪代码，描述了我想要实现的目标：

type Keys = 'key1' | 'key2';

type  Values = {
  'key1': string;
  'key2': number;
}

/** Should display missing entry error */
const myMap = new Map<K in Keys, Values[K]>([
  ['key1', 'error missing key'],
]);

/** Should display wrong value type error for 'key2' */
const myMap = new Map<K in Keys, Values[K]>([
  ['key1', 'okay'],
  ['key2', 'error: this value should be number'],
]);

/** Should pass */
const myMap = …

考虑以下两个片段（来自这个 jsperf entry）：

let val = 0;
for(let i of indices) {
  val += map.get(i);
}
// ---
let val = 0;
for(let i of indices) {
  val += obj[i];
}

这里，map是一个Map，obj是一个普通的旧 JavaScript 对象 ( let obj = {})，indices是一个随机索引数组。双方obj并map已与数据预填充，因此查找实际返回数据。查看 jsperf 以获取完整代码。

题：

为什么普通的旧 javascript 对象的性能Map超过 5 倍？这仅仅是因为在写作时，Maps 仍然非常新且未经优化吗？或者在Map查找中是否有一些开销会始终阻止它像 POJO 一样快？

如果它还没有优化，我们能期望它最终比随机查找的 POJO 更快吗？为什么？为什么不？

我一直在关注MDN上的新ES6文档,我无法找到普通对象不起作用的Map对象的真实世界用途.有没有人有地图的任何用例,并解释为什么一个对象在那种情况下不起作用？

看几个不同的文档，我所看到的只是Map（ECMAScript6）键是布尔值，字符串还是整数。有没有一种方法可以使用另一个自定义对象（通过新的CustomObject（x，y）构造函数调用来调用）添加为键？

我能够将一个对象添加为键，但是无法检查Map是否具有所述对象。

var myMap = new Map();
myMap.set( new Tuple(1,1), "foo");
myMap.set('bar', "foo");


myMap.has(?);  
myMap.has('bar');  // returns true

有没有解决的办法？

  var myMap = new Map();
  myMap.set( new Tuple(1,1), "foo");

 for(some conditions) {
 var localData = new Tuple(1,1); //Use directly if exists in myMap? 
 map.has(localData) // returns false as this is a different Tuple object. But I need it to return true
}

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map/has

Map我正在尝试从字典创建一个对象string,function。

const entityTagDictionnary = [
  ['GRAPH_ADD_PROPERTY_SUBTYPE', (entity) => {
    console.log('addSubtype called!');
    return entity;
  }],
  ['GRAPH_IGNORE_PROPERTY_SENTENCE', (entity) => {
    console.log('ignore property called!');
    return entity;
  }],
  ['GRAPH_FORMAT_DATES', (entity) => {
    console.log('formatDates called!');
    return entity;
  }],
];

const entityMap : Map<string, Function> = new Map(entityTagDictionnary);

我有以下错误：

Argument of type '(string | ((entity: any) => any))[][]' isn't matching the argument 'Iterable<[string, Function]>'.

我做错了什么吗？

假设我想创建一个字典，例如，汽车品牌到一个或多个模型。

似乎我可以在 ES6 中以两种不同的方式做到这一点。

1. 创建一个对象映射：

代码：

const makesAndModels = {
    "mazda": [
        { name: "Miata" },
        { name: "626" }
    ],
    "toyota": [
        { name: "Camry" }
    ],
    ...
};

2. 创建一个 ES6 Map 实例：

代码：

const makes = {
    mazda: { name: "Mazda" },
    toyota: { name: "Toyota" }
};

const makesAndModels = new Map([
    [makes.mazda, [
        { name: "Miata" },
        { name: "626" }
    ]],
    [makes.toyota, [
        { name: "Camry" }
    ]],
    ...
]);

上述两种方法之间的主要区别和优缺点是什么？

Map如何与字典/对象不同？

换句话说,let x = {}和之间有什么区别let x = new Map()？

我正在学习javascript，并遇到了一些类似于以下代码的Javascript代码。似乎carArrays仅通过将数组分配给即可将对象变成地图carArrays[car1.year]。因此，我对此代码有很多疑问。

1. 哪些JavaScript规则允许您执行此操作？

2. 我以为[]是阵列。如果carArrays现在是地图，为什么使用方括号将其索引？

3. 关于carArrays成为地图，我的解释正确吗？还是仍将其视为具有键“ 1999”和“ 2005”的对象？

我的代码：

function car( make, model, year){
    this.make = make;
    this.model = model;
    this.year = year;
}

let car1 = new car('bmw', '3series', 1999);
let car2 = new car('ford', 'crownvic', 1999);
let car3 = new car('honda', 'accord', 1999);

let car4 = new car('bentley', '5', 2005);
let car5 = new car('chevy', 'silverado', 2005);
let car6 = new car('toyota', 'rav4', 2005);

let carArrays = {};
carArrays[car1.year] = [car1, car2, car3];
carArrays[car4.year] …