class Str

字符字符串

class Str is Cool does Stringy { }

字符串的内置类。Str 类型的对象是 不可变的。

方法§

routine chop§

multi method chop(Str:D:)
multi method chop(Str:D: Int() $chopping)

返回从末尾移除 $chopping 个字符的字符串。

say "Whateverable".chop(3.6);  # OUTPUT: «Whatevera␤» 
my $string= "Whateverable";
say $string.chop("3");         # OUTPUT: «Whatevera␤»

在应用于字符串之前，$chopping 位置参数将转换为 Int。

routine chomp§

multi        chomp(Str:D  --> Str:D)
multi method chomp(Str:D: --> Str:D)

返回从末尾移除一个逻辑换行符（具有 NEWLINE 属性的任何代码点）的字符串。

示例

say chomp("abc\n");       # OUTPUT: «abc␤» 
say "def\r\n".chomp;      # OUTPUT: «def␤» NOTE: \r\n is a single grapheme! 
say "foo\r".chomp;        # OUTPUT: «foo␤»

method contains§

multi method contains(Str:D: Cool:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Regex:D $needle --> Bool:D)
multi method contains(Str:D: Cool:D $needle, Int(Cool:D) $pos, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Str:D $needle, Int:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Regex:D $needle, Int:D $pos --> Bool:D)
multi method contains(Str:D: Regex:D $needle, Cool:D $pos --> Bool:D)

给定 Str 调用者（称为干草堆）和第一个参数（称为 $needle），它从字符串开头在干草堆中搜索 $needle，如果找到 $needle，则返回 True。如果提供了可选参数 $pos，则 contains 将从字符串中 $pos 个字符开始搜索干草堆。

say "Hello, World".contains('Hello');      # OUTPUT: «True␤» 
say "Hello, World".contains('hello');      # OUTPUT: «False␤» 
say "Hello, World".contains('Hello', 1);   # OUTPUT: «False␤» 
say "Hello, World".contains(',');          # OUTPUT: «True␤» 
say "Hello, World".contains(',', 3);       # OUTPUT: «True␤» 
say "Hello, World".contains(',', 10);      # OUTPUT: «False␤»

在第一种情况下，contains 从调用者字符串的开头就在调用者上搜索 'Hello' 字符串，并返回 True。在第三种情况下，没有找到 'Hello' 字符串，因为我们已经从 'Hello, World' 中的第二个位置（索引 1）开始查找。

自 Rakudo 2020.02 版本起，$needle 还可以是一个 Regex，在这种情况下，contains 方法将快速返回正则表达式是否至少匹配字符串一次。不会创建 Match 对象，因此速度较快。

say 'Hello, World'.contains(/\w <?before ','>/);    # OUTPUT: «True␤» 
say 'Hello, World'.contains(/\w <?before ','>/, 5); # OUTPUT: «False␤»

自 Rakudo 2020.02 版本起，如果指定可选命名参数 :ignorecase 或 :i，则在搜索 $needle 时将忽略大小写字母之间的区别。

say "Hello, World".contains("world");              # OUTPUT: «False␤» 
say "Hello, World".contains("world", :ignorecase); # OUTPUT: «True␤»

自 Rakudo 2020.02 版本起，如果指定可选命名参数 :ignoremark 或 :m，则在搜索 $needle 时只考虑基本字符，而忽略附加标记，例如组合重音。

say "abc".contains("ä");               # OUTPUT: «False␤» 
say "abc".contains("ä", :ignoremark);  # OUTPUT: «True␤»

请注意，由于 List 或 Array 是如何 强制转换 为 Str 的，因此结果有时可能会令人惊讶。

say <Hello, World>.contains('Hello');    # OUTPUT: «True␤» 
say <Hello, World>.contains('Hello', 0); # OUTPUT: «True␤» 
say <Hello, World>.contains('Hello', 1); # OUTPUT: «False␤»

参见 陷阱。

例程 lc§

multi        lc(Str:D  --> Str:D)
multi method lc(Str:D: --> Str:D)

返回字符串的小写版本。

示例

lc("A"); # OUTPUT: «"a"» 
"A".lc;  # OUTPUT: «"a"»

例程 uc§

multi        uc(Str:D  --> Str:D)
multi method uc(Str:D: --> Str:D)

返回字符串的大写版本。

例程 fc§

multi        fc(Str:D  --> Str:D)
multi method fc(Str:D: --> Str:D)

执行适用于不区分大小写字符串比较的 Unicode “折叠大小写”操作。（通常情况下，返回的字符串不太可能用于比较以外的任何目的。）

例程 tc§

multi        tc(Str:D  --> Str:D)
multi method tc(Str:D: --> Str:D)

执行 Unicode “标题大小写”操作，即更改字符串中的第一个字符为标题大小写，或者如果字符没有标题大小写映射，则更改为大写

例程 tclc§

multi        tclc(Str:D  --> Str:D)
multi method tclc(Str:D: --> Str:D)

将第一个字符转换为标题大小写，并将所有其他字符转换为小写

例程 wordcase§

multi        wordcase(Cool $x  --> Str)
multi        wordcase(Str:D $x --> Str)
multi method wordcase(Str:D: :&filter = &tclc, Mu :$where = True --> Str)

返回一个字符串，其中 &filter 已应用于与 $where 匹配的所有单词。默认情况下，这意味着每个单词的第一个字母都大写，所有其他字母都小写。

方法 unival§

multi method unival(Str:D: --> Numeric)

返回调用者中第一个代码点表示的数字值，如果它不是数字，则返回 NaN。

say '4'.unival;     # OUTPUT: «4␤» 
say '¾'.unival;     # OUTPUT: «0.75␤» 
say 'a'.unival;     # OUTPUT: «NaN␤»

方法 univals§

multi method univals(Str:D: --> List)

返回调用者字符串中每个代码点表示的数字值列表，对于非数字字符，返回 NaN。

say "4a¾".univals;  # OUTPUT: «(4 NaN 0.75)␤»

例程 chars§

multi        chars(Cool  $x --> Int:D)
multi        chars(Str:D $x --> Int:D)
multi        chars(str   $x --> int)
multi method chars(Str:D:   --> Int:D)

返回字符串中以音素为单位的字符数。在 JVM 上，它当前错误地返回代码点数。

方法 encode§

multi method encode(Str:D $encoding = 'utf8', :$replacement, Bool() :$translate-nl = False, :$strict)

返回一个 Blob，表示给定编码和标准形式中的原始字符串。实际返回类型尽可能具体，因此 $str.encode('UTF-8') 返回一个 utf8 对象，$str.encode('ISO-8859-1') 返回一个 buf8。如果 :translate-nl 设置为 True，它会将换行符从 \n 转换为 \r\n，但仅在 Windows 中。$replacement 指示在当前编码中不可用时如何替换字符，而 $strict 指示未映射的代码点是否仍会解码；例如，在 windows-1252 中不存在的代码点 129。

