关联数组（Associative Arrays）

优质

小牛编辑

138浏览

2023-12-01

关联数组的索引不一定是整数，并且可以稀疏填充。关联数组的索引称为Key ，其类型称为KeyType 。

通过将KeyType放在数组声明的[]内来声明关联数组。关联数组的一个简单示例如下所示。

import std.stdio;
void main () { 
   int[string] e;      // associative array b of ints that are  
   e["test"] = 3; 
   writeln(e["test"]); 
   string[string] f; 
   f["test"] = "Tuts"; 
   writeln(f["test"]); 
   writeln(f);  
   f.remove("test"); 
   writeln(f); 
}

编译并执行上述代码时，会产生以下结果 -

3 
Tuts 
["test":"Tuts"] 
[]

初始化关联数组

关联数组的简单初始化如下所示。

import std.stdio;
void main () { 
   int[string] days = 
      [ "Monday" : 0, 
         "Tuesday" : 1, 
         "Wednesday" : 2, 
         "Thursday" : 3, 
         "Friday" : 4, 
         "Saturday" : 5, 
         "Sunday" : 6 ]; 
   writeln(days["Tuesday"]);    
}

编译并执行上述代码时，会产生以下结果 -

关联数组的属性

以下是关联数组的属性 -

Sr.No.	财产和描述
1	.sizeof 返回关联数组的引用大小; 它在32位构建中为4，在64位构建中为8。
2	.length 返回关联数组中的值的数量。与动态数组不同，它是只读的。
3	.dup 创建一个大小相同的新关联数组，并将关联数组的内容复制到其中。
4	.keys 返回动态数组，其元素是关联数组中的键。
5	.values 返回动态数组，其元素是关联数组中的值。
6	.rehash 在适当的位置重新组织关联数组，以便查找更有效。例如，当程序完成加载符号表并且现在需要快速查找时，rehash是有效的。返回对重组数组的引用。
7	.byKey() 返回一个适合用作ForeachStatement的Aggregate的委托，它将迭代关联数组的键。
8	.byValue() 返回一个适合用作ForeachStatement的Aggregate的委托，它将迭代关联数组的值。
9	.get(Key key, lazy Value defVal) 查找键; 如果它存在则返回相应的值，否则计算并返回defVal。
10	.remove(Key key) 删除密钥对象。

例子 (Example)

使用上述属性的示例如下所示。

import std.stdio;
void main () { 
   int[string] array1;
   array1["test"] = 3; 
   array1["test2"] = 20; 
   writeln("sizeof: ",array1.sizeof); 
   writeln("length: ",array1.length); 
   writeln("dup: ",array1.dup);  
   array1.rehash; 
   writeln("rehashed: ",array1);  
   writeln("keys: ",array1.keys); 
   writeln("values: ",array1.values);
   foreach (key; array1.byKey) { 
      writeln("by key: ",key); 
   }
   foreach (value; array1.byValue) { 
      writeln("by value ",value); 
   }
   writeln("get value for key test: ",array1.get("test",10)); 
   writeln("get value for key test3: ",array1.get("test3",10));  
   array1.remove("test"); 
   writeln(array1); 
}

编译并执行上述代码时，会产生以下结果 -

sizeof: 8                                                                          
length: 2                                                                          
dup: ["test":3, "test2":20]                                                        
rehashed: ["test":3, "test2":20]                                                   
keys: ["test", "test2"]                                                            
values: [3, 20]                                                                    
by key: test                                                                       
by key: test2                                                                      
by value 3                                                                         
by value 20                                                                        
get value for key test: 3                                                          
get value for key test3: 10                                                        
["test2":20]