类 Map

从字符串到值的不可变映射

class Map does Associative does Iterable { }

Map 是从字符串键到任意类型值的不可变映射。它充当 Hash 的基类，后者是可变的。

在列表上下文中，Map 表现为 Pair 对象的列表。

请注意，检索键、值和对的顺序通常是任意的，但 keys、values 和 pairs 方法在对同一对象调用时始终以相同的顺序返回它们。

my %e := Map.new('a', 1, 'b', 2);
say %e.keys;    # can print «a b␤» or «b a␤» 
say %e.values;  # prints «1 2␤» if the previous line 
                # printed «a b␤», «2 1␤» otherwise

要通过键从 Map 中检索值，请使用 { } 后缀运算符

my %map is Map = 'a', 1, 'b', 2;
say %map{'a'};      # OUTPUT: «1␤» 
say %map{ 'a', 'b' }; # OUTPUT: «(1 2)␤»

要检查给定的键是否存储在 Map 中，请使用 :exists 副词修改访问

my $map = Map.new('a', 1, 'b', 2);
my $key = 'a';
if $map{$key}:exists {
    say "$map{} has key $key";
}

作为不可变实例，在初始化 Map 后无法添加键

my $m = Map.new( 'a', 1, 'b', 2 );
$m{ 'c' } = 'foo'; # WRONG! 
                   # Cannot modify an immutable Str

与可变伴随类型 Hash 不同，Map 无法按键或值类型进行参数化。

方法§

方法 new§

method new(*@args)

从交替键和值的列表创建新的 Map，其 语义与 哈希和映射 文档中描述的相同，但还接受 Pair 而不是单独的键和值。使用 分组运算符 或引用键以确保不会将文字对解释为命名参数。

my %h = Map.new('a', 1, 'b', 2);
 
# WRONG: :b(2) interpreted as named argument 
say Map.new('a', 1, :b(2)).keys; # OUTPUT: «(a)␤» 
 
# RIGHT: :b(2) interpreted as Pair because of extra parentheses 
say Map.new( ('a', 1, :b(2)) ).keys.sort; # OUTPUT: «(a b)␤» 
 
# RIGHT: 'b' => 2 always creates a Pair 
say Map.new('a', 1, 'b' => 2).keys.sort; # OUTPUT: «(a b)␤»

提供了创建 Map 的简写语法

my %h is Map = 'a', 1, 'b', 2;

方法 elems§

method elems(Map:D: --> Int:D)

返回存储在 Map 中的对的数量。

my %map = Map.new('a', 1, 'b', 2);
say %map.elems; # OUTPUT: «2␤»

方法 ACCEPTS§

multi method ACCEPTS(Map:D: Positional $topic)
multi method ACCEPTS(Map:D: Cool:D     $topic)
multi method ACCEPTS(Map:D: Regex      $topic)
multi method ACCEPTS(Map:D: Any        $topic)

如果右侧是 Map，则在智能匹配中使用。

如果主题类似列表（Positional），则当列表中的任何元素作为 Map 中的键存在时返回 True。

如果主题的类型为 Cool（字符串、整数等），则当主题作为键存在时返回 True。

如果主题是正则表达式，则当任何键与正则表达式匹配时返回 True。

作为后备，主题将强制转换为列表，并应用 Positional 行为。

方法 gist§

method gist(Map:D: --> Str:D)

返回包含 Map 的“要点”的字符串，对对进行排序并列出最多 100 个，如果 Map 有 100 多个对，则追加省略号。

方法 keys§

method keys(Map:D: --> Seq:D)

返回 Map 中所有键的 Seq。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.keys; # OUTPUT: «(a b)␤»

方法 values§

method values(Map:D: --> Seq:D)

返回 Seq，其中包含 Map 中的所有值。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.values; # OUTPUT: «((2 3) 17)␤»

方法 pairs§

method pairs(Map:D: --> Seq:D)

返回 Seq，其中包含 Map 中的所有对。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.pairs; # OUTPUT: «(a => (2 3) b => 17)␤»

方法 antipairs§

method antipairs(Map:D: --> Seq:D)

将所有键及其各自的值作为 Seq 返回，其中包含 Pair，键和值已交换，即方法 pairs 的相反操作。与 invert 方法不同，不会尝试将列表值展开为多个对。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.antipairs;                        # OUTPUT: «((2 3) => a 17 => b)␤»

方法 invert§

method invert(Map:D: --> Seq:D)

将所有键及其各自的值作为 Seq 返回，其中包含 Pair，键和值已交换。invert 和 antipairs 之间的区别在于，invert 将列表值展开为多个对。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.invert;                          # OUTPUT: «(2 => a 3 => a 17 => b)␤»

方法 kv§

method kv(Map:D: --> Seq:D)

返回交错的键和值 Seq。

Map.new('a', 1, 'b', 2).kv  # (a 1 b 2)

方法 list§

multi method list(Map:D: --> List:D)

返回 List，其中包含 Map 中所有键和值的 Pair 对象。

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.list;                            # OUTPUT: «(b => 17 a => (2 3))␤»

方法 sort§

multi method sort(Map:D: --> Seq:D)

返回 Seq，其中包含 Pair 对象，这些对象是哈希的对，按键排序。等同于 %hash.sort: *.key

# These are equivalent: 
say Map.new(<c 3 a 1 b 2>).sort;        # OUTPUT: «(a => 1 b => 2 c => 3)␤» 
say Map.new(<c 3 a 1 b 2>).sort: *.key; # OUTPUT: «(a => 1 b => 2 c => 3)␤»

有关其他可用候选，请参见 Any.sort。

方法 Int§

method Int(Map:D: --> Int:D)

返回存储在 Map 中的对数（与 .elems 相同）。

my $m = Map.new('a' => 2, 'b' => 17);
say $m.Int;                                       # OUTPUT: «2␤»

方法 Numeric§

method Numeric(Map:D: --> Int:D)

返回存储在 Map 中的对数（与 .elems 相同）。

my $m = Map.new('a' => 2, 'b' => 17);
say $m.Numeric;                                   # OUTPUT: «2␤»

方法 Bool§

method Bool(Map:D: --> Bool:D)

如果调用者至少包含一个键/值对，则返回 True。

my $m = Map.new('a' => 2, 'b' => 17);
say $m.Bool;                                      # OUTPUT: «True␤»

方法 Capture§

method Capture(Map:D:)

返回 Capture，其中每个键（如果有）已转换为命名参数，其值与在原始 Map 中的值相同。返回的 Capture 不会包含任何位置参数。

my $map = Map.new('a' => 2, 'b' => 17);
my $capture = $map.Capture;
my-sub(|$capture);                                # OUTPUT: «2, 17␤» 
 
sub my-sub(:$a, :$b) {
    say "$a, $b"
}

类型图§

Map 的类型关系
raku-type-graph Map Map Cool Cool Map->Cool Iterable Iterable Map->Iterable Associative Associative Map->Associative Mu Mu Any Any Any->Mu Cool->Any PseudoStash PseudoStash PseudoStash->Map Hash Hash Hash->Map Stash Stash Stash->Hash

展开上方图表