my $str = "Þor is mighty";
say $str.encode("ascii", :replacement( 'Th') ).decode("ascii");
# OUTPUT: «Thor is mighty␤»

在这种情况下，任何未知字符都将被 Th 替换。我们预先知道 ascii 编码中未知的字符是 Þ，所以我们用它的拉丁语等价物 Th 替换它。在没有设置任何替换字符集的情况下，:replacement 被理解为一个 Bool

say $str.encode("ascii", :replacement).decode("ascii"); # OUTPUT: «?or is mighty␤» 

如果 :replacement 未设置或未分配值，则会发出错误 Error encoding ASCII string: could not encode codepoint 222（在这种情况下，因为 þ 是代码点 222）。

由于 encode 返回的 Blob 是标准形式的原始字符串，并且 Blob 的每个元素都是一个字节，因此你可以通过调用返回 Blob 大小的方法来获取字符串的字节长度

say "þor".encode.bytes; # OUTPUT: «4␤» 
say "þor".encode.elems; # OUTPUT: «4␤» 

方法索引§

multi method index(Str:D: Cool:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Cool:D $needle, Cool:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: Str:D $needle, Int:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Int:D)
multi method index(Str:D: @needles --> Int:D)
multi method index(Str:D: @needles, :m(:$ignoremark)! --> Int:D)
multi method index(Str:D: @needles, :i(:$ignorecase)!, :m(:$ignoremark) --> Int:D)

从 $pos（如果存在）开始在字符串中搜索 $needle。它返回在字符串中找到 $needle 的偏移量，如果未找到，则返回 Nil。

自 Rakudo 2020.02 版本以来，如果指定了可选命名参数 :ignorecase 或 :i，则搜索 $needle 时会忽略大小写字母之间的区别。此外，如果指定了可选命名参数 :ignoremark 或 :m，则搜索 $needle 时只考虑基本字符，而忽略组合重音等附加标记。

自 Rakudo 2020.05 版本以来，index 接受一个列表，用该列表中的内容搜索字符串，并返回找到的最低索引或 Nil。

示例

say "Camelia is a butterfly".index("a");         # OUTPUT: «1␤» 
say "Camelia is a butterfly".index("a", 2);      # OUTPUT: «6␤» 
say "Camelia is a butterfly".index("er");        # OUTPUT: «17␤» 
say "Camelia is a butterfly".index("Camel");     # OUTPUT: «0␤» 
say "Camelia is a butterfly".index("Onion");     # OUTPUT: «Nil␤» 
say "Camelia is a butterfly".index(<a e i u>);   # OUTPUT: «1␤» 
say "Camelia is a butterfly".index(<a c>, :i);   # OUTPUT: «0␤» 
say "Camelia is a butterfly".index(('w', 'x'));  # OUTPUT: «Nil␤» 
 
say "Hello, World".index("world");               # OUTPUT: «Nil␤» 
say "Hello, World".index("world", :ignorecase);  # OUTPUT: «7␤» 
 
say "abc".index("ä");                            # OUTPUT: «Nil␤» 
say "abc".index("ä", :ignoremark);               # OUTPUT: «0␤» 
say "abc".index("x").defined ?? 'OK' !! 'NOT';   # OUTPUT: «NOT␤»

其他形式的 index，包括子例程，继承自 Cool。

例程 rindex§

multi method rindex(Str:D: Str:D $needle --> Int:D)
multi method rindex(Str:D: Str:D $needle, Int:D $pos --> Int:D)
multi method rindex(Str:D: @needles --> Int:D)

返回字符串中 $needle 的最后一个位置，该位置不在 $pos 之后。如果未找到 $needle，则返回 Nil。

自 Rakudo 2020.05 版本以来，rindex 接受一个列表，用该列表中的内容搜索字符串，并返回找到的最高索引或 Nil。

示例

say "aardvark".rindex: "a";       # OUTPUT: «5␤» 
say "aardvark".rindex: "a", 0;    # OUTPUT: «0␤ 
say "aardvark".rindex: "t";       # OUTPUT: «Nil␤» 
say "aardvark".rindex: <d v k>;   # OUTPUT: «7␤»

其他形式的 rindex，包括子例程，继承自 Cool。

方法 indices§

multi method indices(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark), :$overlap --> List:D)
multi method indices(Str:D: Str:D $needle, Int:D $start, :i(:$ignorecase), :m(:$ignoremark), :$overlap --> List:D)

从位置 $start 开始在字符串中搜索 $needle 的所有出现（如果未指定，则从零开始），并返回一个 List，其中包含在字符串中找到 $needle 的所有偏移量，如果未找到，则返回一个空列表。

如果指定了可选参数 :overlap，则搜索将从紧跟前一个匹配项的索引继续，否则搜索将在前一个匹配项之后继续。

say "banana".indices("a");              # OUTPUT: «(1 3 5)␤» 
say "banana".indices("ana");            # OUTPUT: «(1)␤» 
say "banana".indices("ana", :overlap);  # OUTPUT: «(1 3)␤» 
say "banana".indices("ana", 2);         # OUTPUT: «(3)␤»

自 Rakudo 2020.02 版本起，如果指定可选命名参数 :ignorecase 或 :i，则在搜索 $needle 时将忽略大小写字母之间的区别。

say "banAna".indices("a");              # OUTPUT:«(1 5)␤» 
say "banAna".indices("a", :ignorecase); # OUTPUT:«(1 3 5)␤»

自 Rakudo 2020.02 起，如果指定可选命名参数 :ignoremark 或 :m，则对 $needle 的搜索仅考虑基本字符，而忽略附加标记（例如组合重音符号）。

say "tête-à-tête".indices("te");              # OUTPUT:«(2 9)␤» 
say "tête-à-tête".indices("te", :ignoremark); # OUTPUT:«(0 2 7 9)␤»

方法 match§

method match($pat, :continue(:$c), :pos(:$p), :global(:$g), :overlap(:$ov), :exhaustive(:$ex), :st(:$nd), :rd(:$th), :$nth, :$x --> Match)

根据 $pat 对字符串执行匹配，如果匹配成功，则返回一个 Match 对象；否则返回 (Any)。匹配存储在 默认匹配变量 $/ 中。如果 $pat 不是一个 Regex 对象，match 将强制将参数转换为 Str，然后根据 $pat 执行一个文本匹配。

可以指定多个可选命名参数，这些参数会改变匹配的执行方式。

  • :continue

:continue 副词将正则表达式应开始搜索的位置作为参数。如果未为 :c 指定位置，则它将默认为 0，除非设置了 $/，在这种情况下，它将默认为 $/.to。

  • :pos

将位置作为参数。如果无法从该位置匹配正则表达式，则失败，这与 :continue 不同。

  • :global

