// 創(chuàng)建一個(gè)空Map
const map = new Map();

// 創(chuàng)建時(shí)初始化
const initializedMap = new Map([
  ['key1', 'value1'],
  ['key2', 'value2']
]);
// 從對(duì)象創(chuàng)建Map
const obj = { a: 1, b: 2 };
const mapFromObject = new Map(Object.entries(obj));

map.set('name', 'Alice');
map.set(1, 'number key');
map.set({}, 'object key');
map.set(null, 'null key'); // 甚至可以使用null或undefined作為鍵

const name = map.get('name'); // 'Alice'
const unknown = map.get('non-existent'); // undefined

const hasName = map.has('name'); // true

 const deleted = map.delete('name'); // 返回布爾值表示是否刪除成功

map.clear();

const size = map.size;

for (const key of map.keys()) {
 console.log(key);
}
// 或者轉(zhuǎn)換為數(shù)組
const keysArray = Array.from(map.keys());

for (const value of map.values()) {
 console.log(value);
}

for (const [key, value] of map.entries()) {
  console.log(key, value);
}
// 可以簡(jiǎn)寫(xiě)為
for (const [key, value] of map) {
  console.log(key, value);
}

map.forEach((value, key) => {
  console.log(key, value);
  // 注意：value在前，key在后，與數(shù)組的forEach不同
});

// 明確指定鍵和值的類(lèi)型
const typedMap = new Map<string, number>();
typedMap.set('age', 25); // 正確
typedMap.set('name', 'Alice'); // 錯(cuò)誤，值應(yīng)該是number類(lèi)型

// 復(fù)雜類(lèi)型示例
interface User {
  id: number;
  name: string;
}

const userMap = new Map<number, User>();
userMap.set(1, { id: 1, name: 'Alice' });

// 從現(xiàn)有類(lèi)型派生Map類(lèi)型
type UserMap = Map<number, User>;

// 創(chuàng)建一個(gè)空Set
const set = new Set();

// 創(chuàng)建時(shí)初始化
const initializedSet = new Set([1, 2, 3, 4]);

// 從類(lèi)數(shù)組對(duì)象創(chuàng)建
const arrayLike = { 0: 'a', 1: 'b', length: 2 };
const setFromArrayLike = new Set(Array.from(arrayLike));

// 字符串會(huì)被拆分為字符
const charSet = new Set('hello'); // Set {'h', 'e', 'l', 'o'}

set.add(1).add(2).add(3);
set.add(NaN).add(NaN); // Set中NaN等于自身，只會(huì)保留一個(gè)

const hasTwo = set.has(2); // true
set.has(NaN); // 可以正確檢測(cè)NaN

set.delete(2);

set.clear();

const size = set.size;

for (const value of set.values()) {
  console.log(value);
}

for (const key of set.keys()) {
  console.log(key);
}

for (const [key, value] of set.entries()) {
  console.log(key, value); // 兩者相同
}

set.forEach((value) => {
  console.log(value);
  // 注意：參數(shù)設(shè)計(jì)為與Map的forEach一致
});

// 明確指定值的類(lèi)型
const typedSet = new Set<number>();
typedSet.add(1); // 正確
typedSet.add('1'); // 錯(cuò)誤，值應(yīng)該是number類(lèi)型

// 復(fù)雜類(lèi)型示例
interface Product {
  id: number;
  name: string;
}

const productSet = new Set<Product>();
productSet.add({ id: 1, name: 'Laptop' });

// 從現(xiàn)有類(lèi)型派生Set類(lèi)型
type ProductSet = Set<Product>;

// 并集
const union = new Set([...setA, ...setB]);

// 交集
const intersection = new Set([...setA].filter(x => setB.has(x)));

// 差集 (A - B)
const difference = new Set([...setA].filter(x => !setB.has(x)));

// 總是明確指定泛型類(lèi)型
const userMap = new Map<number, User>(); 

// 需要不可變Map/Set時(shí)
function addToImmutableSet<T>(set: Set<T>, value: T): Set<T> {
  return new Set([...set, value]);
} 

// Map轉(zhuǎn)數(shù)組
const mapEntries = [...map.entries()];
// Set轉(zhuǎn)數(shù)組
const setValues = [...set];

// 對(duì)于對(duì)象值，需要自定義相等邏輯
const objectSet = new Set<{id: number}>();
const obj1 = {id: 1};
const obj2 = {id: 1};
objectSet.add(obj1);
objectSet.has(obj2); // false，因?yàn)閷?duì)象引用不同