Perl 到 Raku 指南 - 函数

Perl 到 Raku 的内置函数

描述§

一份（希望是）全面的 Perl 内置函数列表，以及它们在 Raku 中的等效函数，并在必要时说明它们之间的差异。

注意§

本文档旨在帮助您从 Perl 的 perlfunc 文档中的函数迁移到 Raku 中的等效函数。有关 Raku 函数的完整文档，请点击本文档中的链接跳转到相应的文档。

一般来说：Raku 比 Perl 更重视对象。在 Raku 中，一切都是对象，尽管语言足够灵活，即使您不想以面向对象的方式工作，它也不会强迫您这样做。然而，这意味着很多以前以 function(@args) 形式的函数调用现在也变成了以 @args.function 形式的方法调用（在极少数情况下，只存在方法调用）。在下面的文本中应该很明显，但现在最好先进入这种思维方式。

此外，除非另有说明，本文中的“函数”一词将指 func(@args) 形式的函数，而“方法”将指 @args.func 形式的函数。

Perl 函数的字母顺序列表§

文件测试§

  • -X FILEHANDLE

  • -X EXPR

  • -X DIRHANDLE

  • -X

在 Raku 中，您在进行文件测试时有两种选择。您可以进行智能匹配 (~~) 或调用方法。

在 Raku 中，您不需要以传统方式实际打开文件句柄（尽管您可以这样做）来进行文件测试。您只需在文件名后附加 .IO 即可。例如，以下是如何使用智能匹配检查文件是否可读：

'/path/to/file'.IO ~~ :r

您可以使用已打开的文件句柄。这里，使用文件句柄 $fh，是一个使用方法语法进行文件测试的示例：

$fh.r

大多数以前的文件测试都有冒号等效项，可用于智能匹配

:e 存在
:d 目录
:f 文件
:l 符号链接
:r 可读的
:w 可写的
:x 可执行的
:s 大小
:z 零大小

所有这些测试都可以用作方法（不带冒号）。

然而，有三个测试 *只有* 方法等效项

$fh.modified; # -M $fh 
$fh.accessed; # -A $fh 
$fh.changed;  # -C $fh 

Perl 中剩余的文件测试在 Raku 中未实现。

有关此内容的文档可以在 文件测试运算符 中找到。

有关读取和写入文件的更多信息，请参见 io。此外，下面关于 open() 的部分可能会有所帮助。

Raku 生态系统有一个模块 P5-X，它尽可能地将行为导出到 Raku 中。

abs§

  • abs VALUE

可以用作函数 (abs($x))，也可以用作方法。但是，有一个问题 - 方法调用比 - 绑定得更紧密，因此，例如，-15.abs 评估为 -(15.abs)，得到 -15。在此示例中，您需要执行类似 (-15).abs 的操作。

abs 也可以在没有值的情况下对 $_ 进行操作，但不能作为函数，并且作为方法，您需要将其称为 .abs 而不是简单的 abs。

Raku 生态系统有一个模块 P5math，它导出一个 abs 函数，该函数尽可能地模仿原始 Perl 行为。

accept§

  • accept NEWSOCKET, GENERICSOCKET

accept 是您可以对服务器调用的方法，例如 $server.accept()。它不返回打包的地址，而是返回一个套接字，很可能是一个 IO::Socket 对象。

alarm§

  • alarm SECONDS

alarm() 不再存在。但是，可以在经过一定时间后或在给定时间执行代码

Promise.in(5).then: { say "five seconds have passed" }
 
Promise.at(now + 5).then: { say "five seconds have passed" }

在 Raku 中，这 *不* 涉及任何（虚拟）信号。

atan2§

  • atan2 Y, X

可用作函数，也可以用作方法。例如，这些是等效的

atan2(100);
100.atan2;

bind§

  • bind SOCKET, NAME

[需要进一步研究] 在 Raku 中没有与套接字相关的 bind() 的迹象。据推测，无论需要什么套接字绑定，都会在您创建新的套接字对象时发生。

binmode§

  • binmode FILEHANDLE

您将使用 :bin 作为打开套接字时的文件模式，而不是使用它。例如 my $fh = open("path/to/file", :bin);

bless§

  • bless REF, CLASSNAME

随着 Raku 中类创建的更改，这可能比在 Perl 中使用得更少，并且是方法和函数。Raku 文档说“创建一个与调用者类型相同的对象，使用命名参数初始化属性，并返回创建的对象”。如果您要将模块从 Perl 移植到 Raku，您很可能希望使用 new 来创建对象而不是 bless，尽管在某些情况下后者可能仍然有用。

break§

  • break

它在 Raku 中不存在。要退出 given 块，您可能应该查看 proceed 和 succeed。

caller§

  • caller EXPR

在 Raku 中有几种方法可以获取调用者信息。基本功能现在通过 callframe 提供。但是，Raku 为常规块构建调用帧，而不仅仅是为子例程构建调用帧，因此有更多帧需要查看。以下将检索 caller 可以返回的基本信息

my $frame   = callframe(0); # OR just callframe() 
my ($subroutine, $package);
if $frame.code ~~ Routine {
    $subroutine = $frame.code.name;
    $package    = $frame.code.package;
}
my $file    = $frame.file;
my $line    = $frame.line;

caller 返回的许多其他详细信息特定于 Perl，在 Raku 中没有意义。

您还可以使用动态变量 &?ROUTINE、&?BLOCK、$?PACKAGE、$?FILE 和 $?LINE 获取当前帧或例程帧的一些信息。对于许多目的，Backtrace 可能提供了一种更轻松的方式来浏览调用堆栈。

Raku 生态系统有一个模块 P5caller，它导出一个尽可能模仿原始 Perl 行为的 caller 函数。

chdir§

  • chdir EXPR

与 Perl 中的工作方式相同，但必须接受参数。chdir() 的行为（关于查看 HOME 和 LOGDIR）不受支持。

在 Raku 中，chdir 仅更改 $*CWD 动态变量。它不会真正从操作系统的角度更改默认目录；如果需要，可以使用特殊动态变量例程 &*chdir 来实现。

这样做是因为没有“每个操作系统线程的默认目录”的概念。由于 Raku 不会分叉，而只会进行线程化，因此认为“当前目录”概念应该在 $*CWD 动态变量中，该变量可以是词法作用域的，因此可以是线程安全的。

Raku 生态系统有一个模块 P5chdir，它导出一个尽可能模仿原始 Perl 行为的 chdir 函数，包括查看 HOME 和 LOGDIR。

chmod§

  • chmod LIST

在 Perl 下的功能相同，区别在于八进制数的表示方式不同（0o755 而不是 0755）。您也可以将其用作方法，例如 $fh.chmod(0o755)。

chomp§

  • chomp VARIABLE

chomp 的行为与 Perl 中不同。它不会影响目标，而是返回目标的副本，其中删除了最后一个逻辑换行符，例如 $x = "howdy\n";$y = chomp($x); 会导致 $x 包含 "howdy\n"，而 $y 包含 "howdy"。也可以用作方法，例如 $y = $x.chomp。与许多其他方法一样，也可以使用赋值来修改目标，例如 $x.=chomp 会导致 $x 包含 "howdy"。

请注意，chomp()（不带参数）在 Raku 中不受支持。

Raku 生态系统有一个模块 P5chomp，它导出一个尽可能模仿原始 Perl 行为的 chomp 函数。

chop§

  • chop VARIABLE