不只搜索一个匹配项并返回 Match 对象，而是搜索每个不重叠的匹配项，并将其返回到 List 中。

  • :overlap

查找所有匹配项，包括重叠匹配项，但仅从每个起始位置返回一个匹配项。

  • :exhaustive

查找正则表达式的所有可能匹配项，包括重叠匹配项和从同一位置开始的匹配项。

  • :st, :nd, :rd, :nth

返回字符串中的第 n 个匹配项。参数可以是 Numeric 或 Iterable，生成单调递增的数字（即，下一个生成的数字必须大于前一个）。Iterable 将被延迟 具体化，如果遇到非单调序列，则会引发异常。

如果提供了 Iterable 参数，则返回值和 $/ 变量将被设置为 List 中可能为空的 Match 对象。

  • :x

将要返回的匹配项数量作为参数，一旦达到指定的匹配项数量，则停止。该值必须是 Numeric 或 Range；其他值将导致 .match 返回一个 Failure，其中包含 X::Str::Match::x 异常。

示例

say "properly".match('perl');                     # OUTPUT: «｢perl｣␤» 
say "properly".match(/p.../);                     # OUTPUT: «｢prop｣␤» 
say "1 2 3".match([1,2,3]);                       # OUTPUT: «｢1 2 3｣␤» 
say "a1xa2".match(/a./, :continue(2));            # OUTPUT: «｢a2｣␤» 
say "abracadabra".match(/ a .* a /, :exhaustive);
# OUTPUT: «(｢abracadabra｣ ｢abracada｣ ｢abraca｣ ｢abra｣ ｢acadabra｣ ｢acada｣ ｢aca｣ ｢adabra｣ ｢ada｣ ｢abra｣)␤» 
say 'several words here'.match(/\w+/,:global);    # OUTPUT: «(｢several｣ ｢words｣ ｢here｣)␤» 
say 'abcdef'.match(/.*/, :pos(2));                # OUTPUT: «｢cdef｣␤» 
say "foo[bar][baz]".match(/../, :1st);            # OUTPUT: «｢fo｣␤» 
say "foo[bar][baz]".match(/../, :2nd);            # OUTPUT: «｢o[｣␤» 
say "foo[bar][baz]".match(/../, :3rd);            # OUTPUT: «｢ba｣␤» 
say "foo[bar][baz]".match(/../, :4th);            # OUTPUT: «｢r]｣␤» 
say "foo[bar][baz]bada".match('ba', :x(2));       # OUTPUT: «(｢ba｣ ｢ba｣)␤» 

方法 Numeric§

method Numeric(Str:D: --> Numeric:D)

使用等效于 val 例程的语义将字符串强制转换为 Numeric。如果无法强制转换为数字，则使用 X::Str::Numeric 失败。

仅允许属性为 Nd 的 Unicode 字符以及前导和尾随空格，特殊情况是空字符串强制转换为 0。禁止使用合成代码点（例如 "7\x[308]"）。

虽然 Nl 和 No 字符可以在语言中用作数字文本，但它们通过 Str.Numeric 进行转换会失败，这是设计使然；合成数字（由数字和变音符号组成）也会发生这种情况。如果你需要将此类字符强制转换为 Numeric，请参见 unival。+、- 和 Unicode 减号 − 都允许使用。

" −33".Numeric;       # OUTPUT: «-33␤» 

方法 Num§

method Num(Str:D: --> Num:D)

将字符串强制转换为 Num，使用与 Str.Numeric 相同的规则，并处理负零、-0e0 和正零、0e0。

my Str $s = "-0/5";
say (.self, .^name) given $s.Numeric;  # OUTPUT: «(0 Rat)␤» 
say (.self, .^name) given $s.Num;      # OUTPUT: «(-0 Num)␤» 

方法 Int§

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

使用与 Str.Numeric 相同的规则将字符串强制转换为 Int。

方法 Rat§

method Rat(Str:D: --> Rational:D)

使用与 Str.Numeric 相同的规则将字符串强制转换为 Rat 对象。如果分母大于 64 位，则仍保留分母，并且不会降级为 Num。

方法 Bool§

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

如果字符串为空，则返回 False，否则返回 True。

例程 parse-base§

multi        parse-base(Str:D $num, Int:D $radix --> Numeric)
multi method parse-base(Str:D $num: Int:D $radix --> Numeric)

通过将带有基数 $radix 的数字字符串转换为其 Numeric 等效项，执行 base 的逆操作。如果基数不在 2..36 范围内，或者要解析的字符串包含对指定基数无效的字符，则会 fail。

1337.base(32).parse-base(32).say; # OUTPUT: «1337␤» 
'Raku'.parse-base(36).say;        # OUTPUT: «1273422␤» 
'FF.DD'.parse-base(16).say;       # OUTPUT: «255.863281␤»

另请参阅：数字文字语法

例程 parse-names§

sub    parse-names(Str:D $names  --> Str:D)
method parse-names(Str:D $names: --> Str:D)

已弃用。改用 uniparse。在 Rakudo 实现中作为可行性实现证明而存在，然后重命名，并在发布 6.e 语言时删除。

例程 uniparse§

sub    uniparse(Str:D $names  --> Str:D)
method uniparse(Str:D $names: --> Str:D)

获取带有字符的 Unicode 名称的逗号分隔字符串，并返回由这些字符组成的字符串。如果任何字符的名称为空或无法识别，则会 fail。忽略字符名称周围的空格。

say "I {uniparse 'TWO HEARTS'} Raku"; # OUTPUT: «I 💕 Raku␤» 
'TWO HEARTS, BUTTERFLY'.uniparse.say; # OUTPUT: «💕🦋␤»

请参阅 uniname 和 uninames，了解分别使用单个代码点和多个代码点在相反方向工作的例程。

请注意，与字符串插值中可用的 \c[...] 构造不同，uniparse 不接受十进制数值。使用 chr 例程转换这些数值

say "\c[1337]"; # OUTPUT: «Թ␤» 
say '1337'.chr; # OUTPUT: «Թ␤»

注意：在 2017.12 标准化之前，此例程以其工作名称 parse-names 而闻名。此名称将在 6.e 版本中删除。

方法 samecase§

multi method samecase(Str:D: Str:D $pattern --> Str:D)

返回调用者的副本，其中每个字符的大小写信息根据 $pattern 更改。

注意：模式字符串可以包含三种类型的字符，即大写、小写和小写。对于 $pattern 中的给定字符，其大小写信息决定了结果中相应字符的大小写。

如果调用者比 $pattern 长，则 $pattern 中最后一个字符的大小写信息将应用于调用者的其余字符。

say "raKu".samecase("A_a_"); # OUTPUT: «Raku␤» 
say "rAKU".samecase("Ab");   # OUTPUT: «Raku␤»

例程 split§

