typescript是javaScript的超集，相当于把弱类型的js变成了强类型的语言，并且实现了封装（成员私有），更方便面向对象编程。
然鹅，typescript并没有扩增原生JS的内容，比如：支持了import和export，却不会在编译时（正确的）实现，导致运行时报错；无法使用现代市面上高级语言常用的List、Dictionary等。
其实List倒是没必要，js本身就是动态数组；小型项目不必用到import和export，写在一个文件里不影响使用，大项目可以选择导入库。
重点是Dictionary，字典是非常方便管理的数据结构，通过规范使用把对象当字典等手段不是不可取但终究解决不了问题，这种时候不如自己造个轮子，自己实现一个字典出来。
废话了那么多，来看看代码吧：
1 /**
2 * 字典，键唯一值不唯一的键值对数据
3 * @example new Dictionary<number,Object : type>({ 0:type,1:type,... });
4 * @class Dictionary
5 * @template K 键的类型，只允许numbr和string
6 * @template T 值的类型，任意
7 */
8 class Dictionary<K extends string | number,T> {
9 /**
10 * 字典项目
11 */
12 private items : Record<string | number,T> = {};
13
14 /**
15 * Creates an instance of Dictionary.
16 * @param {(Record<K,T> | undefined | null)} initvalue 可选的初始化，传入符合K:T类型键值对的对象可以给字典赋予初值
17 * @example
18 * @memberOf Dictionary
19 */
20 constructor(initvalue : Record<K,T> | undefined | null = null){
21 if(initvalue) this.items = initvalue;
22 }
23
24 //#region 成员函数
25 /**
26 * 验证指定键是否在字典中
27 * @param key 键
28 * @returns 是否存在
29 */
30 public Contains(key: K | undefined): boolean {
31 if(key == undefined || key == null) { console.warn("尝试在字典",this,"中查找undefined"); return false;}
32 return key in this.items
33 }
34
35 /**
36 * 设置或添加键值，Set与Add作用相同
37 * @param key 键
38 * @param value 值
39 */
40 public Set(key: K, value: T): void {
41 if(!this.Contains(key))
42 this.items[key] = value
43 else
44 console.warn("尝试往字典",this,"里添加重复的键值");
45 }
46 /**
47 * 设置或添加键值，与Set相同
48 * @param key 键
49 * @param value 值
50 */
51 public Add = this.Set;
52
53 /**
54 * 移除指定键
55 * @param key 键
56 * @returns 是否移除成功
57 */
58 public Remove(key: K | undefined): boolean {
59 if (this.Contains(key)) {
60 delete this.items[key as K]
61 return true
62 }
63 console.warn("尝试从字典",this,"移除不存在的键值，或传入undefined")
64 return false
65 }
66
67 /**
68 * 查找特定键的值，没有会返回underfined
69 * @param key 键
70 * @returns 值
71 */
72 public Get(key: K | undefined): T | undefined {
73 return this.Contains(key) ? this.items[key as K] : undefined
74 }
75
76 /**
77 * 通过值查找键
78 * @param {T} value 值
79 * @returns {K} 返回找到的第一个键，若没找到返回-1
80 * @memberOf Dictionary
81 */
82 public Indexof(value : T) : K{
83 for (const key in this.items) {
84 if(this.items[key] == value){
85 return key as K;
86 }
87 }
88 return -1 as K;
89 }
90
91 /**
92 * 获取字典所有的键
93 * @returns 键数组
94 */
95 public Keys(): Array<K> {
96 let values = new Array<K>()//存到数组中返回
97 for (let k in this.items) {
98 if (this.Contains(k as K)) {
99 values.push(k as K)
100 }
101 }
102 return values
103 }
104
105 /**
106 * 获取字典所有的值
107 * @returns 值数组
108 */
109 public Values(): Array<T> {
110 // 存到数组中返回
111 let values = new Array<T>()
112 for (let k in this.items) {
113 if (this.Contains(k as K)) {
114 values.push(this.items[k])
115 }
116 }
117 return values
118 }
119
120 /**
121 * 获取所有键值，注意！返回的对象是副本
122 * @returns 键值对对象
123 */
124 public GetItems(): object {
125 return Object.assign(this.items);
126 }
127
128 /**
129 * 清空字典
130 */
131 public Clear(): void {
132 this.items = {}
133 }
134
135 /**
136 * 获取字典大小
137 * @returns
138 */
139 public Size(): number {
140 return Object.keys(this.items).length
141 }
142 //#endregion
143 }
这是用typescript编写的泛型字典，使用时就像其他高级语言一样 new Dictionary<键类型,值类型>(初始化内容);
考虑到大部分人使用的javascript，这里也提供一份ts编译出的js版本
1 "use strict";
2 /**
3 * 字典，键唯一值不唯一的键值对数据
4 * @example new Dictionary<number,Object : type>({ 0:type,1:type,... });
5 * @class Dictionary
6 * @template K 键的类型，只允许numbr和string
7 * @template T 值的类型，任意
8 */
9 class Dictionary {
10 /**
11 * Creates an instance of Dictionary.
12 * @param {(Record<K,T> | undefined | null)} initvalue 可选的初始化，传入符合K:T类型键值对的对象可以给字典赋予初值
13 * @example
14 * @memberOf Dictionary
15 */
16 constructor(initvalue = null) {
17 /**
18 * 字典项目
19 */
20 this.items = {};
21 /**
22 * 设置或添加键值，与Set相同
23 * @param key 键
24 * @param value 值
25 */
26 this.Add = this.Set;
27 if (initvalue)
28 this.items = initvalue;
29 }
30 //#region 成员函数
31 /**
32 * 验证指定键是否在字典中
33 * @param key 键
34 * @returns 是否存在
35 */
36 Contains(key) {
37 if (key == undefined || key == null) {
38 console.warn("尝试在字典", this, "中查找undefined");
39 return false;
40 }
41 return key in this.items;
42 }
43 /**
44 * 设置或添加键值，Set与Add作用相同
45 * @param key 键
46 * @param value 值
47 */
48 Set(key, value) {
49 if (!this.Contains(key))
50 this.items[key] = value;
51 else
52 console.warn("尝试往字典", this, "里添加重复的键值");
53 }
54 /**
55 * 移除指定键
56 * @param key 键
57 * @returns 是否移除成功
58 */
59 Remove(key) {
60 if (this.Contains(key)) {
61 delete this.items[key];
62 return true;
63 }
64 console.warn("尝试从字典", this, "移除不存在的键值，或传入undefined");
65 return false;
66 }
67 /**
68 * 查找特定键的值，没有会返回underfined
69 * @param key 键
70 * @returns 值
71 */
72 Get(key) {
73 return this.Contains(key) ? this.items[key] : undefined;
74 }
75 /**
76 * 通过值查找键
77 * @param {T} value 值
78 * @returns {K} 返回找到的第一个键，若没找到返回-1
79 * @memberOf Dictionary
80 */
81 Indexof(value) {
82 for (const key in this.items) {
83 if (this.items[key] == value) {
84 return key;
85 }
86 }
87 return -1;
88 }
89 /**
90 * 获取字典所有的键
91 * @returns 键数组
92 */
93 Keys() {
94 let values = new Array(); //存到数组中返回
95 for (let k in this.items) {
96 if (this.Contains(k)) {
97 values.push(k);
98 }
99 }
100 return values;
101 }
102 /**
103 * 获取字典所有的值
104 * @returns 值数组
105 */
106 Values() {
107 // 存到数组中返回
108 let values = new Array();
109 for (let k in this.items) {
110 if (this.Contains(k)) {
111 values.push(this.items[k]);
112 }
113 }
114 return values;
115 }
116 /**
117 * 获取所有键值，注意！返回的对象是副本
118 * @returns 键值对对象
119 */
120 GetItems() {
121 return Object.assign(this.items);
122 }
123 /**
124 * 清空字典
125 */
126 Clear() {
127 this.items = {};
128 }
129 /**
130 * 获取字典大小
131 * @returns
132 */
133 Size() {
134 return Object.keys(this.items).length;
135 }
136 }
Dictionary(js ver)
就是这样，大家也可以参考我的代码，节省自己造轮子的功夫。
（该字典有参考https://www.cnblogs.com/jardeng/p/14849558.html）
标签：TypeScript,return,items,Javascript,param,键值,key,泛型,字典 From： https://www.cnblogs.com/commend-sheep/p/16927919.html