与 chomp 一样，在 Raku 中，这将返回被截断的字符串，而不是在原地截断。即 $x = "howdy";$y = chop($x); 会导致 $x 为 "howdy"，而 $y 为 "howd"。也可以用作方法：$y = $x.chop。

请注意，chop()（不带参数）在 Raku 中不受支持。

Raku 生态系统有一个模块 P5chomp，它导出一个尽可能模仿原始 Perl 行为的 chop 函数。

.head2 chown

  • chown LIST

chown 不在 Raku 中。

chr§

  • chr NUMBER

类似于 Perl 版本，将目标强制转换为整数，并将其用作 Unicode 代码点来返回相关字符。可以用作函数和方法

chr(65); # "A" 
65.chr;  # "A"

请注意，chr()（不带参数）在 Raku 中不受支持。

Raku 生态系统有一个模块 P5chr，它导出一个 chr 函数，尽可能地模仿原始 Perl 的行为。

chroot§

  • chroot FILENAME

Raku 中没有 chroot。

close§

  • close FILEHANDLE

与 Perl 中一样，关闭文件句柄。返回布尔值。close $fh 和 $fh.close 都可以工作。

请注意，Raku 中不支持 close()（不带参数）。

closedir§

  • closedir DIRHANDLE

Raku 中不支持。

Raku 生态系统有一个模块 P5opendir，它导出一个 closedir 函数，尽可能地模仿原始 Perl 的行为。

connect§

  • connect SOCKET, NAME

对于异步套接字，请使用 connect 来自 IO::Socket::Async，或者为同步套接字创建 IO::Socket::INET 套接字。

continue§

  • continue BLOCK

  • continue

您应该使用 NEXT 块而不是 continue 块。Perl 中裸 continue; 的最接近的模拟似乎是 proceed/succeed。

cos§

  • cos EXPR

与 Perl 中一样工作。

cos 也可以在没有值的情况下对 $_ 进行操作，但不是作为函数，而作为方法，您需要将其称为 .cos 而不是简单的 cos。

Raku 生态系统有一个模块 P5math，它导出一个 cos 函数，尽可能地模仿原始 Perl 的行为。

crypt§

  • crypt PLAINTEXT, SALT

Raku 中不可用。

Raku 生态系统有一个模块 P5math，它导出一个 crypt 函数，尽可能地模仿原始 Perl 的行为。

dbm 函数§

  • dbmclose HASH

  • dbmopen HASH, DBNAME, MASK

这些函数在 Perl 中已被很大程度上取代，并且不太可能出现在 Raku 中。

defined§

  • defined EXPR

可能按预期执行，但从技术上讲，它在类型对象上返回 False，否则返回 True。当您意识到 $num.raku 是类型 Any（如果您没有为其分配任何内容）和分配的值（如果您有）时，这可能更有意义。它可以用作方法：$num.defined。任何新创建的类都可以拥有自己的 .defined 方法，从而决定如何以及何时应将其视为未定义。

请注意，Raku 中不支持 defined()（不带参数）。

Raku 生态系统有一个模块 P5defined，它导出一个 defined 函数，尽可能地模仿原始 Perl 的行为。

delete§

  • delete EXPR

Raku 使用新的副词语法替换了它，特别是 `:delete` 副词。例如：`my $deleted_value = %hash{$key}:delete;` 和 `my $deleted_value = @array[$i]:delete;`。

die§

  • die LIST

与 Perl 版本的工作方式类似，但 Raku 的异常机制可能比 Perl 提供的更强大、更灵活。请参阅 异常。要省略堆栈跟踪和位置，就像 Perl 的 `die "...\n"` 一样，请使用

note "...";
exit 1;

do§

  • do BLOCK

与 Perl 版本类似。请注意，`do` 和块之间必须有一个空格。

  • do EXPR

在 Raku 中已被 `EVALFILE` 替换。

dump§

  • dump LABEL

根据 S29，`dump` 已经被... 丢弃了。

each§

  • each HASH

没有完全等效的替代方案，因为在 Raku 中，哈希由 Pair 对象组成。您可以使用 `%hash.kv`，它返回键和值的列表。例如：`for %hash.kv -> $k, $v { say "$k: $v" }`。但是 Raku 提供了更多可能性，`%hash.pairs` 将每个 Pair 对象作为实体提供，而 `%hash.antipairs` 对键和值进行反转，并以相同的方式提供。

顺便说一下，我们在那里使用 `->` 的东西被称为尖括号块，虽然文档中有很多例子，但似乎没有真正清楚地解释它们是如何工作的。 https://design.raku.org/S04.html#The_for_statement 可能在这里有所帮助，以及位于 https://design.raku.org/S06.html#%22Pointy_blocks%22 的设计文档。在 https://en.wikibooks.org/wiki/Perl_6_Programming/Blocks_and_Closures#Pointy_Blocks 中也有一些信息。

Raku 生态系统有一个模块 P5each，它导出一个 `each` 函数，尽可能地模仿原始的 Perl 行为。

eof§

  • eof FILEHANDLE

在 Raku 中，这不能用作函数，而只能用作方法。即 `$filehandle.eof`。如果在文件末尾，则返回 `True`。

eval§

  • eval EXPR

  • eval EXPR

最接近的替换是 EVAL 函数。但是，此函数必须使用 pragma 显式允许才能以相同的方式工作。请注意，`EVAL` 不会执行任何 异常处理！

evalbytes§

  • evalbytes EXPR

没有等效的替代方案。

exec§

  • exec LIST

Raku 中没有任何东西完全复制 Perl 的 `exec`。`shell` 和 `run` 与 Perl 的 `system` 类似，但 `exec` 在执行系统命令后不返回的行为必须通过类似 `shell($command);exit();` 或可能是 `exit shell($command);` 的东西来模拟。

这两种解决方法都没有（在类 Unix 系统上）将 Perl 程序的进程替换为新程序的行为；值得注意的是，它们不适用于某些长期运行的守护进程中定期对自身执行 exec 以重置其状态或强制操作系统清理的做法。它们也不能满足 `exec` 将过时资源返回给操作系统的功能。

如果你想要 `exec` 的这些行为，你可以通过 `NativeCall` 接口使用 `exec*` 函数。请查阅你的操作系统手册页以了解 `exec`（或其他类似命名的调用，如 `execl`、`execv`、`execvp` 或 `execvpe`）。（注意：这些调用通常在类 Unix 操作系统家族之间不可移植。）考虑到这些注意事项，Raku 生态系统 Native::Exec 模块为类 Unix 系统导出了一个 `exec` 函数。

exists§

  • exists EXPR

在 Raku 中，这不是一个函数，而是一个副词。

%hash{$key}:exists;
@array[$i]:exists;

exit§

  • exit EXPR

似乎与 Perl 中的行为相同。

exp§

  • exp EXPR

与 Perl 中相同。

exp 也可以在没有值的情况下对 `$_` 进行操作，但不是作为函数，而是在作为方法时，你需要调用它为 `exp` 而不是简单的 `exp`。

Raku 生态系统有一个模块 P5math，它导出一个 `exp` 函数，尽可能地模仿原始 Perl 的行为。

fc§

  • fc EXPR

看起来它与 Perl 中的行为相同，只是在 Raku 中不支持不带参数调用它。

Raku 生态系统有一个模块 P5fc，它导出一个 `fc` 函数，尽可能地模仿原始 Perl 的行为。

