Chà,
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
2 đã là duy nhất ... nhưng, đó là một mảng. Vì vậy, bạn không thể truy cập trực tiếp một đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
3 nhưng tìm chỉ mục với vòng lặp.Nếu tôi hiểu câu hỏi của bạn theo cách đúng cách ... bạn muốn tạo bản đồ mới với khóa duy nhất
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
4 Làm thế nào về cách này? - Giảm có thể giúp chúng ta. :]BTW, câu trả lời của Nina Scholz là đúng.
let myMap = {}; //I declare my variable
//Then I fetch a json and parse it
fetch[link]
.then[function[response] {
return response.json[]; //parse the json string
}].then[function[json] {
// myMap = json; //set it to myMap to be used
myMap = json.reduce[function[p, n] { p[n.a] = n; return p; }, {}];
// n.a or n['a'] - primary key [in sample, [1,2,3...]]
// "myMap[1].foo", "myMap[2].bar"
// or change KEY as your taste.
myMap = json.reduce[function[p, n] { p['k' + n.a] = n; return p; }, {}];
// "myMap.k1.foo", "myMap.k2.bar"
// It's unique but if you want everything...
myMap = json.reduce[function[p, n] {
var k = 'k' + n.a;
if[p[k] !== undefined] { p[k] = n; }
else if[Array.isArray[p[k]]] { p[k].push[n]; }
else { p[k] = [p[k]] ; }
return p;
}, {}];
}
Khóa của một đối tượng phải là một chuỗi hoặc biểu tượng, bạn không thể sử dụng một đối tượng làm khóa. Một đối tượng không có thuộc tính đại diện cho kích thước của bản đồ. Đối tượng
5 object holds key-value pairs and remembers the original insertion order of the keys. Any value [both objects and primitive values] may be used as either a key or a value. const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
Bản đồ JavaScript hoạt động như thế nào?
Phương thức Bản đồ [] trong JavaScript tạo một mảng bằng cách gọi một hàm cụ thể trên mỗi phần tử có trong mảng cha. Nó là một phương pháp không đột biến. Nói chung phương thức MAP [] được sử dụng để lặp lại trên một mảng và chức năng gọi trên mọi yếu tố của mảng.
5 giữ các cặp giá trị khóa và nhớ thứ tự chèn ban đầu của các khóa. Bất kỳ giá trị nào [cả đối tượng và giá trị nguyên thủy] có thể được sử dụng làm khóa hoặc giá trị.may
only occur once; it is unique in the const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5's collection. A const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 object is iterated by key-value pairs — a const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
0 loop returns a 2-member array of wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
1 for each iteration. Iteration happens in insertion order, which corresponds to the order in which each key-value pair was first inserted into the map by the
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
2 method [that is, there wasn't a key with the same value already in the map when wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
2 was called].wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
Đặc điểm kỹ thuật yêu cầu các bản đồ phải được thực hiện "Trung bình, cung cấp thời gian truy cập là cao cấp về số lượng các phần tử trong bộ sưu tập". Do đó, nó có thể được biểu diễn bên trong dưới dạng bảng băm [với o [1] tra cứu], một cây tìm kiếm [với o [log [n]] tra cứu] hoặc bất kỳ cấu trúc dữ liệu nào khác, miễn là độ phức tạp tốt hơn o [N].
Bình đẳng chính
Bình đẳng giá trị dựa trên thuật toán sikevaluezero. .
Đối tượng so với bản đồ
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
0 tương tự như ________ 15, cả hai cho phép bạn đặt các khóa thành các giá trị, truy xuất các giá trị đó, xóa các khóa và phát hiện xem có gì đó được lưu trữ ở một phím không. Vì lý do này [và vì không có lựa chọn thay thế tích hợp], const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
0 đã được sử dụng dưới dạng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 trong lịch sử.Tuy nhiên, có những khác biệt quan trọng làm cho
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 thích hợp hơn trong một số trường hợp:Đặt thuộc tính đối tượng
Cài đặt các thuộc tính đối tượng cũng hoạt động cho các đối tượng MAP và có thể gây ra sự nhầm lẫn đáng kể.
Do đó, điều này dường như hoạt động theo một cách:
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
Nhưng cách đặt một thuộc tính không tương tác với cấu trúc dữ liệu bản đồ. Nó sử dụng tính năng của đối tượng chung. Giá trị của 'BLA' không được lưu trữ trong bản đồ cho các truy vấn. Các hoạt động khác trên dữ liệu không thành công:
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
Việc sử dụng chính xác để lưu trữ dữ liệu trong bản đồ là thông qua phương thức
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
5.const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
Người xây dựng
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
6Tạo một đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 mới.Tính chất tĩnh
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
8Hàm tạo thành được sử dụng để tạo các đối tượng dẫn xuất.
Thuộc tính thể hiện
const contacts = new Map[]
contacts.set['Jessie', {phone: "213-555-1234", address: "123 N 1st Ave"}]
contacts.has['Jessie'] // true
contacts.get['Hilary'] // undefined
contacts.set['Hilary', {phone: "617-555-4321", address: "321 S 2nd St"}]
contacts.get['Jessie'] // {phone: "213-555-1234", address: "123 N 1st Ave"}
contacts.delete['Raymond'] // false
contacts.delete['Jessie'] // true
console.log[contacts.size] // 1
9Giá trị ban đầu của thuộc tính
const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
0 là chuỗi const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
1. Thuộc tính này được sử dụng trong const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
2.const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
3Trả về số cặp khóa/giá trị trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5.Phương pháp thể hiện
const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
5Xóa tất cả các cặp giá trị khóa khỏi đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5.const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
7Trả về
const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
8 nếu một phần tử trong đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 tồn tại và đã bị xóa hoặc const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
0 nếu phần tử không tồn tại. const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
1 sẽ trở lại const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
0 sau đó.const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
3Trả về giá trị được liên kết với khóa được truyền hoặc
const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
4 nếu không có.const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
5Trả về một boolean cho biết liệu một giá trị có được liên kết với khóa được truyền trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 hay không.const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
7Đặt giá trị cho khóa được truyền trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5. Trả về đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5.const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
0Trả về một đối tượng lặp mới có chứa một mảng hai thành viên là
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
1 cho mỗi phần tử trong đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
3Trả về một đối tượng lặp mới có chứa các phím cho từng phần tử trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
5Trả về một đối tượng lặp mới có chứa các giá trị cho từng phần tử trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
7Trả về một đối tượng lặp mới có chứa một mảng hai thành viên là
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
1 cho mỗi phần tử trong đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
0Trả về một đối tượng lặp mới có chứa các phím cho từng phần tử trong đối tượng
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
5
const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
Trả về một đối tượng lặp mới có chứa các giá trị cho từng phần tử trong đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 theo thứ tự chèn.
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
const myMap = new Map[];
const keyString = 'a string';
const keyObj = {};
const keyFunc = function[] {};
// setting the values
myMap.set[keyString, "value associated with 'a string'"];
myMap.set[keyObj, 'value associated with keyObj'];
myMap.set[keyFunc, 'value associated with keyFunc'];
console.log[myMap.size]; // 3
// getting the values
console.log[myMap.get[keyString]]; // "value associated with 'a string'"
console.log[myMap.get[keyObj]]; // "value associated with keyObj"
console.log[myMap.get[keyFunc]]; // "value associated with keyFunc"
console.log[myMap.get['a string']]; // "value associated with 'a string'", because keyString === 'a string'
console.log[myMap.get[{}]]; // undefined, because keyObj !== {}
console.log[myMap.get[function[] {}]]; // undefined, because keyFunc !== function [] {}
Gọi myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
1 một lần cho mỗi cặp giá trị khóa có trong đối tượng const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5, theo thứ tự chèn. Nếu tham số myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
3 được cung cấp cho myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
4, nó sẽ được sử dụng làm giá trị myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
5 cho mỗi cuộc gọi lại.
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
Ví dụ
const myMap = new Map[];
myMap.set[NaN, 'not a number'];
myMap.get[NaN];
// "not a number"
const otherNaN = Number['foo'];
myMap.get[otherNaN];
// "not a number"
Sử dụng đối tượng bản đồ
Sử dụng NaN làm khóa bản đồ
const myMap = new Map[];
myMap.set[0, 'zero'];
myMap.set[1, 'one'];
for [const [key, value] of myMap] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
for [const key of myMap.keys[]] {
console.log[key];
}
// 0
// 1
for [const value of myMap.values[]] {
console.log[value];
}
// zero
// one
for [const [key, value] of myMap.entries[]] {
console.log[`${key} = ${value}`];
}
// 0 = zero
// 1 = one
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
6 cũng có thể được sử dụng làm chìa khóa. Mặc dù mọi wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
6 không bằng chính nó [wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
8 là đúng], ví dụ sau đây hoạt động vì wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
6 không thể phân biệt được với nhau:
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
Lặp lại bản đồ với ... của
myMap.forEach[[value, key] => {
console.log[`${key} = ${value}`];
}];
// 0 = zero
// 1 = one
Bản đồ có thể được lặp lại bằng cách sử dụng vòng lặp wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
0:
wrongMap.has['bla'] // false
wrongMap.delete['bla'] // false
console.log[wrongMap] // Map { bla: 'blaa', bla2: 'blaaa2' }
const kvArray = [['key1', 'value1'], ['key2', 'value2']];
// Use the regular Map constructor to transform a 2D key-value Array into a map
const myMap = new Map[kvArray];
console.log[myMap.get['key1']]; // "value1"
// Use Array.from[] to transform a map into a 2D key-value Array
console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray
// A succinct way to do the same, using the spread syntax
console.log[[...myMap]];
// Or use the keys[] or values[] iterators, and convert them to an array
console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
Lặp lại bản đồ với foreach []
Bản đồ có thể được lặp lại bằng phương pháp
const kvArray = [['key1', 'value1'], ['key2', 'value2']];
// Use the regular Map constructor to transform a 2D key-value Array into a map
const myMap = new Map[kvArray];
console.log[myMap.get['key1']]; // "value1"
// Use Array.from[] to transform a map into a 2D key-value Array
console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray
// A succinct way to do the same, using the spread syntax
console.log[[...myMap]];
// Or use the keys[] or values[] iterators, and convert them to an array
console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
1:const original = new Map[[
[1, 'one'],
]];
const clone = new Map[original];
console.log[clone.get[1]]; // one
console.log[original === clone]; // false [useful for shallow comparison]
Quan hệ với các đối tượng mảng Keep in mind that the data itself is not cloned.
Bản đồ nhân bản và hợp nhất
const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
0Giống như
const kvArray = [['key1', 'value1'], ['key2', 'value2']];
// Use the regular Map constructor to transform a 2D key-value Array into a map
const myMap = new Map[kvArray];
console.log[myMap.get['key1']]; // "value1"
// Use Array.from[] to transform a map into a 2D key-value Array
console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray
// A succinct way to do the same, using the spread syntax
console.log[[...myMap]];
// Or use the keys[] or values[] iterators, and convert them to an array
console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
2S, const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
5 có thể được nhân bản:const wrongMap = new Map[];
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';
console.log[wrongMap]; // Map { bla: 'blaa', bla2: 'blaaa2' }
1Lưu ý: Hãy nhớ rằng chính dữ liệu không được nhân bản.
Bản đồ cũng có thể được hợp nhất với các mảng: # sec-map-objects |
Thông số kỹ thuật
Sự chỉ rõ
Đặc tả ngôn ngữ Ecmascript # Sec-Map-Enjects
- Tính tương thích của trình duyệt web
6const kvArray = [['key1', 'value1'], ['key2', 'value2']]; // Use the regular Map constructor to transform a 2D key-value Array into a map const myMap = new Map[kvArray]; console.log[myMap.get['key1']]; // "value1" // Use Array.from[] to transform a map into a 2D key-value Array console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray // A succinct way to do the same, using the spread syntax console.log[[...myMap]]; // Or use the keys[] or values[] iterators, and convert them to an array console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
7const kvArray = [['key1', 'value1'], ['key2', 'value2']]; // Use the regular Map constructor to transform a 2D key-value Array into a map const myMap = new Map[kvArray]; console.log[myMap.get['key1']]; // "value1" // Use Array.from[] to transform a map into a 2D key-value Array console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray // A succinct way to do the same, using the spread syntax console.log[[...myMap]]; // Or use the keys[] or values[] iterators, and convert them to an array console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]
8const kvArray = [['key1', 'value1'], ['key2', 'value2']]; // Use the regular Map constructor to transform a 2D key-value Array into a map const myMap = new Map[kvArray]; console.log[myMap.get['key1']]; // "value1" // Use Array.from[] to transform a map into a 2D key-value Array console.log[Array.from[myMap]]; // Will show you exactly the same Array as kvArray // A succinct way to do the same, using the spread syntax console.log[[...myMap]]; // Or use the keys[] or values[] iterators, and convert them to an array console.log[Array.from[myMap.keys[]]]; // ["key1", "key2"]