multi        split(  Str:D $delimiter, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)
multi        split(Regex:D $delimiter, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)
multi        split(List:D $delimiters, Str:D $input, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)
multi method split(Str:D:   Str:D $delimiter, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)
multi method split(Str:D: Regex:D $delimiter, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)
multi method split(Str:D: List:D $delimiters, $limit = Inf,
  :$skip-empty, :$v, :$k, :$kv, :$p)

根据字符串中找到的分隔符将字符串分成几部分。

如果 DELIMITER 是一个字符串，它将被逐字搜索，而不是被视为正则表达式。如果 DELIMITER 是空字符串，它将有效地将字符串的所有字符分别返回（加上开头和结尾的空字符串）。如果 PATTERN 是一个正则表达式，那么它将被用来分割字符串。如果 DELIMITERS 是一个列表，那么它的所有元素都将被视为分隔符（字符串或正则表达式）来分割字符串。

可选的 LIMIT 指示字符串应尽可能地分成多少段。它默认为 Inf（或 *，无论你如何看待它），这意味着“尽可能多”。请注意，指定负限制不会产生任何有意义的结果。

可以指定许多可选的命名参数，它们会改变返回的结果。:v、:k、:kv 和 :p 命名参数都对找到的分隔符执行特殊操作。

  • :skip-empty

如果指定，则不要在分隔符之前或之后返回空字符串。

  • :v

还返回分隔符。如果分隔符是一个正则表达式，那么这将是相关的 Match 对象。由于这会字符串化为找到的分隔符字符串，因此如果你对该特定匹配的更多信息不感兴趣，你可以始终假设它是分隔符字符串。

  • :k

还返回分隔符的索引。只有在指定了分隔符列表时才有意义：在所有其他情况下，这将是 0。

  • :kv

还返回分隔符的索引和分隔符。

  • :p

还返回分隔符的索引和分隔符作为 Pair。

示例

say split(";", "a;b;c").raku;           # OUTPUT: «("a", "b", "c").Seq␤» 
say split(";", "a;b;c", :v).raku;       # OUTPUT: «("a", ";", "b", ";", "c").Seq␤» 
say split(";", "a;b;c", 2).raku;        # OUTPUT: «("a", "b;c").Seq␤» 
say split(";", "a;b;c", 2, :v).raku;    # OUTPUT: «("a", ";", "b;c").Seq␤» 
say split(";", "a;b;c,d").raku;         # OUTPUT: «("a", "b", "c,d").Seq␤» 
say split(/\;/, "a;b;c,d").raku;        # OUTPUT: «("a", "b", "c,d").Seq␤» 
say split(<; ,>, "a;b;c,d").raku;       # OUTPUT: «("a", "b", "c", "d").Seq␤» 
say split(/<[;,]>/, "a;b;c,d").raku;    # OUTPUT: «("a", "b", "c", "d").Seq␤» 
say split(<; ,>, "a;b;c,d", :k).raku;   # OUTPUT: «("a", 0, "b", 0, "c", 1, "d").Seq␤» 
say split(<; ,>, "a;b;c,d", :kv).raku;  # OUTPUT: «("a", 0, ";", "b", 0, ";", "c", 1, ",", "d").Seq␤» 
 
say "".split("x").raku;                 # OUTPUT: «("",).Seq␤» 
say "".split("x", :skip-empty).raku;    # OUTPUT: «().Seq␤» 
 
say "abcde".split("").raku;             # OUTPUT: «("", "a", "b", "c", "d", "e", "").Seq␤» 
say "abcde".split("",:skip-empty).raku; # OUTPUT: «("a", "b", "c", "d", "e").Seq␤»

例程 comb§

multi        comb(Str:D   $matcher, Str:D $input, $limit = Inf)
multi        comb(Regex:D $matcher, Str:D $input, $limit = Inf, Bool :$match)
multi        comb(Int:D $size, Str:D $input, $limit = Inf)
multi method comb(Str:D $input:)
multi method comb(Str:D $input: Str:D   $matcher, $limit = Inf)
multi method comb(Str:D $input: Regex:D $matcher, $limit = Inf, Bool :$match)
multi method comb(Str:D $input: Int:D $size, $limit = Inf)

在 $input 中搜索 $matcher，并返回一个 Seq 的非重叠匹配，限制在最多 $limit 个匹配。

如果 $matcher 是一个 Regex，则每个 Match 对象都会被转换为一个 Str，除非设置了 $match（在 Rakudo 编译器的 2020.01 版本中可用）。

如果没有提供匹配器，则返回字符串中字符的 Seq，就像匹配器是 rx/./ 一样。

示例

say "abc".comb.raku;                 # OUTPUT: «("a", "b", "c").Seq␤» 
say "abc".comb(:match).raku;         # OUTPUT: «(｢a｣ ｢b｣ ｢c｣)␤» 
say 'abcdefghijk'.comb(3).raku;      # OUTPUT: «("abc", "def", "ghi", "jk").Seq␤» 
say 'abcdefghijk'.comb(3, 2).raku;   # OUTPUT: «("abc", "def").Seq␤» 
say comb(/\w/, "a;b;c").raku;        # OUTPUT: «("a", "b", "c").Seq␤» 
say comb(/\N/, "a;b;c").raku;        # OUTPUT: «("a", ";", "b", ";", "c").Seq␤» 
say comb(/\w/, "a;b;c", 2).raku;     # OUTPUT: «("a", "b").Seq␤» 
say comb(/\w\;\w/, "a;b;c", 2).raku; # OUTPUT: «("a;b",).Seq␤» 
say comb(/.<(.)>/, "<>[]()").raku;   # OUTPUT: «(">", "]", ")").Seq␤»

如果匹配器是一个整数值，则 comb 的行为就像匹配器是 rx/ . ** {1..$matcher} / 一样，但经过优化以使其速度更快。

请注意，Regex 匹配器可以通过使用显式设置顶级捕获的功能来控制返回匹配文本的哪一部分。

multi        comb(Pair:D $rotor, Str:D $input, $limit = Inf, Bool :$partial)
multi method comb(Str:D $input: Pair:D $rotor, $limit = Inf, Bool :$partial)

在 6.e 语言版本中可用（早期实现存在于 Rakudo 编译器 2022.12+ 中）。rotor 对指示作为键获取的字符数（“大小”）和之后向前移动的“步数”。其主要预期用途是提供一种从字符串中创建 N-grams 的有效方法。默认情况下，只生成指定大小的字符串。可以通过使用命名参数 :partial 和 true 值来覆盖此设置。

示例

say "abcde".comb(3 => -2);             # OUTPUT: «(abc bcd cde)␤» 
say "abcde".comb(3 => -2, :partial);   # OUTPUT: «(abc bcd cde de e)␤» 
say "abcdefg".comb(3 => -2, 2);        # OUTPUT: «(abc bcd)␤» 
say comb(3 => -2, "abcde");            # OUTPUT: «(abc bcd cde)␤» 
say comb(5 => -2, "abcde", :partial);  # OUTPUT: «(abc bcd cde de e)␤» 
say comb(5 => -2, "abcdefg", 2);       # OUTPUT: «(abc bcd)␤»