fcntl§

  • fcntl FILEHANDLE, FUNCTION, SCALAR

似乎不在 Raku 中。

__FILE__§

  • __FILE__

被 `$?FILE` 替换，它与 `__FILE__` 略有不同，因为它始终是绝对路径，而不是 Perl 中的相对路径。

Raku 生态系统有一个模块 P5__FILE__，它导出一个 `__FILE__` 项，尽可能地模仿原始 Perl 的行为。

fileno§

  • fileno FILEHANDLE

IO::Handle 上的 `native-descriptor` 方法返回与 `fileno` 等效的值。

Raku 生态系统有一个模块 P5fileno，它导出一个 `fileno` 函数，尽可能地模仿原始 Perl 的行为。

flock§

  • flock FILEHANDLE, OPERATION

目前未实现。

fork§

  • fork

没有内置的 `fork` 函数。虽然可以使用 NativeCall 调用它，但由此产生的进程很可能无法使用。

Raku 提供了对线程的广泛支持，并在内部使用线程。但是，`fork` 仅克隆调用 `fork` 的线程，从而导致一个进程缺少其其他线程，这些线程将处于未知状态，并且可能持有锁。即使 Raku 程序没有有意启动任何线程，编译器也可能在预编译过程中创建一些自己的线程，而 Raku 运行的 VM 也创建自己的内部工作线程来执行诸如优化和 GC 之类的后台操作。因此，线程的存在几乎是确定的，并且没有合理的方法使 `fork` 在这种情况下可靠地工作。

formats§

  • format

  • formline PICTURE, LIST

Raku 没有内置格式。

getc§

  • getc FILEHANDLE

从输入流中读取单个字符，与 Perl 中相同。现在也可以用作方法：$filehandle.getc

getpeername§

  • getpeername SOCKET

最初在 S29 中推测，但未在 Raku 中实现。

getpgrp§

  • getpgrp PID

不会实现。

Raku 生态系统有一个模块 P5getpriority，它导出一个 getpgrp 函数，尽可能地模仿原始 Perl 行为。

getppid§

  • getppid PID

不会实现。

Raku 生态系统有一个模块 P5getpriority，它导出一个 getppid 函数，尽可能地模仿原始 Perl 行为。

getpriority§

  • getpriority WHICH, WHO

不会实现。

Raku 生态系统有一个模块 P5getpriority，它导出一个 getpriority 函数，尽可能地模仿原始 Perl 行为。

get and set functions§

  • endpwent

  • getlogin

  • getpwent

  • getpwnam NAME

  • getpwuid UID

  • setpwent

Raku 生态系统有一个模块 P5getpwnam，它导出 endpwent、getlogin、getpwent、getpwnam、getpwuid 和 setpwent 函数，尽可能地模仿原始 Perl 行为。

  • endgrent

  • getgrent

  • getgrgid GID

  • getgrnam NAME

  • setgrent

Raku 生态系统有一个模块 P5getgrnam，它导出 endgrent、getgrent、getgrgid、getgrnam 和 setgrent 函数，尽可能地模仿原始 Perl 行为。

  • endnetent

  • getnetbyaddr ADDR, ADDRTYPE

  • getnetbyname NAME

  • getnetent

  • setnetent STAYOPEN

Raku 生态系统有一个模块 P5getnetbyname，它导出 endnetent、getnetent、getnetbyaddr、getnetbyname 和 setnetent 函数，尽可能地模仿原始 Perl 行为。

  • endservent

  • getservbyname NAME, PROTO

  • getservbyport PORT, PROTO

  • getservent

  • setservent STAYOPEN

Raku 生态系统有一个模块 P5getservbyname，它导出 endservent、getservent、getservbyname、getservbyport 和 setservent 函数，尽可能地模仿原始 Perl 行为。

  • endprotoent

  • getprotobyname NAME

  • getprotobynumber NUMBER

  • getprotoent

  • setprotoent STAYOPEN

Raku 生态系统有一个模块 P5getprotobyname，它导出 endprotoent、getprotoent、getprotobyname、getprotobynumber 和 setprotoent 函数，尽可能地模仿原始 Perl 行为。

  • gethostbyname NAME

  • gethostbyaddr ADDR, ADDRTYPE

  • gethostent

  • sethostent STAYOPEN

  • endhostent

[需要进一步研究] 显然，这一系列函数应该由 User、Group 等角色来处理。

getsock*§

  • getsockname SOCKET

  • getsockopt SOCKET, LEVEL, OPTNAME

[需要进一步研究] 这些可能由某种 IO::Socket 对象实现，但细节尚不清楚。

glob§

  • glob EXPR

核心库中不可用，尽管部分功能由 dir 例程及其 test 参数提供。

参见 生态系统中的 IO::Glob 模块

gmtime§

  • gmtime EXPR

与 localtime 的各个部分类似，gmtime 的功能似乎在 DateTime 对象中。例如，要获取当前时间的 DateTime 对象的 UTC 版本，请使用 my $gmtime = DateTime.now.utc。

Raku 生态系统有一个模块 P5localtime，它导出一个 gmtime 函数，该函数尽可能地模仿原始 Perl 行为。

goto§

  • goto LABEL

  • goto EXPR

  • goto &NAME

goto LABEL 的语法已被接受，但 goto 的运行时部分尚未实现。因此这将导致运行时错误

FOO: goto FOO; # Label.goto() not yet implemented. Sorry.

grep§

  • grep BLOCK LIST

  • grep EXPR, LIST

在 Raku 中仍然存在，但需要注意的是，块形式现在需要在块之后添加逗号。例如 @foo = grep { $_ = "bars" }, @baz。也可以用作方法：@foo = @bar.grep(/^f/)

hex§

  • hex EXPR

在 Raku 中，必须指定表达式。

被副词形式 :16 替换。例如 :16("aF") 返回 175。这是 Str->Int。

可以使用 .base 方法实现相反的结果（Int->Str）：0xaF.base(10)

恰好 .Str 默认以 10 为基数，因此如果您只是 say 0xaF，它也会打印 175，但这可能并不立即显而易见，因此可能不是最好的方法。

Raku 生态系统有一个模块 P5hex，它导出一个 hex 函数，该函数尽可能地模仿原始 Perl 行为。

import§

  • import LIST

Perl 中本来就不是内置函数。在 Raku 中，通常将函数声明为可导出或不可导出，所有可导出的函数都会被导出。尽管如此，选择性导入是可能的，但这超出了本文档的范围。有关详细信息，请参见 本节。

index§

  • index STR, SUBSTR, POSITION

与 Perl 中的工作方式相同。现在也可以用作方法："howdy!".index("how"); # 0。与 Perl 的主要区别在于，当未找到子字符串时，返回 Nil 而不是 -1。这与 with 命令结合使用非常有用

with index("foo","o") -> $index {
    say "Found it at $index";
}
else {
    say "Not found"
}

Raku 生态系统有一个模块 P5index，它导出一个 index 函数，该函数尽可能地模仿原始 Perl 行为。

int§

  • int EXPR

Raku 中有一个 truncate 函数（也可以用作方法），它执行 Perl 的 int 所做的操作。您可能希望将其用作 Perl 代码的直接翻译，但在 Raku 中，您可以像调用数字的 .Int 方法一样轻松地调用它。3.9.Int; # 3 和 3.9.truncate 是等效的。

请注意，int 在 Raku 中确实有意义。它是一种类型，可用于指示本机整数

my int $a = 42;   # a native integer, similar to Perl's integer values

int 在没有值的情况下也会对 $_ 进行操作，但不是作为函数，而作为方法，你需要调用它为 .int 而不是简单的 int。

Raku 生态系统有一个模块 P5math，它导出一个 int 函数，尽可能地模仿原始 Perl 的行为。

ioctl§

  • ioctl FILEHANDLE, FUNCTION, SCALAR

目前在 Raku 中未实现。

join§

  • join EXPR, LIST

与 Perl 中的工作方式相同，也可以作为方法使用：@x.join(",")

keys§

  • keys HASH

与 Perl 中的工作方式相同，也可以用作方法：%hash.keys

kill§

  • kill SIGNAL, LIST

  • kill SIGNAL

没有预定义的核心替代方案。一个不可移植的方法是使用 NativeCall

use NativeCall;
sub kill(int32, int32) is native {*};
kill $*PID, 9; # OUTPUT: «Killed␤»

要杀死通过创建 Proc::Async 启动的进程，请使用 Proc::Async.kill 方法。

last§

  • last LABEL

  • last EXPR

  • last

与 Perl 中相同。

lc§

  • lc EXPR

与 Perl 中的工作方式相同，也可以作为方法使用："UGH".lc。在 Raku 中，必须指定表达式。

Raku 生态系统有一个模块 P5lc，它导出一个 lc 函数，尽可能地模仿原始 Perl 的行为。

lcfirst§

  • lcfirst EXPR

在 Raku 中不存在。

Raku 生态系统有一个模块 P5lcfirst，它导出一个 lcfirst 函数，尽可能地模仿原始 Perl 的行为。

length§

  • length EXPR

被 chars 替换，通常用作方法 ($string.chars)，但也可以用作函数。

Raku 生态系统有一个模块 P5length，它导出一个 length 函数，尽可能地模仿原始 Perl 的行为。

__LINE__§

  • __LINE__

被 $?LINE 替换。

Raku 生态系统有一个模块 P5__FILE__，它导出一个 __LINE__ 项，尽可能地模仿原始 Perl 的行为。

  • link OLDFILE, NEWFILE

参见 link

listen§

  • listen SOCKET, QUEUESIZE

没有明确的文档，但似乎 listen 将是您将在某种 IO::Socket 对象上调用的方法。

local§

  • local EXPR

Raku 等价物是 temp。但是，与 local 不同，给定变量的值不会立即取消设置：它会保留其原始值，直到被赋值。

localtime§

  • localtime EXPR

localtime 的大部分功能都可以在 DateTime 中找到。localtime 的具体部分可以按如下方式找到

my $d = DateTime.now;
my $sec  = $d.second; # Potentially includes fractional seconds 
my $min  = $d.minute;
my $hour = $d.hour;
my $mday = $d.day-of-month; # or $d.day; 1..31 
my $mon  = $d.month; # 1..12 
my $year = $d.year;
my $wday = $d.day-of-week; # 1 => Monday, 2 => Tuesday, etc. 
my $yday = $d.day-of-year; # 1..366 

请注意，在 Raku 中，范围不是从 0 开始的，如示例中的注释所示。

目前似乎没有办法获取 Perl 的 $isdst。此外，Perl 提供的 scalar(localtime) 的结果也不可用。$d.Str 将给出类似于 "2015-06-29T12:49:31-04:00" 的内容。

Raku 生态系统有一个模块 P5localtime，它导出一个 localtime 函数，尽可能地模仿原始的 Perl 行为。

lock§

  • lock THING

目前在 Raku 中没有等效项。有一个 Lock 类用于创建 Lock 对象，可以根据需要锁定/解锁。但这种锁不引用任何外部对象。

log§

  • log EXPR

与 Perl 中相同。

log 也可以在没有值的情况下对 $_ 进行操作，但不是作为函数，而作为方法，您需要将其调用为 .log 而不是简单的 log。

Raku 生态系统有一个模块 P5math，它导出一个 log 函数，尽可能地模仿原始的 Perl 行为。

lstat§

  • lstat FILEHANDLE

  • lstat EXPR

  • lstat DIRHANDLE

  • lstat

可能在 Raku 的 IO 类中的某个地方实现，但目前尚不清楚。

m//§

  • m//

正则表达式语法在 Raku 中有所不同，但匹配运算符仍然存在。如果您尝试重写一些 Perl 代码，最重要的区别是 =~ 被智能匹配运算符 ~~ 替换。类似地，!~ 被 !~~ 替换。正则表达式运算符的选项是副词，并且很复杂。有关详细信息，请参阅 副词

map§

  • map BLOCK LIST

  • map EXPR, LIST

作为函数，Perl 和 Raku 之间的唯一区别是，如果您使用的是块，则块后面必须跟一个逗号。也可以用作方法：@new = @old.map: { $_ * 2 }

mkdir§

  • mkdir FILENAME, MASK

  • mkdir FILENAME

与 Perl 中一样工作。当给出多级目录规范时，它将自动使用相同的 MASK 创建不存在的中间目录（类似于 Perl 中的 File::Path 模块的 "make_path" 所做的）。

  • mkdir

Raku 中不允许使用零参数（隐式 $_）版本。

msg*§

  • msgctl ID, CMD, ARG

  • msgget KEY, FLAGS

  • msgrcv ID, VAR, SIZE, TYPE, FLAGS

  • msgsnd ID, MSG, FLAGS

在 Raku 中不是内置函数。可能在某个时候出现在外部模块中。也许。

my§

  • my VARLIST

  • 我的类型变量列表

  • 我的变量列表：属性

  • 我的类型变量列表：属性

与 Perl 中一样工作。

next§

  • next 标签

  • next 表达式

  • next

在 Raku 中相同。

no§

  • no 模块 版本

  • no 模块 列表

  • no 模块

  • no 版本

在 Raku 中，这可用于诸如 strict 之类的 pragma，但不适用于模块或版本。

oct§

  • oct

被副词形式 :8 替换。例如 :8("100") 返回 64。

如果你想处理以 0x、0o 或 0b 开头的字符串，你可以直接使用 prefix:<+> 运算符。

Raku 生态系统有一个模块 P5hex，它导出一个 oct 函数，尽可能地模仿原始 Perl 行为。

open§

  • open 文件句柄，表达式

  • open 文件句柄，模式，表达式

  • open 文件句柄，模式，表达式，列表

  • open 文件句柄，模式，引用

  • open 文件句柄

与 Perl 最明显的区别是文件模式语法。要以只读方式打开文件，你需要说 open("file", :r)。对于只写、读写和追加，你将分别使用 :w、:rw 和 :a。还有用于编码和文件句柄如何处理换行符的选项。详情 此处。

另一个重要的变化是，文件句柄在作用域退出时不会自动关闭。需要显式调用 close。

opendir§

  • opendir 目录句柄，表达式

没有替代品。请参阅 &dir/IO::Path.dir 以了解替代方案。

Raku 生态系统有一个模块 P5opendir，它导出一个 opendir 函数，尽可能地模仿原始 Perl 行为。

ord§

  • ord 表达式

与 Perl 中相同。可以作为方法使用："howdy!".ord; # 104

请注意，ord()（不带参数）在 Raku 中不受支持。

Raku 生态系统有一个模块 P5chr，它导出一个 ord 函数，尽可能地模仿原始 Perl 行为。

our§

  • our 变量列表

  • our 类型 变量列表

  • our 变量列表：属性

  • our 类型 变量列表：属性