例程 lines§

multi method lines(Str:D: $limit, :$chomp = True)
multi method lines(Str:D: :$chomp = True)

返回行列表。默认情况下，它会像调用 $input.comb( / ^^ \N* /, $limit ) 一样去除行尾。要保留行尾，请将可选命名参数 $chomp 设置为 False。

示例

say lines("a\nb").raku;    # OUTPUT: «("a", "b").Seq␤» 
say lines("a\nb").elems;   # OUTPUT: «2␤» 
say "a\nb".lines.elems;    # OUTPUT: «2␤» 
say "a\n".lines.elems;     # OUTPUT: «1␤» 
 
# Keep line endings 
say lines(:!chomp, "a\nb").raku;  # OUTPUT: «("a\n", "b").Seq␤» 
say "a\n".lines(:!chomp).elems;   # OUTPUT: «1␤»

可以通过将 $limit 变量设置为非零、非 Infinity 值来限制返回的行数

say <not there yet>.join("\n").lines( 2 ); # OUTPUT: «(not there)␤»

从 6.d 语言开始已弃用，:count 参数用于返回总行数

say <not there yet>.join("\n").lines( :count ); # OUTPUT: «3␤»

改用对返回的 Seq 调用 elems

say <not there yet>.join("\n").lines.elems; # OUTPUT: «3␤»

例程 words§

multi method words(Str:D: $limit)
multi method words(Str:D:)

返回非空白位列表，即与调用 $input.comb( / \S+ /, $limit ) 相同。

示例

say "a\nb\n".words.raku;       # OUTPUT: «("a", "b").Seq␤» 
say "hello world".words.raku;  # OUTPUT: «("hello", "world").Seq␤» 
say "foo:bar".words.raku;      # OUTPUT: «("foo:bar",).Seq␤» 
say "foo:bar\tbaz".words.raku; # OUTPUT: «("foo:bar", "baz").Seq␤»

它还可以用作子例程，将第一个参数变成调用者。$limit 是可选的，但如果提供了（并且不等于 Inf），它将仅返回前 $limit 个单词。

say words("I will be very brief here", 2); # OUTPUT: «(I will)␤»

例程 flip§

multi        flip(Str:D  --> Str:D)
multi method flip(Str:D: --> Str:D)

返回逐个字符反转的字符串。

示例

"Raku".flip;  # OUTPUT: «ukaR» 
"ABBA".flip;  # OUTPUT: «ABBA»

方法 starts-with§

multi method starts-with(Str:D: Str(Cool) $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)

如果调用者与 $needle 相同或以 $needle 开头，则返回 True。

say "Hello, World".starts-with("Hello");     # OUTPUT: «True␤» 
say "https://raku.perl5.cn/".starts-with('ftp');  # OUTPUT: «False␤»

自 Rakudo 2020.02 版本以来，如果指定了可选命名参数 :ignorecase 或 :i，则调用者和 $needle 的比较将忽略大小写字母之间的区别。

say "Hello, World".starts-with("hello");              # OUTPUT: «False␤» 
say "Hello, World".starts-with("hello", :ignorecase); # OUTPUT: «True␤»

自 Rakudo 2020.02 以来，如果指定了可选命名参数 :ignoremark 或 :m，则调用者和 $needle 的比较只考虑基本字符，并忽略附加标记，如组合重音。

say "abc".starts-with("ä");              # OUTPUT: «False␤» 
say "abc".starts-with("ä", :ignoremark); # OUTPUT: «True␤»

方法 ends-with§

multi method ends-with(Str:D: Str(Cool) $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)

如果调用者与 $needle 相同或以 $needle 结尾，则返回 True。

say "Hello, World".ends-with('Hello');      # OUTPUT: «False␤» 
say "Hello, World".ends-with('ld');         # OUTPUT: «True␤»

自 Rakudo 2020.02 版本以来，如果指定了可选命名参数 :ignorecase 或 :i，则调用者和 $needle 的比较将忽略大小写字母之间的区别。

say "Hello, World".ends-with("world");              # OUTPUT: «False␤» 
say "Hello, World".ends-with("world", :ignorecase); # OUTPUT: «True␤»

自 Rakudo 2020.02 以来，如果指定了可选命名参数 :ignoremark 或 :m，则调用者和 $needle 的比较只考虑基本字符，并忽略附加标记，如组合重音。

say "abc".ends-with("ç");              # OUTPUT: «False␤» 
say "abc".ends-with("ç", :ignoremark); # OUTPUT: «True␤»

方法 subst§

multi method subst(Str:D: $matcher, $replacement = "", *%options)

返回调用者字符串，其中 $matcher 被 $replacement 替换（如果没有找到匹配项，则返回原始字符串）。如果没有提供 $replacement，则使用空字符串（即，删除匹配的字符串）。

subst 有一个就地语法变体，拼写为 s/matcher/replacement/，并在 s 后或匹配器内跟随状语。

$matcher 可以是 Regex 或文字 Str。类型为 Cool 的非 Str 匹配器参数将强制转换为 Str 以进行文字匹配。如果使用了 Regex $matcher，则 $/ 特殊变量 将被设置为 Nil（如果没有匹配项）、Match 对象或 List 的 Match 对象（如果使用了多匹配选项，如 :g）。

文字替换§

my $some-string = "Some foo";
my $another-string = $some-string.subst(/foo/, "string"); # gives 'Some string' 
$some-string.=subst(/foo/, "string"); # in-place substitution. $some-string is now 'Some string' 
 
say "multi-hyphenate".subst("-"); # OUTPUT: «multihyphenate␤»

可调用§

替换可以是 Callable，其中当前 Match 对象将被放置在 $/ 变量中，以及 $_ 主题变量中。使用 Callable 作为替换是你如何引用正则表达式中创建的任何捕获

# Using capture from $/ variable (the $0 is the first positional capture) 
say 'abc123defg'.subst(/(\d+)/, { " before $0 after " });
# OUTPUT: «abc before 123 after defg␤» 
 
# Using capture from $/ variable (the $<foo> is a named capture) 
say 'abc123defg'.subst(/$<foo>=\d+/, { " before $<foo> after " });
# OUTPUT: «abc before 123 after defg␤» 
 
# Using WhateverCode to operate on the Match given in $_: 
say 'abc123defg'.subst(/(\d+)/, "[ " ~ *.flip ~ " ]");
# OUTPUT: «abc[ 321 ]defg␤» 
 
# Using a Callable to generate substitution without involving current Match: 
my $i = 41;
my $str = "The answer is secret.";
say $str.subst(/secret/, {++$i}); # The answer to everything 
# OUTPUT: «The answer is 42.␤»

副词§

支持以下副词