在 Raku 中相同。

pack§

  • pack 模板，列表

在 Raku 中可用，前提是在需要调用 pack 的作用域中指定了 use experimental :pack。模板选项目前比 Perl 中更受限制。当前记录的列表可以在 unpack 中找到。

Raku 生态系统有一个模块 P5pack，它导出一个 pack 函数，尽可能地模仿原始 Perl 行为，并且支持的功能比实验性的 Raku 版本更多。

package§

  • package 命名空间

  • package 命名空间 版本

  • package 命名空间 块

  • package 命名空间 版本 块

S10 指示 package 可在 Raku 中使用，但只能与代码块一起使用。例如，package Foo { ... } 表示代码块中的代码将位于 Foo 包中。有一种特殊情况，如果文件中的第一个语句是 package Foo;，则表示该文件其余部分是 Perl 代码，但这种用法的实用性尚不清楚。事实上，由于模块和类是用不同的关键字（如 class）声明的，因此您不太可能在 Raku 中直接使用 package。

__PACKAGE__§

  • __PACKAGE__

已替换为 $?PACKAGE，它与 __PACKAGE__ 略有不同，因为它实际上是包对象。您应该在其上调用 .^name 方法以获取字符串。

Raku 生态系统有一个模块 P5__FILE__，它导出一个 __PACKAGE__ 术语，尽可能地模仿原始 Perl 行为。

pipe§

  • pipe READHANDLE, WRITEHANDLE

根据您的需求，请参阅 Channel 以在线程之间传递数据（以及 并发教程 以获取其他选项），或者参阅 Proc 类型以对进程进行管道传输。

pop§

  • pop ARRAY

在 Raku 中有效，也可以用作方法。例如，my $x = pop @a; 和 my $x = @a.pop; 是等效的。

pop 的无参数版本不存在。此外，如果数组为空，Raku 将返回一个 Failure，如果该值实际上在重要方面使用，则会抛出异常。

如果您在数组中只使用已定义的值，则可以使用 with 函数来处理这种情况。

with pop @array -> $popped {
    say "popped '$popped' of the array";
}
else {
    say "there was nothing to pop";
}

Raku 生态系统有一个模块 P5push，它导出一个 pop 函数，尽可能地模仿原始 Perl 行为。

pos§

  • pos SCALAR

在 Raku 中不可用。最接近的等效项是 :c 副词，如果 $/ 为真，则默认为 $/.to，否则为 0。有关 :c 的信息，请参阅 Continue。

print§

  • print FILEHANDLE LIST

  • print FILEHANDLE

  • print LIST

  • print

print 可用作 Raku 中的函数，写入标准输出。要将 print 用作具有文件句柄的函数，而不是标准输出，可以使用方法调用：$fh.print("howdy!")

Raku 生态系统有一个模块 P5print，它导出一个 print 函数，尽可能地模仿原始 Perl 行为。

printf§

  • printf FORMAT, LIST

  • printf

Raku 版本类似；有关可接受的格式指令的详细信息，请参阅 sprintf。要打印到除 STDOUT 之外的文件句柄，请使用该文件句柄上的 .printf 方法。

Raku 生态系统有一个模块 P5print，它导出一个 printf 函数，尽可能地模仿原始 Perl 行为。

prototype§

  • prototype FUNCTION

在 Raku 中不可用。最接近的等效项是 .signature。例如，say &sprintf.signature 的结果是 "(Cool $format, *@args)"。

push§

  • push ARRAY, LIST

与 Perl 中一样有效，也可以用作方法：@a.push("foo");。注意：Raku 中的扁平化行为不同：@b.push: @a 将 @a 作为单个元素推入 @b。另请参阅 append 方法。

还要注意，Raku 中的 push 返回被推入的数组，与 Perl 中返回新元素数量相反。

Raku 生态系统有一个模块 P5push，它导出一个 push 函数，尽可能地模仿原始 Perl 行为。

quoting§

  • q/STRING/

  • qq/STRING/

  • qw/STRING/

  • qx/STRING/

这些在迁移到 Raku 时仍然有效。一些注意事项

q/.../;  # is still equivalent to using single quotes.
qq/.../; # is still equivalent to using double quotes.
qw/.../; # is more commonly written as <...> in Raku.

正如在 引用 中解释的那样，有一些新增的引用结构和等价物。

  • qr/STRING/

已被 rx/.../ 替换。

  • quotemeta EXPR

没有直接的等价物，也就是说，没有直接返回字符串并将所有 ASCII 非单词字符反斜杠转义的函数。然而，在正则表达式中，使用 $foo 将把 $foo 视为字面字符串，而使用 <$foo> 将解释 $foo 的内容为正则表达式代码。请注意，尖括号在这里的作用与正则表达式之外不同。有关此方面的更多信息，请参见 https://design.raku.org/S05.html#Extensible_metasyntax_(%3C...%3E)

Raku 生态系统有一个模块 P5quotemeta，它导出一个 quotemeta 函数，尽可能地模拟原始 Perl 的行为。

rand§

  • rand EXPR

rand 本身的工作方式与 Perl 中相同，但你不能再给它传递参数。但是，你可以将其用作数字的方法来获得这种行为。例如，Perl 中的 rand(100) 等价于 Raku 中的 100.rand。此外，你可以使用类似 (^100).pick 的方法来获取随机整数。有关 为什么 你可以这样做，请参见 ^ 运算符 和 pick。

Raku 生态系统有一个模块 P5math，它导出一个 rand 函数，尽可能地模拟原始 Perl 的行为。

read§

  • read FILEHANDLE, SCALAR, LENGTH, OFFSET

read 在 Raku 中的 IO::Handle 和 IO::Socket 中找到。它从相关句柄或套接字读取指定数量的字节（而不是字符）。目前没有记录 Perl 中可用的偏移量使用方式。

readdir§

  • readdir DIRHANDLE

不是内置函数。要遍历目录的内容，请查看 dir 例程。

Raku 生态系统有一个模块 P5opendir，它导出一个 readdir 函数，尽可能地模拟原始 Perl 的行为。

readline§

  • readline

在 Raku 中不可用。你可能想要以某种方式使用 .lines 方法。有关从文件读取的更详细的信息，请参见 io。

  • readlink EXPR

似乎已从 Raku 中移除。在 IO::Path 中有一个 resolve 方法，如果操作系统/文件系统支持，它将跟踪符号链接。

Raku 生态系统有一个模块 P5readlink，它导出一个 readlink 函数，尽可能地模拟原始 Perl 的行为。

readpipe§

  • readpipe EXPR

  • readpipe

似乎在 Raku 中不起作用，但 qx// 是有效的，所以它可能隐藏在某个不明显的类中。

recv§

  • recv SOCKET, SCALAR, LENGTH, FLAGS

似乎在 IO::Socket 中。目前没有详细记录。

redo§

  • redo LABEL

  • redo EXPR

  • redo

在 Raku 中没有改变。

ref§

  • ref EXPR

已移除。引用 S29，“如果你真的想要类型名称，你可以使用 $var.WHAT.^name。”

Raku 生态系统有一个模块 P5ref，它导出一个 ref 函数，尽可能地模仿原始 Perl 的行为。

rename§

  • rename OLDNAME, NEWNAME

在 Raku 中仍然可用。

requires§

  • require VERSION

没有等效的替代方案。

reset§

  • reset EXPR

没有等效的替代方案。

Raku 生态系统有一个模块 P5reset，它导出一个 reset 函数，尽可能地模仿原始 Perl 的行为。

return§

  • return EXPR

似乎在 Raku 中可用，但没有明确的文档。

reverse§

  • reverse LIST

在 Raku 中，这只会反转列表的元素。reverse(@a) 或 @a.reverse。要反转字符串中的字符，请使用 .flip 方法。

reverse 不带参数在 Raku 中不受支持。

Raku 生态系统有一个模块 P5reverse，它导出一个 reverse 函数，尽可能地模仿原始 Perl 的行为。

rewinddir§

  • rewinddir DIRHANDLE

Raku 中不支持。

Raku 生态系统有一个模块 P5opendir，它导出一个 rewinddir 函数，尽可能地模仿原始 Perl 的行为。

rindex§

  • rindex STR, SUBSTR, POSITION

与 Perl 中的工作方式相同，也可以用作方法。例如 $x = "babaganush";say $x.rindex("a"); say $x.rindex("a", 3); # 5, 3。与 Perl 的主要区别在于，当未找到子字符串时，返回 Nil 而不是 -1。这在与 with 命令结合使用时非常有用。

with index("foo","o") -> $index {
    say "Found it at $index";
}
else {
    say "Not found"
}

Raku 生态系统有一个模块 P5index，它导出一个 rindex 函数，尽可能地模仿原始 Perl 的行为。

rmdir§

  • rmdir FILENAME

在 Raku 中工作，也可以用作方法。rmdir "Foo"; 和 "Foo".IO.rmdir; 等效。

s///§

  • s///

正则表达式语法在 Raku 中有所不同，但替换运算符存在。如果您尝试重写一些 Perl 代码，最重要的区别是 =~ 被智能匹配运算符 ~~ 替换。类似地，!~ 是 !~~。正则表达式运算符的选项是副词，并且很复杂。有关详细信息，请参阅 副词页面

say§

  • say FILEHANDLE

  • say LIST

  • say

say 可以用作函数，默认为标准输出。要将 say 用作带有文件句柄的函数，而不是标准输出，您需要在文件句柄后添加冒号。即 say $fh: "Howdy!"。冒号在这里用作“调用标记”的使用在 https://design.raku.org/S03.html#line_4019 中进行了讨论。或者，您可以使用方法调用：$fh.say("howdy!")

Raku 生态系统有一个模块 P5print，它导出一个 say 函数，尽可能地模仿原始 Perl 的行为。

scalar§

  • scalar EXPR

已消失。显然“非常”消失了。

为 CPAN Butterfly Plan 创建的一些模块的函数接受一个名为 :scalar 的命名参数，以指示需要函数的 scalar 行为。

seek§

  • seek FILEHANDLE, POSITION, WHENCE

目前尚未有详细的文档记录，但列为 IO::Handle 类的一种方法。

Raku 生态系统有一个模块 P5seek，它导出一个 seek 函数，尽可能地模仿原始 Perl 的行为。

seekdir§

  • seekdir DIRHANDLE, POS

Raku 中不支持。

Raku 生态系统有一个模块 P5opendir，它导出一个 seekdir 函数，尽可能地模仿原始 Perl 的行为。

select§

  • select FILEHANDLE

"[S]elect 作为全局概念已经不存在了。" 当我询问有关 select 的信息时，我被告知 $*OUT 等可以在动态作用域中被覆盖，并且 IO::Capture::Simple（位于 https://github.com/sergot/IO-Capture-Simple）可能对您使用 select 值所做的事情有所帮助。

semctl§

  • semctl ID, SEMNUM, CMD, ARG

不再是核心的一部分。

semget§

  • semget KEY, NSEMS, FLAGS

不再是核心的一部分。

semop§

  • semop KEY, OPSTRING

不再是核心的一部分。

send§

  • send SOCKET, MSG, FLAGS, TO

可以在 IO::Socket 类中找到。

setpgrp§

  • setpgrp PID, PGRP

不会实现。

Raku 生态系统有一个模块 P5getpriority，它导出一个 setpgrp 函数，尽可能地模仿原始 Perl 的行为。

setpriority§

  • setpriority WHICH, WHO, PRIORITY

不会实现。

Raku 生态系统有一个模块 P5getpriority，它导出一个 setpriority 函数，尽可能地模仿原始 Perl 的行为。

setsockopt§

  • setsockopt SOCKET, LEVEL, OPTNAME, OPTVAL

没有文档记录，但可能隐藏在某个 IO 类中。

shift§

  • shift ARRAY

  • shift EXPR

  • shift

在 Raku 中有效，也可以用作方法。例如，my $x = shift @a; 和 my $x = @a.shift; 是等效的。

shift 的无参数版本不存在。此外，如果数组为空，Raku 将返回一个 Failure，如果该值实际上在重要的方式中使用，则会抛出异常。

如果您在数组中只使用已定义的值，则可以使用 with 函数来处理这种情况。

with shift @array -> $shifted {
    say "shifted '$shifted' of the array";
}
else {
    say "there was nothing to shift";
}

Raku 生态系统有一个模块 P5shift，它导出一个 shift 函数，尽可能地模仿原始 Perl 的行为。

shm*§

  • shmctl ID, CMD, ARG

  • shmget KEY, SIZE, FLAGS

  • shmread ID, VAR, POS, SIZE

  • shmwrite ID, STRING, POS, SIZE

已从核心移除。可能会出现在某个模块中。

shutdown§

  • shutdown SOCKET, HOW

没有文档记录，但可能已移至 IO::Socket。

sin§

  • sin EXPR

与 Perl 中相同。

sin 在没有值的情况下也会对 $_ 进行操作，但不是作为函数，而作为方法，您需要将其称为 .sin 而不是简单的 sin。

Raku 生态系统有一个模块 P5math，它导出一个 sin 函数，尽可能地模仿原始 Perl 的行为。

sleep§

  • sleep EXPR

仍然与 Perl 中一样工作，但不再局限于秒的整数值。并且它始终返回 Nil。

如果您对 sleep 的返回值感兴趣，以确保睡眠到指定时间，那么您应该在 Raku 中使用 sleep-until（它接受一个 Instant）。

如果您有兴趣每隔 N 秒运行一些代码，并且您不关心它在哪个线程上运行，您可能应该使用 react 和 whenever 以及 Supply.interval。

Raku 生态系统有一个模块 P5sleep，它导出一个 sleep 函数，尽可能地模仿原始 Perl 的行为。

sockets§

  • socket SOCKET, DOMAIN, TYPE, PROTOCOL

  • socketpair SOCKET1, SOCKET2, DOMAIN, TYPE, PROTOCOL

目前没有记录，但可能会出现在 IO::Socket 中。

sort§

  • sort SUBNAME LIST

sort 在 Raku 中存在，但略有不同。$a 和 $b 不再是特殊的（参见 特殊变量），排序例程不再返回正整数、负整数或 0，而是返回 Order::Less、Order::Same 或 Order::More 对象。有关详细信息，请参见 sort。也可以用作方法，例如 sort(@a) 等效于 @a.sort。

splice§

  • splice ARRAY, OFFSET, LENGTH

  • splice ARRAY, OFFSET

  • splice ARRAY

  • splice EXPR, OFFSET, LENGTH, LIST

  • splice EXPR, OFFSET, LENGTH

  • splice EXPR, OFFSET

  • splice EXPR