shortlongmeaning
:g:global尝试尽可能频繁地匹配
:nth(Int|Callable|Whatever)仅替换第 n 个匹配项；别名：:st、:nd、:rd 和 :th
:ss:samespace在替换时保留空格
:ii:samecase在替换时保留大小写
:mm:samemark保留字符标记（例如，用 'o' 替换 'ü' 将导致 'ö'）
:x(Int|Range|Whatever)精确替换 $x 个匹配项

请注意，仅在 s/// 形式中，:ii 隐含 :i，:ss 隐含 :s。在方法形式中，:s 和 :i 修饰符必须添加到正则表达式，而不是 subst 方法调用。

更多示例§

以下是其他用法示例

my $str = "Hey foo foo foo";
 
say $str.subst(/foo/, "bar", :g);           # OUTPUT: «Hey bar bar bar␤» 
say $str.subst(/\s+/, :g);                  # OUTPUT: «Heyfoofoofoo␤» 
 
say $str.subst(/foo/, "bar", :x(0));        # OUTPUT: «Hey foo foo foo␤» 
say $str.subst(/foo/, "bar", :x(1));        # OUTPUT: «Hey bar foo foo␤» 
# Can not match 4 times, so no substitutions made 
say $str.subst(/foo/, "bar", :x(4));        # OUTPUT: «Hey foo foo foo␤» 
say $str.subst(/foo/, "bar", :x(2..4));     # OUTPUT: «Hey bar bar bar␤» 
# Replace all of them, identical to :g 
say $str.subst(/foo/, "bar", :x(*));        # OUTPUT: «Hey bar bar bar␤» 
 
say $str.subst(/foo/, "bar", :nth(3));      # OUTPUT: «Hey foo foo bar␤» 
# Replace last match 
say $str.subst(/foo/, "bar", :nth(*));      # OUTPUT: «Hey foo foo bar␤» 
# Replace next-to-last last match 
say $str.subst(/foo/, "bar", :nth(*-1));    # OUTPUT: «Hey foo bar foo␤»

:nth 副词具有可读的英语变体

say 'ooooo'.subst: 'o', 'x', :1st; # OUTPUT: «xoooo␤» 
say 'ooooo'.subst: 'o', 'x', :2nd; # OUTPUT: «oxooo␤» 
say 'ooooo'.subst: 'o', 'x', :3rd; # OUTPUT: «ooxoo␤» 
say 'ooooo'.subst: 'o', 'x', :4th; # OUTPUT: «oooxo␤»

方法 subst-mutate§

注意： .subst-mutate 在 6.d 版本中已弃用，未来版本中将被移除。你可以使用 subst 与 .= 方法调用赋值运算符 或 s/// 替换运算符 代替。

如果 subst 返回修改后的字符串并保持原样，则可以使用 subst-mutate 改变原始字符串。如果匹配成功，该方法将返回一个 Match 对象，表示成功的匹配，否则返回 Nil。如果 :nth（或其别名）与 Iterable 值、:g、:global 或 :x 参数一起使用，则返回 List 的 Match 对象，或如果未发生匹配，则返回一个空的 List。

my $some-string = "Some foo";
my $match = $some-string.subst-mutate(/foo/, "string");
say $some-string;  # OUTPUT: «Some string␤» 
say $match;        # OUTPUT: «｢foo｣␤» 
$some-string.subst-mutate(/<[oe]>/, '', :g); # remove every o and e, notice the :g named argument from .subst

如果使用 Regex $matcher，则 $/ 特殊变量 将被设置为 Nil（如果未发生匹配）、Match 对象或 List 的 Match 对象（如果使用多匹配选项，如 :g）。

例程 substr§

multi        substr(Str:D $s, $from, $chars?  --> Str:D)
multi        substr(Str:D $s, Range  $from-to --> Str:D)
multi method substr(Str:D $s: $from, $chars?  --> Str:D)
multi method substr(Str:D $s: Range $from-to  --> Str:D)

返回原始字符串的子字符串，位于 $from-to 端点（强制转换为 Int）指定的索引之间，或从索引 $from 开始且长度为 $chars。

$from 和 $chars 都可以指定为 Callable，它将使用原始字符串的 长度 进行调用，并且返回值将用作参数的值。如果 $from 或 $chars 不是 Callable，它们将被强制转换为 Int。

如果省略了 $chars 或它大于可用字符，则返回从 $from 到字符串末尾的字符串。如果 $from-to 的起始索引或 $from 小于零，则会抛出 X::OutOfRange 异常。允许 $from-to 的结束索引超出字符串末尾，在这种情况下，它将等同于最后一个字符的索引。

say substr("Long string", 3..6);     # OUTPUT: «g st␤» 
say substr("Long string", 6, 3);     # OUTPUT: «tri␤» 
say substr("Long string", 6);        # OUTPUT: «tring␤» 
say substr("Long string", 6, *-1);   # OUTPUT: «trin␤» 
say substr("Long string", *-3, *-1); # OUTPUT: «in␤»

方法 substr-eq§

multi method substr-eq(Str:D:  Str(Cool) $test-string, Int(Cool) $from, :i(:$ignorecase), :m(:$ignoremark) --> Bool)
multi method substr-eq(Cool:D: Str(Cool) $test-string, Int(Cool) $from, :i(:$ignorecase), :m(:$ignoremark) --> Bool)

如果 $test-string 从给定的初始索引 $from 开始与 String 对象完全匹配，则返回 True。例如，从字符串 "foobar" 开始，子字符串 "bar" 将从索引 3 开始匹配

my $string = "foobar";
say $string.substr-eq("bar", 3);    # OUTPUT: «True␤»

但是，从索引 3 开始的子字符串 "barz" 不会匹配，即使子字符串的前三个字母确实匹配

my $string = "foobar";
say $string.substr-eq("barz", 3);   # OUTPUT: «False␤»

当然，要匹配整个字符串，只需从索引 0 开始匹配

my $string = "foobar";
say $string.substr-eq("foobar", 0); # OUTPUT: «True␤»

自 Rakudo 2020.02 版本以来，如果指定了可选命名参数 :ignorecase 或 :i，则调用者和 $test-string 的比较将忽略大小写字母之间的区别。

say "foobar".substr-eq("Bar", 3);              # OUTPUT: «False␤» 
say "foobar".substr-eq("Bar", 3, :ignorecase); # OUTPUT: «True␤»

自 Rakudo 2020.02 版本以来，如果指定了可选命名参数 :ignoremark 或 :m，则调用者和 $test-string 的比较只考虑基本字符，而忽略组合重音等附加标记。

say "cliché".substr-eq("che", 3);              # OUTPUT: «False␤» 
say "cliché".substr-eq("che", 3, :ignoremark); # OUTPUT: «True␤»

由于此方法是从 Cool 类型继承的，因此它也适用于整数。因此，整数 42 将从索引 1 开始匹配值 342

my $integer = 342;
say $integer.substr-eq(42, 1);      # OUTPUT: «True␤»

正如预期的那样，可以通过从索引 0 开始来匹配整个值

my $integer = 342;
say $integer.substr-eq(342, 0);     # OUTPUT: «True␤»

使用不同的值或不正确的起始索引也不会匹配

my $integer = 342;
say $integer.substr-eq(42, 3);      # OUTPUT: «False␤» 
say $integer.substr-eq(7342, 0);    # OUTPUT: «False␤»

方法 substr-rw§

method substr-rw($from, $length = *)

substr 的一个版本，它返回一个 Proxy，该代理用作字符串变量一部分的可写引用。它的第一个参数 $from 指定字符串中应进行替换的索引，其最后一个参数 $length 指定要替换的字符数。如果未指定，$length 默认为字符串的长度。

例如，在它的方法形式中，如果要获取字符串 "abc" 并用字母 "z" 替换第二个字符（在索引 1 处），则执行以下操作

my $string = "abc";
$string.substr-rw(1, 1) = "z";
$string.say;                         # OUTPUT: «azc␤»

请注意，也可以插入新字符

my $string = 'azc';
$string.substr-rw(2, 0) = "-Zorro-"; # insert new characters BEFORE the character at index 2 
$string.say;                         # OUTPUT: «az-Zorro-c␤»

substr-rw 还有一个函数形式，因此上面的示例也可以这样编写

my $string = "abc";
substr-rw($string, 1, 1) = "z";
$string.say;                          # OUTPUT: «azc␤» 
substr-rw($string, 2, 0) = "-Zorro-";
$string.say;                          # OUTPUT: «az-Zorro-c␤»

也可以别名 substr-rw 返回的可写引用以进行重复操作

my $string = "A character in the 'Flintstones' is: barney";
$string ~~ /(barney)/;
my $ref := substr-rw($string, $0.from, $0.to-$0.from);
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: barney␤» 
$ref = "fred";
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: fred␤» 
$ref = "wilma";
$string.say;
# OUTPUT: «A character in the 'Flintstones' is: wilma␤»

例程 samemark§

multi  samemark(Str:D $string, Str:D $pattern --> Str:D)
method samemark(Str:D: Str:D $pattern --> Str:D)

返回 $string 的副本，其中每个字符的标记/重音信息已更改，以便与 $pattern 中相应字符的标记/重音匹配。如果 $string 比 $pattern 长，则 $string 中的剩余字符将接收与 $pattern 中最后一个字符相同的标记/重音。如果 $pattern 为空，则不会进行任何更改。

示例

say 'åäö'.samemark('aäo');                        # OUTPUT: «aäo␤» 
say 'åäö'.samemark('a');                          # OUTPUT: «aao␤» 
 
say samemark('Räku', 'a');                        # OUTPUT: «Raku␤» 
say samemark('aöä', '');                          # OUTPUT: «aöä␤»

方法 succ§

method succ(Str:D: --> Str:D)

返回递增 1 的字符串。

字符串增量是“神奇的”。它搜索最后一个不是以点开头的字母数字序列，并对其进行增量。

'12.34'.succ;      # OUTPUT: «13.34» 
'img001.png'.succ; # OUTPUT: «img002.png»

实际增量步骤通过将最后一个字母数字字符映射到它所属的字符范围，并选择该范围内的下一个字符，在溢出时进位到前一个字母来实现。

'aa'.succ;   # OUTPUT: «ab» 
'az'.succ;   # OUTPUT: «ba» 
'109'.succ;  # OUTPUT: «110» 
'α'.succ;    # OUTPUT: «β» 
'a9'.succ;   # OUTPUT: «b0»

字符串增量是 Unicode 感知的，并且通常适用于字符可以唯一归类为属于一个字符范围的脚本。

方法 pred§

method pred(Str:D: --> Str:D)

返回递减一的字符串。

字符串递减就像字符串增量一样“神奇”（参见 succ）。它在欠流时失败

'b0'.pred;           # OUTPUT: «a9» 
'a0'.pred;           # OUTPUT: Failure 
'img002.png'.pred;   # OUTPUT: «img001.png» 

例程 ord§

multi        ord(Str:D  --> Int:D)
multi method ord(Str:D: --> Int:D)

返回字符串中第一个音素的基字符的码点号。

示例

ord("A"); # 65 
"«".ord;  # 171

方法 ords§

multi method ords(Str:D: --> Seq)

返回描述构成字符串的码点的 Unicode 码点号列表。

示例

"aå«".ords; # (97 229 171)

字符串表示为音素。如果字符串中的字符由多个码点表示，那么所有这些码点都将出现在 ords 的结果中。因此，结果中的元素数量可能并不总是等于 chars，但将等于 codes；codes 以不同的方式计算码点，因此结果可能会更快。

返回的码点将在 NFC 中表示字符串。如果需要其他形式，请参见 NFD、NFKC 和 NFKD 方法。

方法 trans§

multi method trans(Str:D: Pair:D \what, *%n --> Str)
multi method trans(Str:D: *@changes, :complement(:$c), :squash(:$s), :delete(:$d) --> Str)

用一个或多个字符替换一个或多个字符。支持范围，适用于键和值。正则表达式用作键。如果使用键和值列表，则也可以替换子字符串。当使用 :complement 调用时，任何内容都将被单个值替换，但匹配的值或范围除外；使用 :delete 删除不带相应替换的匹配字符。组合 :complement 和 :delete 将删除任何内容，但匹配的值除外，除非指定了替换字符，在这种情况下，将忽略 :delete。副词 :squash 将重复匹配的字符减少为单个字符。

示例

my $str = 'say $x<b> && $y<a>';
$str.=trans( '<' => '«' );
$str.=trans( '<' => '«', '>' => '»' );
 
$str.=trans( [ '<'   , '>'   , '&' ] =>
             [ '&lt;', '&gt;', '&amp;' ]);
 
$str.=trans( ['a'..'y'] => ['A'..'z'] );
 
"abcdefghij".trans(/<[aeiou]> \w/ => '');                     # OUTPUT: «cdgh» 
 
"a123b123c".trans(['a'..'z'] => 'x', :complement);            # OUTPUT: «axxxbxxxc» 
"aaa1123bb123c".trans('a'..'z' => 'A'..'Z', :squash);         # OUTPUT: «A1123B123C» 
"aaa1123bb123c".trans('a'..'z' => 'x', :complement, :squash); # OUTPUT: «aaaxbbxc»

通常，字符串在替换后将具有相同的长度

say "a123b123c".trans('23' => '4');   # OUTPUT: «a144b144c␤» 
say "a123b123c".trans('123' => 'þð'); # OUTPUT: «aþðþbþðþc␤»

:squash 和 :delete 在这种情况下将产生相同的效果，使其成为严格替换