在 Raku 中可用。也可以用作方法。splice(@foo, 2, 3, <M N O P>) 等效于 @foo.splice(2, 3, <M N O P>);。

split§

  • split /PATTERN/, EXPR, LIMIT

  • split /PATTERN/, EXPR

  • split /PATTERN/

大部分与 Perl 中一样工作。不过，有一些例外。要获得使用空字符串的特殊行为，您必须实际使用空字符串 - 空模式 // 被视为空字符串的特殊情况不适用。如果您对 split 使用正则表达式，它将使用正则表达式，而文字字符串将被视为文字。如果您希望将分隔符包含在结果列表中，您需要使用命名参数 :all，例如：split(';', "a;b;c", :all) # a ; b ; c 空块不会从结果列表中删除，就像它们在 Perl 中一样。对于该行为，请参见 comb。有关 split 的详细信息，请参见 此处。不出所料，split 现在也可用作方法："a;b;c".split(';')

  • split

split 现在需要一个模式。对于 Perl 在未指定模式时在空格上拆分的等效行为，请使用 words（或使用 split，模式为 /\s+/，命名参数为 :skip-empty）。

sprintf§

  • sprintf FORMAT, LIST

与 Perl 中一样工作。目前可用的格式为

%一个文字百分号
c具有给定代码点的字符
s一个字符串
d一个带符号的整数，以十进制表示
u一个无符号整数，以十进制表示
o无符号整数，八进制表示
x无符号整数，十六进制表示
e浮点数，科学计数法表示
f浮点数，定点小数表示
g浮点数，%e 或 %f 表示
X类似 x，但使用大写字母
E类似 e，但使用大写 "E"
G类似 g，但使用大写 "E"（如果适用）

兼容性

i%d 的同义词
D%ld 的同义词
U%lu 的同义词
O%lo 的同义词
F%f 的同义词

Perl（非）兼容性

n产生运行时异常
p产生运行时异常

整数有修饰符，但它们主要是不起作用的，因为语义尚未确定

h将整数解释为本机 "short"（通常为 int16）
l将整数解释为本机 "long"（通常为 int32 或 int64）
ll将整数解释为本机 "long long"（通常为 int64）
L将整数解释为本机 "long long"（通常为 uint64）
q将整数解释为本机 "quads"（通常为 int64 或更大）

sqrt§

  • sqrt EXPR

与 Perl 中相同。

sqrt 也可以在没有值的情况下对 $_ 进行操作，但不是作为函数，而作为方法，您需要将其调用为 .sqrt 而不是简单的 sqrt。

Raku 生态系统有一个模块 P5math，它导出一个 sqrt 函数，尽可能地模仿原始 Perl 行为。

srand§

  • srand EXPR

在 Raku 中可用。

stat§

  • stat EXPR

  • stat DIRHANDLE

  • stat

不太可能作为内置函数实现，因为它特定于 POSIX，但可以通过 NativeCall 接口使用。

state§

  • state VARLIST

  • state TYPE VARLIST

  • state VARLIST : ATTRS

  • state TYPE VARLIST : ATTRS

在 Raku 中可用，请参阅 state。

study§

  • study SCALAR

  • study

study 不再存在。

Raku 生态系统有一个模块 P5study，它导出一个 study 函数，尽可能地模仿原始 Perl 行为。

sub§

  • sub NAME BLOCK

  • sub NAME(PROTO) BLOCK

  • sub NAME : ATTRS BLOCK

  • sub NAME(PROTO) : ATTRS BLOCK

不出所料，我们仍然有子例程！您可以在子例程中使用签名，这允许您指定参数。但是，在没有签名的情况下（并且只有在没有签名的情况下），@_ 仍然包含传递给函数的内容。因此，理论上，如果您从 Perl 移植到 Raku，您不需要更改函数的这一方面（尽管您应该考虑使用签名的选项）。有关所有详细信息，请参阅 functions。

__SUB__§

  • __SUB__

被 &?ROUTINE 替换，它与 __SUB__ 略有不同，因为它实际上是 Sub（或 Method）对象。您应该在其上调用 .name 方法以获取字符串。

Raku 生态系统有一个模块 P5__FILE__，它导出一个 __SUB__ 术语，尽可能地模仿原始 Perl 行为。

substr§

  • substr EXPR, OFFSET, LENGTH, REPLACEMENT

参见 substr-rw。

可以用作函数或方法。不能用于 Str 字面量，因为它们是不可变的。

    my $a = 'Cheesy';
    $a.substr-rw(4,1)="k"; # returns 'k' 
    say $a; # OUTPUT: «Cheeky␤» 
 
    substr-rw($a, 0, 3) = "Lea";
    say $a; # OUTPUT: «Leaky␤» 

  • substr EXPR, OFFSET, LENGTH

  • substr EXPR, OFFSET

参见 substr。

可以用作函数或方法。substr("hola!", 1, 3) 和 "hola!".substr(1, 3) 都返回 "ola"。

  • symlink OLDFILE, NEWFILE

参见 symlink。

syscall§

  • syscall NUMBER, LIST

Raku 中没有内置函数。很可能在某个模块中，但目前尚不清楚在哪里。

sys*§

  • sysopen FILEHANDLE, FILENAME, MODE

  • sysopen FILEHANDLE, FILENAME, MODE, PERMS

  • sysread FILEHANDLE, SCALAR, LENGTH, OFFSET

  • sysread FILEHANDLE, SCALAR, LENGTH

  • sysseek FILEHANDLE, POSITION, WHENCE

与这些函数的非 sys 版本一样，可能潜伏在 IO 类中的某个地方。

system§

  • system LIST

  • system PROGRAM LIST

为此，您可能需要 (run) 或 (shell routine).

syswrite§

  • syswrite FILEHANDLE, SCALAR, LENGTH, OFFSET

  • syswrite FILEHANDLE, SCALAR, LENGTH

  • syswrite FILEHANDLE, SCALAR

与 sysopen 及其朋友一样，这已移入 IO 类。

tell§

  • tell FILEHANDLE

作为 IO::Handle 上的方法。

telldir§

  • telldir DIRHANDLE

Raku 中不支持。

Raku 生态系统有一个模块 P5opendir，它导出一个 telldir 函数，尽可能地模仿原始 Perl 行为。

tie§

  • tie VARIABLE, CLASSNAME, LIST

  • tied VARIABLE

Raku 中绑定标量的替代方法是 Proxy 容器。例如

sub lval() {
  Proxy.new(
    FETCH => method () { ...},
    STORE => method ($new) { ... }
  )
}

这使得 lval 成为一个左值子例程。每当请求值时，都会调用 FETCH 方法。每当它用于赋值时，都会调用 STORE 方法。

对于数组和哈希（执行 Positional 和/或 Associative 角色的对象），只需要提供这些角色需要的方法来获得 tie 在 Perl 中提供的功能。这些在“下标”部分有记录。

Raku 生态系统有一个模块 P5tie，它导出 tie / tied 函数，尽可能地模仿原始 Perl 行为。

time§

  • time

自纪元以来的秒数（作为 Int），与 Perl 中相同。

times§

  • times

Raku 中不可用。

Raku 生态系统有一个模块 P5times，它导出一个 times 函数，尽可能地模仿原始 Perl 行为。

tr///§

  • tr///

与 Perl 中的工作方式类似。唯一需要注意的是范围的指定方式不同。不要使用范围 "a-z"，而是使用 "a..z"，即使用 Perl 的范围运算符。在 Raku 中，tr/// 有一个方法版本，称为 trans，它提供了一些额外的功能。