say "a123b123c".trans('123' => 'þð', :squash); # OUTPUT: «aþðbþðc␤» 
say "a123b123c".trans('123' => 'þð', :delete); # OUTPUT: «aþðbþðc␤»

:delete 还将从原始字符串中删除不匹配的字符

say "abc".trans("abc".comb => 1..2, :delete);  # OUTPUT: «12␤»

请注意，两个版本的多方法的行为略有不同。如果原点也是一个字符，则第一个表单将只转置一个字符

say "abcd".trans( "a" => "zz" );  # OUTPUT: «zbcd␤» 
say "abcd".trans( "ba" => "yz" ); # OUTPUT: «zycd␤» 

在第二种情况下，行为符合预期，因为原点长度超过一个字符。但是，如果多方法中的 Pair 没有 Str 作为原点或目标，则将其处理为第二个多方法，并且行为会发生变化

say "abcd".trans: ["a"] => ["zz"]; # OUTPUT: «zzbcd␤»

在这种情况下，Pair 中既没有 origin 也没有 target 是 Str；具有 Pair 签名的该方法随后调用第二个方法，这使得上述调用等效于 "abcd".trans: ["a"] => ["zz"],（后面带有逗号，使其成为 Positional，而不是 Pair），从而产生显示为输出的行为。

方法 indent§

multi method indent(Int $steps where { $_ == 0 } )
multi method indent(Int $steps where { $_ > 0  } )
multi method indent($steps where { .isa(Whatever) || .isa(Int) && $_ < 0 } )

使用 $steps 对字符串的每一行进行缩进。如果 $steps 为负，则会缩小缩进。如果 $steps 为 *，则会将字符串缩小到边距

"  indented by 2 spaces\n    indented even more".indent(*)
    eq "indented by 2 spaces\n  indented even more"

方法 trim§

method trim(Str:D: --> Str)

删除前导和尾随空格。它既可以用作字符串上的方法，也可以用作函数。当用作方法时，它将返回修剪后的字符串。为了进行就地修剪，需要编写 .=trim

my $line = '   hello world    ';
say '<' ~ $line.trim ~ '>';        # OUTPUT: «<hello world>␤» 
say '<' ~ trim($line) ~ '>';       # OUTPUT: «<hello world>␤» 
$line.trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<   hello world    >␤» 
$line.=trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<hello world>␤»

另请参见 trim-trailing 和 trim-leading。

方法 trim-trailing§

method trim-trailing(Str:D: --> Str)

从字符串末尾删除空格字符。另请参见 trim。

方法 trim-leading§

method trim-leading(Str:D: --> Str)

从字符串开头删除空格字符。另请参见 trim。

方法 NFC§

method NFC(Str:D: --> NFC:D)

以 NFC 格式（Unicode 规范化形式 C/组合）返回代码点字符串。

方法 NFD§

method NFD(Str:D: --> NFD:D)

以 NFD 格式（Unicode 规范化形式 D/分解）返回代码点字符串。

方法 NFKC§

method NFKC(Str:D: --> NFKC:D)

以 NFKC 格式（Unicode 规范化形式 KC/兼容组合）返回代码点字符串。

方法 NFKD§

method NFKD(Str:D: --> NFKD:D)

以 NFKD 格式（Unicode 规范化形式 KD/兼容分解）返回代码点字符串。

方法 ACCEPTS§

multi method ACCEPTS(Str:D: $other)

如果字符串与 $other 相同，则返回 True。

方法 Capture§

method Capture()

抛出 X::Cannot::Capture。

例程 val§

multi val(*@maybevals)
multi val(Slip:D \maybevals)
multi val(List:D \maybevals)
multi val(Pair:D \ww-thing)
multi val(\one-thing)
multi val(Str:D $MAYBEVAL, :$val-or-fail)

给定一个可能可解析为数字值的 Str，它将尝试构造适当的 同形异位词，返回 IntStr、NumStr、RatStr 或 ComplexStr 之一，或者如果无法解析数字值，则返回一个普通的 Str。

say val("42").^name;    # OUTPUT: «IntStr␤» 
say val("42e0").^name;  # OUTPUT: «NumStr␤» 
say val("42.0").^name;  # OUTPUT: «RatStr␤» 
say val("42+0i").^name; # OUTPUT: «ComplexStr␤»

你可以使用加号和减号，以及 Unicode “减号”作为字符串的一部分

say val("−42");         # OUTPUT: «−42␤»

虽然属于 Unicode 类别 Nl（数字字母）和 No（其他数字）的字符可以在语言中用作数字文字，但它们不会被 val 故意转换为数字，并且在它们上使用 val 会导致失败。对于合成数字（例如 7̈ ）也会发生这种情况。如果你需要将此类字符转换为 Numeric，请参见 unival。

方法版本§

method Version(Str:D: --> Version:D)

自 Rakudo 编译器 2020.01 版本起可用。

强制将字符串转换为 版本。

这可用于 签名中的类型强制转换，例如

sub f(Version(Str) $want-version) { say $want-version.^name };
f "1.2.3";  # OUTPUT: «Version␤»

方法日期§

method Date(Str:D:)

自 Rakudo 编译器 2020.05 版本起可用。

强制将 Str 转换为 日期 对象，前提是字符串格式正确。日期 (Str) 也适用。

示例

say '2015-11-24'.Date.year;  # OUTPUT: «2015␤» 
say Date('2015-11-24').year; # OUTPUT: «2015␤»

方法日期时间§

method DateTime(Str:D:)

自 Rakudo 编译器 2020.05 版本起可用。

强制将 Str 转换为 日期时间 对象，前提是字符串格式正确。日期时间 (Str) 也适用。

示例

say ('2012-02-29T12:34:56Z').DateTime.hour; # OUTPUT: «12␤» 
say DateTime('2012-02-29T12:34:56Z').hour;  # OUTPUT: «12␤»

自 Rakudo 2022.07 版本起，还可以只指定一个 "YYYY-MM-DD" 字符串来表示给定日期的午夜。

say "2023-03-04".DateTime;  # OUTPUT: «2023-03-04T00:00:00Z␤»

类型图§

Str 的类型关系
raku-type-graph Str Str Cool Cool Str->Cool Stringy Stringy Str->Stringy Mu Mu Any Any Any->Mu Cool->Any Allomorph Allomorph Allomorph->Str Numeric Numeric Real Real Real->Numeric Int Int Int->Cool Int->Real IntStr IntStr IntStr->Allomorph IntStr->Int Num Num Num->Cool Num->Real NumStr NumStr NumStr->Allomorph NumStr->Num Complex Complex Complex->Cool Complex->Numeric ComplexStr ComplexStr ComplexStr->Allomorph ComplexStr->Complex Rational Rational Rational->Real Rat Rat Rat->Cool Rat->Rational RatStr RatStr RatStr->Allomorph RatStr->Rat

展开上面的图表