Perl 的 /r 标志在 Raku 中实现为 TR/// 运算符。y/// 等效项不存在。

truncate§

  • truncate FILEHANDLE, LENGTH

  • truncate EXPR, LENGTH

目前尚未实现（2018.04）。

uc§

  • uc EXPR

既可以作为函数，也可以作为方法使用。uc("ha") 和 "ha".uc 都返回 "HA"。不支持无参数版本。

Raku 生态系统有一个模块 P5lc，它导出一个 uc 函数，尽可能地模拟原始 Perl 的行为。

ucfirst§

  • ucfirst EXPR

  • ucfirst

Raku 已经取消了 ucfirst。标题大小写函数 tc 或 tclc 可能可以满足你的需求；在第一种情况下，它执行“标题大小写”，这可能对应于不同字母表中的不同字符；如果没有标题大小写映射，它默认使用大写。另一方面，tclc 应用 tc，然后将其余字符转换为小写。

Raku 生态系统有一个模块 P5lcfirst，它导出一个 ucfirst 函数，尽可能地模拟原始 Perl 的行为。

undef§

  • undef EXPR

Raku 中没有 undef。你无法取消定义函数，最接近的等效值可能是 Nil，但你可能不会用到它。

如果你使用的是类似 (undef, $file, $line) = caller; 的语句，在 Raku 中你只需要直接获取文件名和行号，而不需要丢弃 caller 的第一个结果。caller 在 Raku 中已被 callframe 替换，因此等效语句为 ($file, $line) = callframe.annotations<file line>;

Raku 生态系统有一个模块 P5defined，它导出一个 undef 函数，尽可能地模拟原始 Perl 的行为。

  • unlink LIST

仍然可用。可以作为方法使用："filename".IO.unlink

  • unlink

Raku 中没有 unlink 的零参数（隐式 $_）版本。

unpack§

  • unpack TEMPLATE, EXPR

  • unpack TEMPLATE

在 Raku 中，当在需要调用 unpack 的作用域中指定了 use experimental :pack 时，unpack 可用。模板选项目前比 Perl 中的选项更受限制。当前的文档列表可以在 unpack 中找到。

Raku 生态系统有一个模块 P5pack，它导出一个 unpack 函数，尽可能地模拟原始 Perl 的行为，并且支持的功能比实验性的 Raku 版本更多。

unshift§

  • unshift ARRAY, LIST

  • unshift EXPR, LIST

与 Perl 中一样，也可以作为方法使用：@a.unshift("foo");。注意：Raku 中的扁平化行为有所不同：@b.unshift: @a 会将 @a 作为单个元素插入 @b 的开头。另请参阅 prepend 方法。

还要注意，Raku 中的 unshift 返回被插入的数组，而 Perl 中返回的是新元素的数量。

Raku 生态系统有一个模块 P5shift，它导出一个 unshift 函数，尽可能地模拟原始 Perl 的行为。

untie§

  • untie VARIABLE

Raku 中不支持，但请参阅 tie 以了解完整的故事。

Raku 生态系统有一个模块 P5tie，它导出一个 untie 函数，尽可能地模拟原始 Perl 的行为。

use§

  • use Module VERSION LIST

  • use Module VERSION

  • use Module LIST

  • use Module

  • use VERSION

在 Perl 中，这需要一个最小版本的 perl 可执行文件才能运行。在 Raku 中，这需要一个规范版本（例如 6.c），可以由各种 Raku 可执行文件实现。

utime§

  • utime LIST

没有等效的替代方案。

values§

  • values HASH

  • values ARRAY

  • values EXPR

在 Raku 中可用。也可以用作方法。values %hash 等同于 %hash.values。

vec§

  • vec EXPR, OFFSET, BITS

Raku 中不支持 vec()。

S29 说“应该用声明的 bit、uint2、uint4 等缓冲区/数组替换 vec”。对 bit、uint2、uint4 的支持尚未实现。但对 uint8、int8、uint16、int16、uint32、int32、uint64、int64 以及系统大小的 uint 和 int 的支持**已经**实现。在标量形式中，以及在数组和形状数组（也称为矩阵）形式中。

wait§

  • wait

[需要进一步研究] 不清楚它去了哪里。在 Supply 中有一个 wait 方法，在 Channel 和 Promise 中都有一个 await 方法。哪些（如果有的话）是 Perl 中 wait 的直接等效项尚不清楚。

waitpid§

  • waitpid PID, FLAGS

与 wait 一样，它的处理方式尚不清楚。

wantarray§

  • wantarray

Raku 中没有 wantarray；但是，有很多简单的方法可以涵盖 wantarray 填补的许多用例。

首先，由于 Raku 不需要特殊的引用语法来在 Scalar 中包含 List 或 Array，因此只需返回一个列表可能就足够了

sub listofstuff {
    return 1, 2, 3;
}
my $a = listofstuff();
print $a;                      # OUTPUT: «1 2 3» 
print join("<", listofstuff()) # OUTPUT: «1<2<3»

最常见的用例之一是提供一行或元素的数组，或者比简单打印数组产生的更漂亮的字符串。可以为此目的混合使用自定义 .Str 方法

sub prettylist(*@origlist) {
    @origlist but role {
        method Str { self.join("<") }
    }
}
print prettylist(1, 2, 3);            # OUTPUT: «1<2<3» 
print join(">", prettylist(3, 2, 1)); # OUTPUT: «3>2>1»

在上面的示例中，返回的列表可能是惰性的，并且 .Str 方法直到字符串化发生才被调用，因此不会做额外的工作来生成未要求的东西。

另一个用例是创建在空上下文（void context）中调用时是 mutator，但在赋值期间产生副本的方法。在 Raku 中通常认为这样做不是更好的形式，尤其是在 Raku 中不存在空上下文（void context）的情况下，最接近的等效项是接收上下文（sink context），因为用户可以使用 .= 运算符非常轻松地将任何产生副本的方法转换为 mutator

my $a = "foo\n";
$a.ords.say; # OUTPUT: «(102 111 111 10)␤» 
$a .= chomp;
$a.ords.say; # OUTPUT: «(102 111 111)␤»

但是，如果您执意要使用相同的函数名称来执行两种操作，您可以通过混合使用 .sink 方法来实现大部分功能，该方法将在结果处于接收上下文（sink context）时被调用。但是，有一些注意事项，因此再次建议不要这样做

multi increment($b is rw) {
    ($b + 1) does role { method sink { $b++ } }
}
multi increment($b) {
    $b + 1
}
my $a = 1;
increment($a);
say $a;                 # OUTPUT: «2␤» 
my $b = increment($a);
say "$a $b";            # OUTPUT: «2 3␤» 
# ...users will just have to be aware that they should not accidentally 
# sink a stored value later, though this requires some effort to 
# actually do: 
sub identity($c is rw) { $c };
$a = 1;
$b = increment($a);
identity($b);
$a.say;                 # OUTPUT: «2␤»

warn§

  • warn LIST

warn 抛出一个可恢复的异常。要简单地将消息打印到 $*ERR，可以使用 note 函数。有关异常的更多信息，请参见 异常。

write§

  • write FILEHANDLE

  • write EXPR

  • write

Raku 中已经没有格式了，所以这不再起作用。

y///§

  • y///

tr/// 的这个同义词已经不存在了。有关功能，请参阅 tr/// 的条目。