AnyMath 文档

基本要素

导言

Julia Base包含一系列适用于执行科学和数值计算的函数和宏，但也与许多通用编程语言一样广泛。 更多的功能可以从越来越多的https://julialang.org/packages/[可用的软件包]。 功能按以下主题分组。

一些一般注释:

*要使用模块功能，请使用 导入模块 要导入模块，以及 模块。fn(x) 要使用的功能。 *或者, 使用模块 将导入所有导出 模块 函数到当前命名空间。 *按照惯例，以感叹号结尾的函数名（!）修改他们的论点。 有些函数有两种修改（例如, 排序！）和非修改（排序）版本。

的行为 基地 标准库是稳定的，如https://semver.org/[SemVer]只有当他们被记录;即，包括在https://docs.julialang.org/[Julia文档]并且没有标记为不稳定。 见 API常见问题了解更多信息。

四处游荡

exit(code=0)

用退出代码停止程序。 默认退出代码为零，表示程序成功完成。 在交互式会话中, 出口() 可以用键盘快捷键调用 ^D.

atexit(f)

注册一个零参数或一参数函数 f() 在进程退出时被调用。 atexit() 钩子按后进先出（LIFO）顺序调用，并在对象终结器之前运行。

如果 f 有一个为一个整数参数定义的方法，它将被称为 f(n::Int32)，在哪里 n 是当前退出代码，否则将调用为 f().

兼容性

Julia1.9单参数形式要求Julia1.9

允许调用退出挂钩 出口(n)，在这种情况下，Julia将以退出代码退出 n （而不是原来的退出代码）。 如果多个退出挂钩调用 出口(n)，然后Julia将使用与调用的最后一个调用的exit钩子对应的exit代码退出 出口(n). （因为exit钩子是按LIFO顺序调用的，所以"last called"相当于"first registered"。)

注意：一旦调用了所有的退出钩子，就不能注册更多的退出钩子，并且任何调用 atexit(f) 所有钩子完成后会抛出异常。 如果您正在注册可能仍在关闭期间并发执行的后台任务的退出挂钩，则可能会出现这种情况。

isinteractive() -> Bool

确定Julia是否正在运行交互式会话。

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

计算从参数可访问的所有唯一对象使用的内存量（以字节为单位）。

关键字参数

  • 排除在外:指定要从遍历中排除的对象类型。

  • 收费:指定对象的类型，以始终计算其所有字段的大小，即使这些字段通常被排除在外。

请参阅 大小；大小.

例子

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8

# 基地。__预编译__-函数

__precompile__(isprecompilable::Bool)

指定调用此函数的文件是否可预编译，默认为 真的. 如果一个模块或文件是_not_安全可预编译的，它应该调用 __预编译__(false) 为了抛出一个错误，如果朱莉娅试图预编译它。

Base.include([mapexpr::Function,] m::Module, path::AbstractString)

在模块的全局范围内评估输入源文件的内容 m. 每个模块（除了那些定义与 裸模,裸模）有自己的定义 包括 省略 m 参数，它计算该模块中的文件。 返回输入文件的最后一个计算表达式的结果。 在包含过程中，任务本地包含路径设置为包含文件的目录。 嵌套调用 包括 将相对于该路径进行搜索。 此函数通常用于以交互方式加载源，或组合被分解为多个源文件的包中的文件。

可选的第一个参数 地图表达 可用于在计算包含的代码之前对其进行转换：对于每个解析的表达式 expr 在 路径,的 包括 函数实际计算 地图表达(expr). 如果省略, 地图表达 默认值为 身份认同.

兼容性

茱莉亚1.5茱莉亚1.5是通过 地图表达 争论。

 
include([mapexpr::Function,] path::AbstractString)

在包含模块的全局范围内评估输入源文件的内容。 每个 模块 （定义为 裸模,裸模）有一个私有的1参数定义 包括，它评估该模块中的文件，以便在该模块中使用。 返回输入文件的最后一个计算表达式的结果。 在包含过程中，任务本地包含路径设置为包含文件的目录。 嵌套调用 包括 将相对于该路径进行搜索。 此函数通常用于以交互方式加载源，或组合被分解为多个源文件的包中的文件。 论点 路径 被归一化使用 规范路径这将解析相对路径令牌，如 .. 并转换 / 到适当的路径分隔符。

可选的第一个参数 地图表达 可用于在计算包含的代码之前对其进行转换：对于每个解析的表达式 expr 在 路径,的 包括 函数实际计算 地图表达(expr). 如果省略, 地图表达 默认值为 身份认同.

使用方法 基地。包括评估一个文件到另一个模块。

注意Julia的语法降低识别对文字的显式调用 包括 在顶层并插入一个隐式 @核心。最新世界 使任何include定义对后续代码可见。 但是请注意，此识别是_syntactic_。 即分配 const myinclude=包括 可能需要和明确 @核心。最新世界 电话后 我的前奏.
兼容性

茱莉亚1.5茱莉亚1.5是通过 地图表达 争论。

 
include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")

像 包括，除了从给定的字符串而不是从文件中读取代码。

可选的第一个参数 地图表达 可用于在计算包含的代码之前对其进行转换：对于每个解析的表达式 expr 在 密码,的 include_string 函数实际计算 地图表达(expr). 如果省略, 地图表达 默认值为 身份认同.

兼容性

茱莉亚1.5茱莉亚1.5是通过 地图表达 争论。

 
include_dependency(path::AbstractString; track_content::Bool=true)

在模块中，声明由 路径 （相对或绝对）是预编译的依赖项;也就是说，如果 track_content=true 该模块将需要重新编译，如果内容 路径 更改（如果 路径 是内容等于的目录 join(readdir(path))). 如果 track_content=false 修改时间时触发重新编译 m时间 的 路径 变化。

只有当您的模块依赖于不使用via的路径时，才需要这样做 包括. 它在编译之外没有任何影响。

兼容性

Julia1.11关键字参数 跟踪_content 至少需要Julia1.11。 现在抛出一个错误，如果 路径 是不可读的。

# __init__-密码_

__init__

该 __init__() 模块中的函数立即执行_after_模块在运行时首次加载。 在模块中的所有其他语句执行完毕后，它被调用一次。 因为它是在完全导入模块后调用的, __init__ 子模块的功能将首先执行。 两个典型的用途 __init__ 正在调用外部C库的运行时初始化函数，并初始化涉及外部库返回的指针的全局常量。 查看 关于模块的手册部分了解更多细节。

请参阅: 一次处理.

例子

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end
OncePerProcess{T}(init::Function)() -> T

打电话给 一次处理 对象返回类型的值 T 通过运行函数 初始化器 每个过程只需一次。 同一进程中的所有并发和未来调用将返回完全相同的值。 这在将被预编译的代码中很有用，因为它允许设置缓存或其他不会被序列化的状态。

兼容性

Julia1.12这种类型需要Julia1.12或更高版本。

例子

julia> const global_state = Base.OncePerProcess{Vector{UInt32}}() do
           println("Making lazy global value...done.")
           return [Libc.rand()]
       end;

julia> (procstate = global_state()) |> typeof
Making lazy global value...done.
Vector{UInt32} (alias for Array{UInt32, 1})

julia> procstate === global_state()
true

julia> procstate === fetch(@async global_state())
true
OncePerTask{T}(init::Function)() -> T

打电话给 OncePerTask 对象返回类型的值 T 通过运行函数 初始化器 每个任务只需一次。 同一任务中的所有未来调用将返回完全相同的值。

请参阅: 任务_local_storage.

兼容性

Julia1.12这种类型需要Julia1.12或更高版本。

例子

julia> const task_state = Base.OncePerTask{Vector{UInt32}}() do
           println("Making lazy task value...done.")
           return [Libc.rand()]
       end;

julia> (taskvec = task_state()) |> typeof
Making lazy task value...done.
Vector{UInt32} (alias for Array{UInt32, 1})

julia> taskvec === task_state()
true

julia> taskvec === fetch(@async task_state())
Making lazy task value...done.
false
OncePerThread{T}(init::Function)() -> T

打电话给 一旦线程 对象返回类型的值 T 通过运行函数 初始化器 每个线程正好一次。 同一线程中的所有未来调用以及具有相同线程id的并发或未来调用将返回完全相同的值。 对象也可以由任何现有线程的threadid索引，以获取（或初始化_on this thread_）为该线程存储的值。 不正确的使用可能会导致数据竞争或内存损坏，因此仅当该行为在库的线程安全设计中是正确的时才使用。

警告一个任务只在一个线程上运行并不一定是真的，因此这里返回的值可能会别名其他值或在程序中间发生变化。 此函数将来可能会被弃用。 如果初始值设定项产生，则在调用后运行当前任务的线程可能与调用开始时的线程不同。

请参阅: OncePerTask.

兼容性

Julia1.12这种类型需要Julia1.12或更高版本。

例子

julia> const thread_state = Base.OncePerThread{Vector{UInt32}}() do
           println("Making lazy thread value...done.")
           return [Libc.rand()]
       end;

julia> (threadvec = thread_state()) |> typeof
Making lazy thread value...done.
Vector{UInt32} (alias for Array{UInt32, 1})

julia> threadvec === fetch(@async thread_state())
true

julia> threadvec === thread_state[Threads.threadid()]
true
which(f, types)

返回 f （一 方法 对象），将被调用为给定的参数 类别.

如果 类别 是一个抽象类型，那么将被调用的方法 调用 被退回。

请参阅: [医父母模式], @哪个，和 @编辑.

methods(f, [types], [module])

返回方法表 f.

如果 类别 被指定，返回一个类型匹配的方法数组。 如果 模块 被指定，返回在该模块中定义的方法数组。 模块列表也可以指定为数组或集合。

兼容性

Julia1.4指定模块至少需要Julia1.4。

请参阅: 其中, @哪个和 方法，方法.

@show exs...

将一个或多个表达式及其结果打印到 标准输出，并返回最后一个结果。

请参阅: 展览, @资讯, 打印,打印.

例子

julia> x = @show 1+2
1 + 2 = 3
3

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5
ans

引用最后一个计算值的变量，自动导入到交互式提示中。

err

引用上次抛出的错误的变量，自动导入到交互式提示中。 抛出的错误收集在异常堆栈中。

active_project()

返回活动的路径 工程。汤姆尔 档案。 请参阅 基地。set_active_project.

set_active_project(projfile::Union{AbstractString,Nothing})

设置活动 工程。汤姆尔 档案至 项目文件. 请参阅 基地。活动_项目.

兼容性

Julia1.8此功能至少需要Julia1.8。

关键词

这是Julia中的保留关键字列表: 裸模,裸模, 開始啦。, 休息, 渔获, 康斯特, 继续, 做, 其他, 埃尔塞夫, 结束, 出口, 错误, 最后, 为, 功能, 全球, 如果, 进口, 让, 本地, 宏, 模块, 报价, 回来吧, 结构体, 真的, 试试, 使用, 而. 这些关键字不允许用作变量名。

保留以下两个字序列: 抽象类型, 可变结构, 原始类型. 但是，您可以使用名称创建变量: 摘要, 可变的, 原始的 和 类型.

最后: 哪里 被解析为中缀运算符，用于编写参数化方法和类型定义; 在 和 伊萨 被解析为中缀运算符; 公众人士 在开始toplevel语句时被解析为关键字; 外，外 在迭代规范中用于修改变量的范围时，被解析为关键字 为 循环；以及 作为 用作关键字来重命名带入范围的标识符 进口 或 使用. 创建命名的变量 哪里, 在, 伊萨, 外，外 和 作为 不过是允许的。

module

模块 声明a 模块，这是一个单独的全局变量工作区。 在模块中，您可以控制其他模块的哪些名称是可见的（通过导入），并指定哪些名称是公开的（通过 出口 和 公众人士). 模块允许您创建顶级定义，而不必担心当您的代码与其他人的代码一起使用时的名称冲突。 关于模块的手册部分了解更多细节。

例子

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end
export

出口 在模块中用于告诉Julia哪些名字应该提供给用户。 例如: 出口食品 使名称 [医]脚 可于 使用的模块。 查看 关于模块的手册部分有关详细信息。

public

公众人士 在模块中用于告诉Julia哪些名称是模块公共API的一部分。 例如: 公共食物 表示名称 [医]脚 是公开的，而不是在 使用的模块。

作为 出口已经表明一个名称是公共的，这是不必要的，并且将一个名称声明为 公众人士 而作为 出口艾迪 查看 关于模块的手册部分有关详细信息。

兼容性

Julia1.11在Julia1.11中添加了public关键字。 在此之前，公开性的概念不那么明确。

 
import

进口食物 将加载模块或包 [医]脚. 导入的名称 [医]脚 模块可以用点语法访问（例如 Foo。[医]脚 访问名称 [医]脚). 查看 关于模块的手册部分有关详细信息。

using

使用Foo 将加载模块或包 [医]脚 并使其 出口可直接使用的ed名称。 名称也可以通过点语法使用（例如 Foo。[医]脚 访问名称 [医]脚），无论它们是 出口爱德与否。 查看 关于模块的手册部分有关详细信息。

请注意，当两个或多个包/模块导出一个名称时，该名称在每个包中不引用相同的东西，并且这些包是通过 使用 如果没有明确的名称列表，则在没有限定的情况下引用该名称是错误的。 因此，建议打算向前兼容其依赖项和Julia的未来版本的代码，例如发布包中的代码，列出它在每个加载包中使用的名称，例如, 使用Foo:Foo,f 而不是 使用Foo.

 
as

作为 用作关键字来重命名带入范围的标识符 进口 或 使用，用于解决名称冲突以及缩短名称。 （外 进口 或 使用 声明, 作为 不是关键字，可以用作普通标识符。)

将LinearAlgebra导入为LA 带来进口的 线性代数 标准库纳入范围为 洛杉矶.

导入LinearAlgebra：eigen作为eig，cholesky作为chol 带来 本征 和 乔莱斯基 方法从 线性代数 范围为 eig 和 卓尔 分别。

作为 与 使用 只有当个别标识符被带入范围时。 例如, 使用LinearAlgebra：eigen作为eig 或 使用LinearAlgebra：eigen作为eig，cholesky作为chol 有效，但是 使用LinearAlgebra作为LA 是无效的语法，因为重命名_all_导出的名称是无意义的 线性代数 到 洛杉矶.

baremodule

裸模,裸模 声明不包含的模块 使用基地 或本地定义 埃瓦尔和 包括. 它仍然进口 核心. 换句话说,

module Mod

...

end

相当于

baremodule Mod

using Base

eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)

...

end
function

函数定义为 功能 关键字:

function add(a, b)
    return a + b
end

或简写符号:

add(a, b) = a + b

使用 回来吧关键字与其他语言完全相同，但通常是可选的。 没有显式的函数 回来吧 语句将返回函数体中的最后一个表达式。

macro

宏 定义将生成的代码插入到程序中的方法。 宏将参数表达式序列映射到返回的表达式，并在调用宏时将生成的表达式直接替换到程序中。 宏是一种无需调用即可运行生成代码的方法 埃瓦尔，因为生成的代码反而简单地成为周围程序的一部分。 宏参数可以包括表达式、文字值和符号。 宏可以为可变数量的参数（varargs）定义，但不接受关键字参数。 每个宏也隐式传递参数 __来源__，其中包含宏从中调用的行号和文件名，以及 __模块__，这是宏展开的模块。

请参阅手册部分 元编程有关如何编写宏的更多信息。

例子

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (macro with 1 method)

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (macro with 1 method)

julia> @saylots "hey " "there " "friend"
Say: hey there friend
return

返回x 导致封闭函数提前退出，传递给定值 x 回到呼叫者那里。 回来吧 本身没有价值相当于 什么也不退货 （见 什么都没有).

function compare(a, b)
    a == b && return "equal to"
    a < b ? "less than" : "greater than"
end

一般来说，你可以放置一个 回来吧 语句在函数体内的任何地方，包括深度嵌套的循环或条件，但要小心 做 街区。 例如:

function test1(xs)
    for x in xs
        iseven(x) && return 2x
    end
end

function test2(xs)
    map(xs) do x
        iseven(x) && return 2x
        x
    end
end

在第一个例子中，返回打破了 测试1 只要它击中一个偶数，所以 测试1([5,6,7]) 申报表 12.

您可能期望第二个例子的行为方式相同，但实际上 回来吧 只有_inner_函数（在 做 块）并给出一个值回 地图. 测试2([5,6,7]) 然后返回 [5,12,7].

在顶级表达式中使用时（即在任何函数之外）, 回来吧 导致整个当前顶级表达式提前终止。

do

创建一个匿名函数并将其作为第一个参数传递给函数调用。 例如:

map(1:10) do x
    2x
end

相当于 地图(x->2x,1:10).

像这样使用多个参数:

map(1:10, 11:20) do x, y
    x + y
end
begin

开始。..结束 表示代码块。

begin
    println("Hello, ")
    println("World!")
end

通常情况下 開始啦。 不会是必要的，因为关键字如 功能和 让隐式开始代码块。 请参阅 ;.

開始啦。 索引时也可以用来表示集合的第一个索引或数组的维数的第一个索引。 例如, a[开始] 是数组的第一个元素 a.

兼容性

Julia1.4使用 開始啦。 作为索引需要Julia1.4或更高版本。

例子

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[begin, :]
2-element Matrix{Int64}:
 1
 2
end

结束 标记表达式块的结论，例如 模块, 结构体, 可变结构, 開始啦。, 让, 为等。

结束 索引时也可用于表示集合的最后一个索引或数组维度的最后一个索引。

例子

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[end, :]
2-element Vector{Int64}:
 3
 4
let

让 块创建一个新的硬作用域，并可选地引入新的本地绑定。

就像 其他范围构造, 让 块定义新引入的局部变量可访问的代码块。 此外，该语法对于逗号分隔的赋值和变量名具有特殊含义，这些变量名可以选择性地出现在与 让:

let var1 = value1, var2, var3 = value3
    code
end

这一行引入的变量是本地的 让 块和赋值按顺序计算，每个右侧在作用域中计算，而不考虑左侧的名称。 因此，写一些像这样的东西是有意义的 设x=x，自二 x 变量是不同的，左侧局部阴影 x 从外部范围。 这甚至是一个有用的习惯用法，因为每次输入局部范围时都会新创建新的局部变量，但这只有在通过闭包超出其范围的变量的情况下才能观察到。 A 让 没有赋值的变量，例如 var2 在上面的示例中，声明了一个尚未绑定到值的新局部变量。

相比之下, 開始啦。块还将多个表达式组合在一起，但不引入范围或具有特殊的赋值语法。

例子

在下面的函数中，有一个单 x 这是迭代更新三次由 地图. 闭包返回了所有引用 x 在其最终价值:

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

但是，如果我们添加一个 让 引入_new_局部变量的块我们最终将捕获三个不同的变量（每次迭代一个），即使我们选择使用（阴影）相同的名称。

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

所有引入新局部变量的范围构造在重复运行时都以这种方式运行； 让 它是否有能力简洁地宣布新的 本地可能会影响同名外部变量的s。 例如，直接使用 做 函数类似地捕获三个不同的变量:

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3
if/elseif/else

如果/埃尔塞夫/其他 执行条件求值，这允许根据布尔表达式的值对代码部分进行求值或不求值。 以下是 如果/埃尔塞夫/其他 条件语法:

if x < y
    println("x is less than y")
elseif x > y
    println("x is greater than y")
else
    println("x is equal to y")
end

如果条件表达式 x<y 为真，则计算相应的块；否则条件表达式 x>y 被评估，如果为真，则对相应的块进行评估；如果两个表达式都不为真，则 其他 块进行评估。 该 埃尔塞夫 和 其他 块是可选的，并且尽可能多 埃尔塞夫 可以使用所需的块。

与其他一些语言相反，条件必须是类型的 布尔. 条件可转换为 布尔.

julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean context
for

为 循环在迭代值序列时重复计算语句块。

迭代变量始终是一个新变量，即使封闭作用域中存在同名变量也是如此。 使用方法 外，外重用现有的局部变量进行迭代。

例子

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0
while

而 循环重复计算条件表达式，并继续计算while循环的主体，只要表达式保持为真。 如果第一次到达while循环时条件表达式为false，则永远不会计算主体。

例子

julia> i = 1
1

julia> while i < 5
           println(i)
           global i += 1
       end
1
2
3
4
break

立即跳出一个循环。

例子

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5
continue

跳过当前循环迭代的其余部分。

例子

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5
try/catch

A 试试/渔获 语句允许拦截错误（异常）抛出 投掷以便程序执行可以继续。 例如，下面的代码尝试写入一个文件，但警告用户，并继续，而不是终止执行，如果文件无法写入:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Could not write file."
end

或者，当文件无法读入变量时:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "File not found."
end

语法 捉e （哪里 e 是任何变量）将抛出的异常对象分配给给定的变量内 渔获 块。

的力量 试试/渔获 构造在于能够将深度嵌套的计算立即展开到调用函数堆栈中更高的级别。

A 尝试/捕捉 块也可以有一个 其他 仅在未发生异常时执行的子句:

try
    a_dangerous_operation()
catch
    @warn "The operation failed."
else
    @info "The operation succeeded."
end

A 试试 或 试试/渔获 块也可以有一个 最后 结束时执行的子句，而不管是否发生异常。 例如，这可以用来保证打开的文件被关闭:

f = open("file")
try
    operate_on_file(f)
catch
    @warn "An error occurred!"
finally
    close(f)
end

(最后 也可以在没有 渔获 块。)

兼容性

Julia1.8Else子句至少需要Julia1.8。

 
finally

在给定的情况下运行一些代码 试试 代码块退出，无论它如何退出。 例如，以下是我们如何保证打开的文件被关闭的方法:

f = open("file")
try
    operate_on_file(f)
finally
    close(f)
end

当控制离开 试试块（例如，由于一 回来吧，或者只是正常完成）, 关闭(f)将被执行。 如果 试试 块由于异常而退出，异常将继续传播。 A 渔获 块可与 试试 和 最后 ""好吧。 在这种情况下， 最后 块将运行后 渔获 已经处理了错误。

quote

报价 在一个块中创建多个表达式对象，而不使用显式 Expr构造函数。 例如:

ex = quote
    x = 1
    y = 2
    x + y
end

与其他引用方式不同, :( ... )，本表格介绍 报价/报价 表达式树的元素，直接操作树时必须考虑这些元素。 作其他用途, :( ... ) 和 报价。. 结束 块进行同等处理。

local

本地 引入一个新的局部变量。 查看 关于变量范围的手册部分以获取更多信息。

例子

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # introduce a loop-local x
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0
global

全球x 使 x 在当前作用域及其内部作用域中，引用该名称的全局变量。 查看 关于变量范围的手册部分以获取更多信息。

例子

julia> z = 3
3

julia> function foo()
           global z = 6 # use the z variable defined outside foo
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6
for outer

重用现有的局部变量，以便在 为 循环。

查看 关于变量范围的手册部分以获取更多信息。

请参阅 为.

例子

julia> function f()
           i = 0
           for i = 1:3
               # empty
           end
           return i
       end;

julia> f()
0
julia> function f()
           i = 0
           for outer i = 1:3
               # empty
           end
           return i
       end;

julia> f()
3
julia> i = 0 # global variable
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]
const

康斯特 用于声明值不会更改的全局变量。 在几乎所有代码（特别是性能敏感的代码）中，全局变量都应该以这种方式声明为常量。

const x = 5

可以在单个变量中声明多个变量 康斯特:

const y, z = 7, 11

请注意 康斯特 只适用于一个 = 操作，因此 const x=y=1 声明 x 保持不变，但不是 y. 另一方面, const x=const y=1 声明两者 x 和 y 不变。

请注意，"constant-ness"不会扩展到可变容器中;只有变量与其值之间的关联是常量。 如果 x 是数组或字典（例如），您仍然可以修改，添加或删除元素。

在某些情况下，更改a的值 康斯特 变量给出警告而不是错误。 但是，这可能会产生不可预测的行为或破坏程序的状态，因此应该避免。 此功能仅用于方便交互使用。

struct

Julia中最常用的类型是结构体，指定为名称和一组字段。

struct Point
    x
    y
end

字段可以有类型限制，可以参数化:

struct Point{X}
    x::X
    y::Float64
end

结构体也可以通过 <: 语法:

struct Point <: AbstractPoint
    x
    y
end

结构体默认情况下，s是不可变的；构造后不能修改这些类型之一的实例。 使用方法 可变结构而是声明一个实例可以被修改的类型。

请参阅手册部分 复合类型了解更多细节，例如如何定义构造函数。

mutable struct

可变结构 类似于 结构体，但另外允许在构造后设置类型的字段。

可变结构的各个字段可以标记为 康斯特 使它们不可变:

mutable struct Baz
    a::Int
    const b::Float64
end
兼容性

朱莉娅1.8 康斯特 可变结构域的关键字至少需要Julia1.8。

请参阅手册部分 复合类型以获取更多信息。

@kwdef typedef

这是一个帮助器宏，它自动为表达式中声明的类型定义基于关键字的构造函数 打字,打字，这必须是一个 结构体 或 可变结构 表达。 默认参数是通过声明表单的字段来提供的 字段::T=默认值 或 字段=默认值. 如果未提供默认值，则关键字参数将成为结果类型构造函数中的必需关键字参数。

内部构造函数仍然可以定义，但至少有一个应该接受与默认内部构造函数相同形式的参数（即每个字段一个位置参数），以便与关键字外部构造函数正确

兼容性

朱莉娅1.1 基地。@kwdef 对于参数结构体和超类型结构体至少需要Julia1.1。
兼容性

Julia1.9此宏从Julia1.9导出。

例子

julia> @kwdef struct Foo
           a::Int = 1         # specified default
           b::String          # required keyword
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
[...]
abstract type

抽象类型 声明一个不能实例化的类型，并且只作为类型图中的一个节点，从而描述相关的具体类型集：这些具体类型是它们的后代。 抽象类型构成了概念层次结构，这使得Julia的类型系统不仅仅是一个对象实现的集合。 例如:

abstract type Number end
abstract type Real <: Number end

电话号码没有超类型，而 真实的是一个抽象的子类型 电话号码.

primitive type

原始类型 声明一个具体类型，其数据仅由一系列位组成。 基本类型的经典示例是整数和浮点值。 一些内置基元类型声明的示例:

primitive type Char 32 end
primitive type Bool <: Integer 8 end

名称后面的数字表示该类型需要多少位存储。 目前，仅支持8位倍数的大小。 该 布尔声明显示如何可以选择性地将基元类型声明为某个超类型的子类型。

where

该 哪里 关键字创建 联合所有类型，它可以被认为是其他类型的迭代联合，在某些变量的所有值上。 例如 向量{T} 其中T<:Real 包括所有 向量资料s其中元素类型是某种 真实的 数字。

变量绑定默认为 任何如果省略:

Vector{T} where T    # short for `where T<:Any`

变量也可以有下限:

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

嵌套还有一个简洁的语法 哪里 表情。 例如，这:

Pair{T, S} where S<:Array{T} where T<:Number

可缩短至:

Pair{T, S} where {T<:Number, S<:Array{T}}

这种形式通常在方法签名上找到。

请注意，在这种形式中，变量首先列在最外层。 这与使用语法将类型"应用"到参数值时替换变量的顺序相匹配 T{p1, p2, ...}.

...

"Splat"操作员, ...，表示参数序列。 ... 可用于函数定义，以指示函数接受任意数量的参数。 ... 也可用于将函数应用于参数序列。

例子

julia> add(xs...) = reduce(+, xs)
add (generic function with 1 method)

julia> add(1, 2, 3, 4, 5)
15

julia> add([1, 2, 3]...)
6

julia> add(7, 1:100..., 1000:1100...)
111107
;

分号用作语句分隔符，并在函数声明或调用中标记关键字参数的开头。

=

= 是赋值运算符。

*对于变量 a 和表达 b, a=b 使 a 参考的值 b. *对于功能 f(x), f(x)=x 定义一个新的函数常量 f，或者将新方法添加到 f 如果 f 已定义；此用法等效于 函数f(x);x;结束. * a[i]=v 电话 （a，v，i）. * a.b=c 电话 xref:base/base.adoc#Base.setproperty!(a,:b,c). *函数调用内部, f（a=b） 通行证 b 作为关键字参数的值 a. *带逗号的括号内, （a=1，） 构造a xref:base/base.adoc#Core.NamedTuple" class="xref page">命名的,命名的.

例子

分配；分配 a 到 b 不创建的副本 b;而是使用 副本或 深镜,深镜.

julia> b = [1]; a = b; b[1] = 2; a
1-element Vector{Int64}:
 2

julia> b = [1]; a = copy(b); b[1] = 2; a
1-element Vector{Int64}:
 1

传递给函数的集合也不会被复制。 函数可以修改（改变）其参数引用的对象的内容。 （执行此操作的函数的名称通常以'！'.)

julia> function f!(x); x[:] .+= 1; end
f! (generic function with 1 method)

julia> a = [1]; f!(a); a
1-element Vector{Int64}:
 2

赋值可以并行地对多个变量进行操作，从可迭代的变量中获取值:

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

赋值可以对串联的多个变量进行操作，并将返回最右边的表达式的值:

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Vector{Int64}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

对越界索引的赋值不会增加集合。 如果集合是 向量资料相反，它可以与 推！或 追加！.

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Vector{Int64} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Vector{Int64}:
 1
 1
 2
 3

分配；分配 [] 不从集合中消除元素；而是使用 过滤器！.

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch: tried to assign 0 elements to 1 destinations
[...]

julia> filter!(x -> x > 1, a) # in-place & thus more efficient than a = a[a .> 1]
2-element Vector{Int64}:
 2
 3
a ? b : c

条件的简短形式;阅读"如果 a，评估 b 否则评估 c". 也称为https://en.wikipedia.org/wiki/%3F：[三元运算符]。

此语法等效于 如果a;b;c结束，但经常被用来强调价值 b-或-c 它被用作更大表达式的一部分，而不是评估的副作用 b 或 c 可能有。

请参阅手册部分 控制流程了解更多详情。

例子

julia> x = 1; y = 2;

julia> x > y ? println("x is larger") : println("x is not larger")
x is not larger

julia> x > y ? "x is larger" : x == y ? "x and y are equal" : "y is larger"
"y is larger"
.=

执行广播分配。 右边的参数被扩展为 广播然后就地分配到左侧参数中。 与同一表达式中的其他虚线运算符融合;即整个赋值表达式转换为单个循环。 A.=B 类似于 广播！（身份，A，B）.

例子

julia> A = zeros(4, 4); B = [1, 2, 3, 4];

julia> A .= B
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 2.0  2.0  2.0  2.0
 3.0  3.0  3.0  3.0
 4.0  4.0  4.0  4.0

julia> A
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 2.0  2.0  2.0  2.0
 3.0  3.0  3.0  3.0
 4.0  4.0  4.0  4.0
.

点运算符用于访问对象的字段或属性以及访问模块内部定义的变量。

一般说来, a.b 电话 getproperty(a,:b) （见 获得财产).

例子

julia> z = 1 + 2im; z.im
2

julia>迭代器。产品
产品（具有1方法的通用函数）

# ->-密码_

x -> y

创建匿名函数映射参数 x 到功能体 y.

julia> f = x -> x^2 + 2x - 1
#1 (generic function with 1 method)

julia> f(2)
7

也可以为多个参数定义匿名函数。

julia> g = (x,y) -> x^2 + y^2
#2 (generic function with 1 method)

julia> g(2,3)
13

请参阅手册部分 匿名函数了解更多详情。

::

该 :: operator要么声明值具有给定类型，要么声明局部变量或函数返回始终具有给定类型。

给出 表达式::T, 表达方式 首先进行评估。 如果结果是类型 T，值简单返回。 否则，一个 打字错误被抛出。

在局部作用域中，语法 本地x::T 或 x::T=表达式 声明该局部变量 x 总是有类型 T. 当一个值被赋给变量时，它将被转换为类型 T 通过调用 转换/转换.

在方法声明中，语法 函数f(x)::T 导致方法返回的任何值转换为类型 T.

请参阅手册部分 类型声明。

例子

julia> (1+2)::AbstractFloat
ERROR: TypeError: typeassert: expected AbstractFloat, got a value of type Int64

julia> (1+2)::Int
3

julia> let
           local x::Int
           x = 2.0
           x
       end
2

基本要素[#] []-密码_

[]

方括号用于 索引(getindex,getindex), 索引分配(setindex！), 数组文字(基地。矢量,矢量), 数组连接(vcat的, hcat,hcat, [医hvcat], [医hvncat])，以及 数组理解(收集资料).

标准模块

Main

主要 是顶层模块，Julia从 主要 置为当前模块。 在提示符下定义的变量进入 主要，而 varinfo的 列出变量 主要.

julia> @__MODULE__
Main
Core

核心 包含被认为是语言"内置"的所有标识符的模块，即核心语言的一部分，而不是库。 每个模块隐式指定 使用核心，因为你不能没有这些定义做任何事情。

Base

朱莉娅的基础库。 基地 是一个包含基本功能的模块（ 基地/). 所有模块隐式包含 使用基地，因为这在绝大多数情况下是需要的。

基本子模块

Base.Broadcast

包含广播实现的模块。

Docs

该 文件 模块提供 @doc宏，可用于设置和检索Julia对象的文档元数据。

请参阅手册部分 文档以获取更多信息。

使用迭代器的方法。

C标准库libc的接口。

元编程的便利功能。

用于收集和操作堆栈跟踪的工具。 主要用于构建错误。

提供检索有关硬件和操作系统的信息的方法。

多线程支持。

Base.GC

带有垃圾收集实用程序的模块。

所有对象

===(x,y) -> Bool
≡(x,y) -> Bool

确定是否 x 和 y 它们是相同的，因为没有程序可以区分它们。 首先是 x 和 y 进行比较。 如果它们是相同的，则可变对象按内存中的地址进行比较，不可变对象（如数字）按位级别的内容进行比较。 这个功能有时被称为"egal"。 它总是返回一个 布尔 价值。

例子

julia> a = [1, 2]; b = [1, 2];

朱莉娅>a==b
真的

朱莉娅>a===b
错误

朱莉娅>a===a
真的
isa(x, type) -> Bool

确定是否 x 是给定的 类型. 也可以用作中缀运算符，例如 x isa类型.

例子

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true
isequal(x)

创建一个函数，将其参数与 x 使用 等效;等效，即等价于 y->等距(y,x).

返回的函数是类型 基地。修正2{typeof(isequal)}，从而可用于实施专门的方法。

isequal(x, y) -> Bool

类似于 ==，但浮点数和缺失值的处理除外。 等效;等效 处理所有浮点 南 值为彼此相等，对待 -0.0 不等于 0.0，而 失踪等于 失踪. 总是返回一个 布尔 价值。

等效;等效 是一个等价关系-它是反身的（=== 暗示 等效;等效），对称（等效(a,b) 暗示 等效(b,a)）和传递性（等效(a,b) 和 等效(b,c) 暗示 等效(a,c)).

实施

的默认实现 等效;等效 电话 ==，所以不涉及浮点值的类型一般只需要定义 ==.

等效;等效 是哈希表使用的比较函数（Dict,Dict). 等距(x,y) 必须暗示 哈希(x)==哈希(y).

这通常意味着自定义的类型 == 或 等效;等效 方法存在必须实现相应的 哈希方法（反之亦然）。 集合通常实现 等效;等效 通过调用 等效;等效 递归地对所有内容。

此外, 等效;等效 与 无为，并且它们一起工作以定义一个固定的总排序，其中恰好一个 等距(x,y), isless(x,y)，或 isless(y,x) 必须是 真的 （而另外两个 错误).

标量类型一般不需要实现 等效;等效 与…​…​ ==，除非它们表示比作为通用后备提供的更有效实现的浮点数（基于 伊斯南, n.信号,信号，而 ==).

例子

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

朱莉娅>0.0==-0.0
真的

julia>isequal(0.0,-0.0)
错误

julia>失踪==失踪
失踪

茱莉亚>isequal(漏,漏)
真的
isless(x, y)

测试是否 x 小于 y，根据固定的总顺序（与 等效;等效). 无障碍 没有为对定义 (x,y) 所有类型的。 但是，如果它被定义，则期望满足以下内容:

*如果 无量(x,y) 是定义的，那么也是 isless(y,x) 和 等距(x,y)，而这三个产量中的一个 真的. *定义的关系 无为 是传递性的，即, isless(x,y)&&isless(y,z) 暗示 isless(x,z).

通常无序的值，例如 南，在常规值之后排序。 失踪值排在最后。

这是由使用的默认比较 排序！.

实施

具有总顺序的非数值类型应实现此功能。 数字类型只有在它们具有特殊值时才需要实现它，例如 南. 具有部分顺序的类型应实现 <. 请参阅 备用排序用于如何定义可用于排序和相关函数的备用排序方法。

例子

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false
isunordered(x)

回来吧 真的 如果 x 是根据不可排序的值 <，如 南 或 失踪.

评估到的值 真的 使用此谓词可能是有序的相对于其他顺序，如 无障碍.

兼容性

Julia1.7此功能需要Julia1.7或更高版本。

 
ifelse(condition::Bool, x, y)

回来吧 x 如果 条件 是 真的，否则返回 y. 这与 ? 或 如果 因为它是一个普通的函数，所以所有的参数都是首先计算的。 在某些情况下，使用 ifelse 而不是一个 如果 语句可以消除生成代码中的分支，并在紧密循环中提供更高的性能。

例子

julia> ifelse(1 > 2, 1, 2)
2
typeassert(x, type)

扔一个 打字错误除非 x isa类型. 语法 x::类型 调用此函数。

例子

julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got a value of type Float64
Stacktrace:
[...]
typeof(x)

获取具体类型的 x.

请参阅 eltype,eltype.

例子

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

julia> M = [1 2; 3.5 4];

julia> typeof(M)
Matrix{Float64} (alias for Array{Float64, 2})
tuple(xs...)

构造给定对象的元组。

请参阅 元组, n.婴儿, 命名的,命名的.

例子

julia> tuple(1, 'b', pi)
(1, 'b', π)

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # takes a collection
(1, 2, π)
ntuple(f, ::Val{N})

创建一个长度元组 N，计算每个元素为 f(i)，在哪里 i 是元素的索引。 通过采取 瓦尔(N) 因此，ntuple的此版本可能会生成比将长度作为整数的版本更有效的代码。 但是 ntuple(f,N) 优选为 ntuple(f,Val(N)) 在以下情况下 N 无法在编译时确定。

例子

julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)
ntuple(f, n::Integer)

创建一个长度元组 n，计算每个元素为 f(i)，在哪里 i 是元素的索引。

例子

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)
objectid(x) -> UInt

获取哈希值 x 基于对象身份。

如果 x===y 然后 objectid(x)==objectid(y)，而通常当 x！==y, objectid（x）！=objectid(y).

请参阅 哈希, IdDict.

hash(x[, h::UInt]) -> UInt

计算一个整数哈希码，以便 等距(x,y) 暗示 哈希(x)==哈希(y). 可选的第二个参数 h 是要与结果混合的另一个哈希码。

新类型应该实现2参数形式，通常通过调用2参数 哈希 方法递归，以便将内容的哈希相互混合（并与 h). 通常，实现的任何类型 哈希 也应该实现自己的 ==（因此 等效;等效）以保证上述财产。

当启动新的Julia进程时，哈希值可能会发生变化。

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # only use the output of another hash function as the second argument
0xd42bad54a8575b16

请参阅: 对象,对象, Dict,Dict, 套装.

finalizer(f, x)

注册函数 f(x) 当没有程序可访问的引用时被调用 x，并返回 x. 的类型 x 必须是一个 可变结构，否则函数会抛出。 f 不能导致任务切换，这排除了大多数I/O操作，例如 打印,打印. 使用 @异步 宏（将上下文切换推迟到终结器之外）或 ccall 在C中直接调用IO函数可能有助于调试目的。

请注意，没有保证执行的世界年龄 f. 它可以在终结者注册的世界时代或任何以后的世界时代被调用。

例子

finalizer(my_mutable_struct) do x
    @async println("Finalizing $x.")
end

终结器（my_mutable_struct）做x
    ccall(:jl_safe_printf,Cvoid,(Cstring,Cstring),"Finalizing%s.",repr(x))
结束

终结器可以在对象构造中注册。 在下面的示例中，请注意，我们隐式依赖于终结器返回新创建的可变结构 x.

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizing $t.")
        finalizer(f, x)
    end
end
finalize(x)

立即运行为对象注册的终结器 x.

copy(x)

创建一个浅拷贝 x：外部结构被复制，但不是所有内部值。 例如，复制数组会生成一个新数组，其元素与原始数组相同。

请参阅 收到！, 收到！, 深镜,深镜.

deepcopy(x)

创建一个深度副本 x：所有内容都是递归复制的，从而产生一个完全独立的对象。 例如，深度复制数组会创建它包含的所有对象的深度副本，并生成具有一致关系结构的新数组（例如，如果前两个元素在原始数组中是相同的对象，则新数组 深镜,深镜ed对象）。 打电话来 深镜,深镜 在对象上通常应该具有与序列化然后反序列化相同的效果。

虽然通常不需要，但用户定义的类型可以复盖默认值 深镜,深镜 通过定义函数的专用版本的行为 deepcopy_internal(x::T,dict::IdDict) （否则不应该使用），在哪里 T 是要专门用于的类型，并且 dict,dict 跟踪递归中到目前为止复制的对象。 内的定义, [医]内切 应用于代替 深镜,深镜，而 dict,dict 在返回之前，应酌情更新变量。

getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

语法 a.b 电话 getproperty(a,:b). 语法 @原子序a.b 电话 getproperty(a,:b,:order) 和语法 @原子a.b 电话 getproperty(a,:b,:sequentially_consistent).

例子

julia> struct MyType{T <: Number}
           x::T
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

一个人应该超载 获得财产 只有在必要时，因为如果语法的行为可能会令人困惑 反对。f 是不寻常的。 还要注意，使用方法通常是优选的。 有关更多信息，请参阅此样式指南文档: 首选导出方法而不是直接字段访问。

请参阅 盖菲尔德, 财产名称和 setproperty！.

setproperty!(value, name::Symbol, x)
setproperty!(value, name::Symbol, x, order::Symbol)

语法 a.b=c 电话 setproperty！(a,:b,c). 语法 @原子序a.b=c 电话 setproperty！(a,:b,c,:顺序) 和语法 @原子a.b=c 电话 setproperty！（a，：b，c，：sequentially_consistent）.

兼容性

朱莉娅1.8 setproperty！ 在模块上至少需要Julia1.8。

请参阅 塞特菲尔德！, 财产名称和 获得财产.

replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

执行比较和交换操作 x.f 从 预期的 到 期望的，每个egal。 语法 @atomicreplace x.f期望=>期望 可以用来代替函数调用形式。

请参阅 替换场！ setproperty！, setpropertyonce！.

swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

语法 @原子a.b,_=c,a.b 申报表 （c，swapproperty！（a，：b，c，：sequentially_consistent）），那里必须有一个 获得财产 双方共同的表达。

请参阅 斯瓦普菲尔德！和 setproperty！.

modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

语法 @原子op(x.f,v) （及其等价物 @原子x.f op v)回报 modifyproperty！(x,:f,op,v,:sequentially_consistent)，其中第一个参数必须是 获得财产 表达并且被原子修饰。

调用 op（getproperty（x，f），v） 必须返回可存储在字段中的值 f 对象的 x 默认情况下。 特别是，与默认行为不同 setproperty！，该 转换/转换 函数不会自动调用。

请参阅 莫迪菲尔德！和 setproperty！.

setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

执行比较和交换操作 x.f 要将其设置为 价值 如果以前未设置。 语法 @atomiconce x.f=值 可以用来代替函数调用形式。

请参阅 setfieldonce！, setproperty！, 更换产品！.

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

 
propertynames(x, private=false)

获取属性的元组或向量（x.财产）的对象 x. 这通常与 字段名(类型(x))，但是重载的类型 获得财产一般应超载 财产名称 以及获取类型的实例的属性。

财产名称(x) 可能只返回"公共"属性名称，这些名称是 x. 如果您希望它也返回用于内部使用的"私有"属性名称，请传递 真的 对于可选的第二个参数。 REPL标签完成 x. 只显示 私人=错误 属性。

请参阅: n.财产, 哈斯菲尔德.

hasproperty(x, s::Symbol)

返回一个布尔值，指示对象是否 x 有 s 作为自己的属性之一。

兼容性

Julia1.2这个函数至少需要Julia1.2。

请参阅: 财产名称, 哈斯菲尔德.

getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

从复合中提取字段 价值 按姓名或职位。 或者，可以为操作定义排序。 如果该字段被宣布 @原子，强烈建议规范与该位置的商店兼容。 否则，如果未声明为 @原子，此参数必须为 ：not_atomic 如果指定。 请参阅 获得财产和 字段名称.

例子

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1
setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

分配；分配 x 到一个命名字段 价值 复合型。 该 价值 必须是可变的和 x 必须是 fieldtype(typeof(value),name). 此外，还可以为此操作指定排序。 如果该字段被宣布 @原子，本规范是强制性的。 否则，如果未声明为 @原子，它必须是 ：not_atomic 如果指定。 请参阅 setproperty！.

例子

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

julia> a = 1//2
1//2

julia> setfield!(a, :num, 3);
ERROR: setfield!: immutable struct of type Rational cannot be changed
modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

在应用函数后，原子地执行获取和设置字段的操作 op的.

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

如果硬件支持（例如，原子增量），这可能被优化到适当的硬件指令，否则它将使用循环。

兼容性

Julia1.7此功能需要Julia1.7或更高版本。

 
replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

原子地执行操作以获取并有条件地将字段设置为给定值。

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

如果硬件支持，这可能会优化到适当的硬件指令，否则它将使用循环。

兼容性

Julia1.7此功能需要Julia1.7或更高版本。

 
swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])

原子地执行操作以同时获取和设置字段:

y = getfield(value, name)
setfield!(value, name, x)
return y
兼容性

Julia1.7此功能需要Julia1.7或更高版本。

 
setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

原子地执行将字段设置为给定值的操作，只有在以前未设置的情况下。

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok
兼容性

Julia1.11此功能需要Julia1.11或更高版本。

 
isdefined(m::Module, s::Symbol, [order::Symbol])
isdefined(object, s::Symbol, [order::Symbol])
isdefined(object, index::Int, [order::Symbol])

测试是否定义了全局变量或对象字段。 参数可以是模块和符号，也可以是复合对象和字段名称（作为符号）或索引。 或者，可以为操作定义排序。 如果该字段被宣布 @原子，强烈建议规范与该位置的商店兼容。 否则，如果未声明为 @原子，此参数必须为 ：not_atomic 如果指定。

要测试是否定义了数组元素，请使用 is分配代替。

支持全局变量变体以兼容较旧的julia版本。 对于新代码，首选 isdefinedglobal.

请参阅 @被定义.

例子

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false
isdefinedglobal(m::Module, s::Symbol, [allow_import::Bool=true, [order::Symbol=:unordered]])

测试是否全局变量 s 在模块中定义 m （在当前的世界时代）。 当且仅当可以从此全局变量读取值并且访问不会抛出时，才认为定义了变量。 这包括具有值集的常量和全局变量。

如果 允许_import 是 错误，全局变量必须在里面定义 m 并且可能不会从另一个模块导入。

兼容性

Julia1.12此功能需要Julia1.12或更高版本。

请参阅 @被定义.

例子

julia> isdefinedglobal(Base, :sum)
true

julia> isdefinedglobal(Base, :NonExistentMethod)
false

julia> isdefinedglobal(Base, :sum, false)
true

julia>isdefinedglobal(Main,:sum,false)
错误
@isdefined s -> Bool

测试是否变量 s 在当前范围中定义。

请参阅 被定义的对于字段属性和 is分配用于数组索引或 哈斯基用于其他映射。

例子

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

julia> function f()
           println(@isdefined x)
           x = 3
           println(@isdefined x)
       end
f (generic function with 1 method)

julia> f()
false
true
convert(T, x)

转换/转换 x 到类型的值 T.

如果 T 是一个 整数类型，an N.恐怖,恐怖如果 x 不能由 T，例如，如果 x 不是整数值，或超出由 T.

例子

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]

如果 T 是一个 [医抽象浮]类型，然后它将返回最接近的值 x 可由 T. Inf被视为大于一个ulp 最大浮标(T) 为确定最近的目的。

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

如果 T 是集合类型和 x 一个集合，结果 转换(T,x) 可以别名全部或部分 x.

julia> x = Int[1, 2, 3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

请参阅: 圆形, [医], 类型,类型, 重新诠释.

promote(xs...)

将所有参数转换为通用类型，并将它们全部返回（作为元组）。 如果不能转换参数，则会引发错误。

请参阅: promote_type, 促进/促进.

例子

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: promotion of types Int64 and String failed to change any arguments
[...]

julia> promote_type(Int, String)
Any
oftype(x, y)

转换/转换 y 到的类型 x 即 转换(类型(x),y).

例子

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0
widen(x)

如果 x 是一个类型，返回一个"较大"的类型，定义为使算术运算 + 和 - 保证对任何类型的值组合不会溢出或丢失精度 x 能撑住。

对于小于128位的固定大小整数类型, 加宽 将返回具有两倍位数的类型。

如果 x 是一个值，它被转换为 加宽(x型).

例子

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5
identity(x)

的身份函数。 返回其参数。

请参阅: 一个, 一个单位，和 线性代数的 我.

例子

julia> identity("Well, what did you expect?")
"Well, what did you expect?"
WeakRef(x)

w=WeakRef（x） 构造a 弱引用到Julia值 x：虽然 w 包含对 x，它不会阻止 x 从垃圾收集。 w.价值 是要么 x （如果 x 尚未被垃圾回收）或 什么都没有 （如果 x 已被垃圾回收）。

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # a reference is maintained via `x`
WeakRef("a string")

julia> x = nothing # clear reference

julia> GC.gc()

julia> w
WeakRef(nothing)

类型的属性

类型关系

supertype(T::Union{DataType, UnionAll})

返回type的直接超类型 T. T 可以是一个 数据类型或一个 联合所有类型。 不支持类型 工会s.另请参阅 类型。

例子

julia> supertype(Int32)
Signed

julia> supertype(Vector)
DenseVector (alias for DenseArray{T, 1} where T)
Core.Type{T}

核心。类型 是一个抽象类型，它具有所有类型对象作为其实例。 单例类型的唯一实例 核心。类型{T} 是对象 T.

例子

julia> isa(Type{Float64}, Type)
true

julia> isa(Float64, Type)
true

julia> isa(Real, Type{Float64})
false

julia> isa(Real, Type{Real})
true
DataType <: Type{T}

数据类型 表示具有名称、显式声明的超类型以及（可选）参数的显式声明类型。 系统中的每个具体值都是一些值的一个实例 数据类型.

例子

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType
<:(T1, T2)::Bool

子类型关系，在两种类型之间定义。 在朱莉娅，一个类型 S 被认为是一个类型的_subtype_ T 当且仅当我们有 S<:T.

适用于任何类型 L 和任何类型 R, L<：R 暗示任何价值 v 类型 L 也是类型 R. 即。, (L<:R)&&(v isa L) 暗示 v isa R.

子类型关系是_partial order_。 即。, <: 是:

*reflexive：对于任何类型 T, T<：T 持有 *antisymmetric：适用于任何类型 A 和任何类型 B, (A<:B)&&(B<:A) 暗示 A==B *transitive：适用于任何类型 A，任何类型 B 和任何类型 C; (A<:B)&&(B<:C) 暗示 A<：C

另请参阅 类型, Union{}, 任何, 伊萨.

例子

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}  # `Matrix` is invariant
false

julia> Tuple{Float64} <: Tuple{AbstractFloat}    # `Tuple` is covariant
true

julia> Union{} <: Int  # The bottom type, `Union{}`, subtypes each type.
true

julia>Union{}<:Float32<:AbstractFloat<:Real<:Number<:Any#Operator chaining
真的

该 <: 关键字也有几种语法用法，它们表示相同的子类型关系，但不执行运算符或返回Bool:

*在a的参数上指定下界和上界 联合所有输入a 哪里声明。 *要在方法的（静态）参数上指定下界和上界，请参阅 参数化方法。 *要在声明新类型时定义子类型关系，请参阅 结构体和 抽象类型.

>:(T1, T2)

超类型运算符，等价于 T2<：T1.

typejoin(T, S, ...)

返回类型的最接近的共同祖先 T 和 S，即它们都继承的最窄类型。 在额外的varargs上递归。

例子

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number
typeintersect(T::Type, S::Type)

计算包含 T 和 S. 通常这将是最小的这种类型或接近它的类型。

保证确切行为的特殊情况：当 T<:S, typeintersect(S,T)==T==typeintersect(T,S).

promote_type(type1, type2, ...)

提升是指将混合类型的值转换为单个通用类型。 promote_type 表示当运算符（通常是数学运算符）被赋予不同类型的参数时，Julia中的默认提升行为。 promote_type 通常尝试返回一个类型，该类型至少可以近似任何输入类型的大多数值，而不会过度扩展。 一些损失是可以容忍的;例如, promote_type（Int64，Float64） 申报表 漂浮64尽管严格，不是全部 Int64值可以完全表示为 漂浮64 价值观。

请参阅: 推广, n.促进,促进, 促进/促进.

例子

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia>promote_type（Int16，Float16）
漂浮物16

julia>promote_type（Int64，Float16）
漂浮物16

julia>promote_type（Int8，UInt16）
UInt16

不要直接重载它来重载你自己的类型，你应该重载 促进/促进. promote_type 电话 促进/促进 内部来确定类型。 超载 promote_type 直接会造成歧义错误。

 
promote_rule(type1, type2)

指定应由 推广当给定类型的值时 第1类 和 打字2. 不应直接调用此函数，而应酌情为新类型添加定义。

promote_typejoin(T, S)

计算包含两者的类型 T 和 S，可以是两种类型的父项，也可以是 工会 如果合适的话。 回落到 [医打字].

请参阅 推广, promote_type.

例子

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64
isdispatchtuple(T)

确定是否类型 T 是一个具体类型的元组，这意味着它可以在dispatch中显示为类型签名，并且没有可能出现在调用中的子类型（或超类型）。 如果 T 不是类型，则返回 错误.

申报结构

ismutable(v) -> Bool

回来吧 真的 当且仅当值 v 是可变的。 见 可变复合类型用于讨论不变性。 请注意，这个函数适用于值，所以如果你给它一个 数据类型，它会告诉你类型的值是可变的。

技术原因说明, ismutable缧 申报表 真的 对于某些特殊类型的值（例如 字符串 和 符号）即使它们不能以允许的方式突变。

请参阅 等位,等位, 等结构类型.

例子

julia> ismutable(1)
false

julia> ismutable([1,2])
true
兼容性

Julia1.5此功能至少需要Julia1.5。

 
isimmutable(v) -> Bool

警告考虑使用 !ismutable(v) 相反，作为 isimmutable(v) 将被替换为 !ismutable(v) 在未来的版本中。 （自Julia1.5以来）

回来吧 真的 iff值 v 是不可变的。 见 可变复合类型用于讨论不变性。 请注意，这个函数适用于值，所以如果你给它一个类型，它会告诉你一个值为 数据类型 是可变的。

例子

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false
ismutabletype(T) -> Bool

确定是否类型 T 被声明为可变类型（即使用 可变结构 关键字）。 如果 T 不是类型，则返回 错误.

兼容性

Julia1.7此功能至少需要Julia1.7。

 
isabstracttype(T)

确定是否类型 T 被声明为抽象类型（即使用 抽象类型 语法）。 请注意，这不是否定 isconcretetype(T). 如果 T 不是类型，则返回 错误.

例子

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false
isprimitivetype(T) -> Bool

确定是否类型 T 被声明为原始类型（即使用 原始类型 语法）。 如果 T 不是类型，则返回 错误.

Base.issingletontype(T)

确定是否类型 T 只有一个可能的实例;例如，除了其他单例值之外没有字段的结构类型。 如果 T 不是具体类型，则返回 错误.

isstructtype(T) -> Bool

确定是否类型 T 被声明为结构类型（即使用 结构体 或 可变结构 关键字）。 如果 T 不是类型，则返回 错误.

nameof(t::DataType) -> Symbol

获取a的名称（可能 联合所有-包装) 数据类型 （没有其父模块）作为符号。

例子

julia> module Foo
           struct S{T}
           end
       end
Foo

julia> nameof(Foo.S{T} where T)
:S
fieldnames(x::DataType)

获取一个元组，其中包含一个字段的名称 数据类型.

每个名字都是一个 符号，除非当 x<:元组，在这种情况下，每个名称（实际上是字段的索引）都是 Int型.

请参阅 财产名称, 哈斯菲尔德.

例子

julia> fieldnames(Rational)
(:num, :den)

julia> fieldnames(typeof(1+im))
(:re, :im)

julia> fieldnames(Tuple{String,Int})
(1, 2)
fieldname(x::DataType, i::Integer)

获取字段的名称 i 一个 数据类型.

返回类型为 符号，除非当 x<:元组，在这种情况下，返回字段的索引，类型 Int型.

例子

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

julia> fieldname(Tuple{String,Int}, 2)
2
fieldtype(T, name::Symbol | index::Int)

确定复合数据类型中字段的声明类型（按名称或索引指定 T.

例子

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String
fieldtypes(T::Type)

复合数据类型中所有字段的声明类型 T 作为元组。

兼容性

Julia1.1此功能至少需要Julia1.1。

例子

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtypes(Foo)
(Int64, String)
fieldcount(t::Type)

获取给定类型的实例将具有的字段数。 如果类型过于抽象而无法确定这一点，则会引发错误。

hasfield(T::Type, name::Symbol)

返回一个布尔值，指示是否 T 有 姓名 作为自己的领域之一。

请参阅 字段名称, 现场人数, n.财产,财产.

兼容性

Julia1.2此功能至少需要Julia1.2。

例子

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false
nfields(x) -> Int

获取给定对象中的字段数。

例子

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("I've done a bad thing");

julia> nfields(ex)
1

在这些例子中, a 是一个 理性的，其中有两个字段。 b 是一个 Int型，这是一个根本没有字段的原始bitstype。 前 是一个 ErrorException异常，其中有一个字段。

isconst(t::DataType, s::Union{Int,Symbol}) -> Bool

确定字段是否 s 是const在给定的类型 t 从这个意义上说，从所述字段的读取对于平均对象是一致的。 特别要注意的是，在这个定义下，越界字段被认为是const（因为它们总是抛出）。

isconst(m::Module, s::Symbol) -> Bool
isconst(g::GlobalRef)

确定全局是否为 康斯特 在给定的模块 m，或者因为它被声明为常量，或者因为它是从常量绑定导入的。 请注意，constant-ness特定于一个特定的世界年龄，因此此函数的结果可能不会假定在世界年龄更新后成立。

isfieldatomic(t::DataType, s::Union{Int,Symbol}) -> Bool

确定字段是否 s 被声明 @原子 在给定的类型 t.

内存布局

sizeof(T::DataType)
sizeof(obj)

给定的规范二进制表示的大小（以字节为单位） 数据类型 T，如果有的话。 或者对象的大小（以字节为单位） 反对 如果它不是一个 数据类型.

请参阅 基地。摘要大小.

例子

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # not the sum of `sizeof` of fields due to padding
16

julia> sizeof(Int64) + sizeof(Bool) # different from above
9

如果 数据类型 T 没有特定大小，则抛出错误。

julia> sizeof(AbstractArray)
ERROR: Abstract type AbstractArray does not have a definite size.
Stacktrace:
[...]
isconcretetype(T)

确定是否类型 T 是一个具体的类型，这意味着它可以有直接的实例（值） x 这样， 类型(x)===T). 请注意，这不是否定 isabstracttype(T). 如果 T 不是类型，则返回 错误.

请参阅: 轨道,轨道, [医伊莎斯特拉克特型], 伊辛莱特类型.

例子

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false
isbits(x)

回来吧 真的 如果 x 是一个实例 等位类型类型。

isbitstype(T)

回来吧 真的 如果类型 T 是"纯数据"类型，这意味着它是不可变的，不包含对其他值的引用，仅 原始的 类型及其他 等位类型 类型。 典型的例子是数字类型，如 UInt8, 漂浮64，和 复杂{Float64}. 此类别类型很重要，因为它们作为类型参数有效，可能无法跟踪 被定义的 / is分配状态，并具有与C.if兼容的定义布局 T 不是类型，则返回 错误.

请参阅 轨道,轨道, isprimitivetype,isprimitivetype, ismutable缧.

例子

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false
fieldoffset(type, i)

字段的字节偏移量 i 相对于数据开始的类型。 例如，我们可以通过以下方式使用它来总结有关结构的信息:

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
14-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)
 (0x0000000000000068, :ioerrno, Int32)
Base.datatype_alignment(dt::DataType) -> Int

此类型实例的内存分配最小对齐。 可以在任何调用 [医]类型，虽然对于内存它会给出元素的对齐，而不是整个对象。

Base.datatype_haspadding(dt::DataType) -> Bool

返回此类型实例的字段是否在内存中打包，没有中间填充位（定义为其值不影响实例本身语义值的位）。 可以在任何调用 [医]类型.

Base.datatype_pointerfree(dt::DataType) -> Bool

返回此类型的实例是否可以包含对gc托管内存的引用。 可以在任何调用 [医]类型.

特殊值

typemin(T)

给定（真实）数字数据类型可表示的最低值 T.

请参阅: [医浮游生物], 打字,打字, 每股收益.

例子

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # smallest finite Float32 floating point number
-3.4028235f38
typemax(T)

由给定（实数）数字表示的最高值 数据类型.

请参阅: 飞鸟,飞鸟, 打字机, 每股收益.

例子

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # largest finite Float32 floating point number
3.4028235f38
floatmin(T = Float64)

返回浮点类型表示的最小正常数 T.

例子

julia> floatmin(Float16)
Float16(6.104e-5)

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308
floatmax(T = Float64)

返回浮点类型可表示的最大有限数 T.

请参阅: 打字,打字, [医浮游生物], 每股收益.

例子

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf
maxintfloat(T, S)

给定浮点类型中可表示的最大连续整数 T 这也不超过整数类型表示的最大整数 S. 等价地，它是最小的 最大浮标(T) 和 打字格式.

maxintfloat(T=Float64)

在给定浮点类型中精确表示的最大连续整数值浮点数 T （默认为 漂浮64).

那就是, [医]最大浮 返回最小的正整数值浮点数 n 这样， n+1 是_not_在类型中完全可表示 T.

当 整数-需要类型值，使用 整数(maxintfloat(T)).

eps(::Type{T}) where T<:AbstractFloat
eps()

返回浮点类型的_machine epsilon_ T (T=浮64 默认情况下）。 这被定义为1和下一个最大值之间的差距，由 类型(一(T))，并且相当于 eps(一(T)). （自 eps(T) 是对_relative error_的约束 T，它是一个"无量纲"量像 一个.)

例子

julia> eps()
2.220446049250313e-16

朱莉娅>eps(Float32)
1.1920929f-7

朱莉娅>1.0+eps()
1.0000000000000002

朱莉娅>1.0+eps()/2
1.0
eps(x::AbstractFloat)

返回最后一个位置的_unit_(ulp) x. 这是连续的可表示浮点值之间的距离 x. 在大多数情况下，如果在任一侧的距离 x 是不同的，则取两者中较大的，即

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

此规则的例外是最小和最大的有限值（例如 nextfloat(-Inf) 和 prevfloat(Inf) 为 漂浮64），其中四舍五入到较小的值。

这种行为的理由是 每股收益 限制浮点舍入误差。 默认情况下 RoundNearest拢潞 舍入模式，如果 是一个实数和 是最接近的浮点数 ，则

请参阅: n.下一层,下一层, [医正常], [医浮游生物].

例子

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # largest finite Float64
1.7976931348623157e308

julia> x + eps(x)/2            # rounds up
Inf

julia> x + prevfloat(eps(x)/2) # rounds down
1.7976931348623157e308
instances(T::Type)

返回给定类型的所有实例的集合（如果适用）。 主要用于枚举类型（请参阅 @枚举).

例子

julia> @enum Color red blue green

julia> instances(Color)
(red, blue, green)

特殊类型

Any::DataType

任何 是所有类型的联合。 它具有定义属性 isa(X,Any)==真 对于任何 x. 任何 因此描述了可能值的整个宇宙。 例如 整数 是 任何 这包括 Int型, Int8，以及其他整数类型。

Union{Types...}

A 工会 类型是一个抽象类型，它包括它的任何参数类型的所有实例。 这意味着 T<:联合{T,S} 和 S<:联合{T,S}.

像其他抽象类型一样，它不能被实例化，即使它的所有参数都是非抽象的。

例子

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString # instance of Int is included in the union
true

julia> "Hello!" isa IntOrString # String is also included
true

julia> 1.0 isa IntOrString # Float64 is not included because it is neither Int nor AbstractString
false

扩展帮助

与大多数其他参数类型不同，联合在其参数中是协变的。 例如, 工会{Real, String} 是 工会{Number, AbstractString}.

空虚的联盟 Union{}是朱莉娅的底部类型。

Union{}

工会{}, the empty Union of types, is the bottom type of the type system. That is, for each T::Type, Union{} <:T. 另请参阅子类型运算符的文档: <:.

因此, 工会{} is also an empty/uninhabited type, meaning that it has no values. That is, for each x, isa(x, Union{})==错误.

基地。底部 被定义为其别名和类型 联合{} 是 核心。[医]打字机.

例子

julia> isa(nothing, Union{})
false

julia> Union{} <: Int
true

julia> typeof(Union{}) === Core.TypeofBottom
true

julia> isa(Union{}, Union)
false
UnionAll

类型在类型参数的所有值上的联合。 联合所有 用于描述某些参数值未知的参数类型。 请参阅手册部分 UnionAll类型。

例子

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType
Tuple{Types...}

元组是一个固定长度的容器，可以保存任何不同类型的值，但不能被修改（它是不可变的）。 这些值可以通过索引访问。 元组字面量用逗号和括号书写:

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

长度-1元组必须用逗号书写, (1,)，自 (1) 只是一个带括号的值。 () 表示空（长度-0）元组。

元组可以通过使用 元组 类型为构造函数:

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

元组类型在其参数中是协变的: 元组{Int} 是 元组{Any}. 因此 元组{Any} 被认为是抽象类型，元组类型只有在它们的参数是具体的情况下才是具体的。 元组没有字段名称；字段只能通过索引访问。 元组类型可以具有任意数量的参数。

请参阅手册部分 元组类型。

请参阅 瓦拉格, N.n.n.n., n.n.n.n., 元组, 命名的,命名的.

NTuple{N, T}

表示长度元组类型的紧凑方法 N 所有元素都是类型的 T.

例子

julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
true

请参阅 n.婴儿.

NamedTuple

命名的,命名的s是，正如他们的名字所暗示的，命名 元组`也就是说，它们是一个类似元组的值集合，其中每个条目都有一个唯一的名称，表示为 xref:base/base.adoc#Core.Symbol[`符号. 像 元组s, 命名的,命名的s是不可变的；名称和值都不能在构造后就地修改。

命名元组可以创建为带有键的元组字面值，例如 （a=1，b=2），或者作为一个元组字面量，在左括号后面加上分号，例如 （;a=1，b=2） （此表单也接受编程生成的名称，如下所述），或使用 命名的,命名的 类型为构造函数，例如 命名的,命名的{(:a, :b)}1,2.

访问命名元组中与名称关联的值可以使用字段访问语法完成，例如 x.a，或使用 getindex,getindex，例如 x[:a] 或 x[(:a,:b)]. 可以使用以下方法获得名称的元组 钥匙，并且可以使用以下方法获得值的元组 价值.

注释迭代结束 命名的,命名的s生成不带名称的_values_。 （见下面的例子。)要遍历名称-值对，请使用 对,对功能。

该 @NamedTuple宏可用于方便地声明 命名的,命名的 类型。

例子

julia> x = (a=1, b=2)
(a = 1, b = 2)

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

julia> keys(x)
(:a, :b)

julia> values(x)
(1, 2)

julia> collect(x)
2-element Vector{Int64}:
 1
 2

julia> collect(pairs(x))
2-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2

与如何以编程方式定义关键字参数类似，可以通过给出对来创建命名元组 名称::符号=>值 在元组字面量内的分号之后。 这个和 名称=值 语法可以混合:

julia> (; :a => 1, :b => 2, c=3)
(a = 1, b = 2, c = 3)

名称-值对也可以通过拆分命名元组或任何迭代器来提供，该迭代器生成两值集合，将每个符号作为第一个值:

julia> keys = (:a, :b, :c); values = (1, 2, 3);

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

julia> (; (keys .=> values)...)
(a = 1, b = 2, c = 3)

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # the final b overwrites the value from nt1
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip yields tuples such as (:a, 1)
(a = 1, b = 2, c = 3)

与关键字参数一样，标识符和点表达式意味着名称:

julia> x = 0
0

julia> t = (; x)
(x = 0,)

julia> (; t.x)
(x = 0,)
兼容性

Julia1.5标识符和点表达式的隐式名称从Julia1.5开始可用。
兼容性

Julia1.7使用 getindex,getindex 具有多个的方法 符号s从Julia1.7开始可用。

 
@NamedTuple{key1::Type1, key2::Type2, ...}
@NamedTuple begin key1::Type1; key2::Type2; ...; end

此宏为声明提供了更方便的语法 命名的,命名的 类型。 它返回一个 命名的,命名的 使用给定的键和类型键入，相当于 命名{(:key1, :key2, ...), Tuple{Type1,Type2,...}}. 如果 ::类型 声明被省略，它被认为是 任何. 该 开始。.. 结束 form允许声明被分割成多行（类似于 结构体 声明），但在其他方面是等价的。 该 命名的,命名的 打印时使用宏 命名的,命名的 类型，例如REPL。

例如，元组 （a=3.1，b="你好"） 有一个类型 命名的,命名的{(:a, :b), Tuple{Float64, String}}，也可以通过 @NamedTuple 作为:

julia> @NamedTuple{a::Float64, b::String}
@NamedTuple{a::Float64, b::String}

julia> @NamedTuple begin
           a::Float64
           b::String
       end
@NamedTuple{a::Float64, b::String}
兼容性

Julia1.5这个宏从Julia1.5开始可用。

 
@Kwargs{key1::Type1, key2::Type2, ...}

此宏提供了一种方便的方法来构造关键字参数的类型表示，其语法与 @NamedTuple. 例如，当我们有一个函数调用 func([位置参数];kw1=1.0,kw2="2")，我们可以使用这个宏来构造关键字参数的内部类型表示为 @夸格斯{kw1::Float64, kw2::String}. 宏语法专门用于在堆栈跟踪视图中打印关键字方法时简化其签名类型。

julia> @Kwargs{init::Int} # the internal representation of keyword arguments
Base.Pairs{Symbol, Int64, Nothing, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
The function `+` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

Stacktrace:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [inlined]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [inlined]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [inlined]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [inlined]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [inlined]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [inlined]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [inlined]
 [10] top-level scope
    @ REPL[12]:1
兼容性

Julia1.10这个宏从Julia1.10开始可用。

 
Val(c)

回来吧 瓦尔{c}()，其中不包含运行时数据。 像这样的类型可以用来通过值传递函数之间的信息 c，这必须是一个 轨道,轨道 值或一个 符号. 此构造的目的是能够直接（在编译时）对常量进行调度，而无需在运行时测试常量的值。

例子

julia> f(::Val{true}) = "Good"
f (generic function with 1 method)

julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)

julia> f(Val(true))
"Good"
Vararg{T,N}

元组类型的最后一个参数 元组可以是特殊值 瓦拉格，表示任意数量的尾随元素。 瓦拉格{T,N} 完全对应于 N 类型的元素 T. 最后 瓦拉格{T} 对应于零个或多个类型的元素 T. 瓦拉格 元组类型用于表示varargs方法接受的参数（请参阅 Varargs函数。)

请参阅 N.婴儿.

例子

julia> mytupletype = Tuple{AbstractString, Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false
Nothing

没有字段的类型 什么都没有.

请参阅: 没有任何东西, 一些, 失踪.

isnothing(x)

回来吧 真的 如果 x===无，并返回 错误 如果没有。

兼容性

Julia1.1此功能至少需要Julia1.1。

请参阅 有些东西, 基地。没有任何东西, 伊斯米辛.

notnothing(x)

抛出一个错误，如果 x===无，并返回 x 如果没有。

Some{T}

在使用的包装类型 联盟{Some{T},没有} 要区分没有一个值（什么都没有)和存在 什么都没有 值（即 一些（没有）).

使用方法 有些东西访问由a包装的值 一些 对象。

something(x...)

返回参数中的第一个值，该值不等于 什么都没有，如果有的话。 否则抛出错误。 类型的参数 一些被解开。

请参阅 聚结,聚结, 跳板,跳板, @东西.

例子

julia> something(nothing, 1)
1

julia> something(Some(1), nothing)
1

julia> something(Some(nothing), 2) === nothing
true

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: No value arguments present
@something(x...)

短路版本的 有些东西.

例子

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("Unable to find default for `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("Unable to find default for `b`")
f(2)
f(3)
ERROR: Unable to find default for `b`
[...]

julia> b = @something b f(2) f(3) Some(nothing)
f(2)
f(3)

julia> b === nothing
true
兼容性

Julia1.7这个宏从Julia1.7开始可用。

 
Enum{T<:Integer}

定义的所有枚举类型的抽象超类型 @枚举.

@enum EnumName[::BaseType] value1[=x] value2[=y]

创建一个 枚举{BaseType} 带名称的子类型 枚举名 和枚举成员值 价值1 和 价值2 可选的赋值值为 x 和 y，分别。 枚举名 可以像其他类型和枚举成员值一样用作常规值，例如

例子

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "I'm a Fruit with value: $(Int(x))"
f (generic function with 1 method)

julia> f(apple)
"I'm a Fruit with value: 1"

julia> Fruit(1)
apple::Fruit = 1

值也可以在一个 開始啦。 块，例如

@enum EnumName begin
    value1
    value2
end

基本类型，其中默认为 Int32，必须是 整数. 成员值可以在枚举类型和 基本类型. 讀！ 和 写 自动执行这些转换。 如果枚举是用非默认值创建的 基本类型, 整数(value1) 将返回整数 价值1 与类型 基本类型.

列出枚举使用的所有实例 实例，例如

julia> instances(Fruit)
(apple, orange, kiwi)

可以从枚举实例构造符号:

julia> Symbol(apple)
:apple
Expr(head::Symbol, args...)

在解析的julia代码(ASTs)中表示复合表达式的类型。 每个表达式由一个 头 符号 识别它是哪种类型的表达式（例如调用，for循环，条件语句等。）和子表达式（例如调用的参数）。 子表达式存储在 向量{Any} 被称为字段 阿格斯.

请参阅手册章节 元编程和开发人员文档 朱莉娅ASTs。

例子

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c
Symbol

在解析的julia代码(Ast)中用于表示标识符的对象类型。 也经常用作名称或标签来识别实体（例如作为字典键）。 符号s可以使用输入 : 报价操作员:

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

朱莉娅>eval(:x)
42

符号s也可以通过调用构造函数从字符串或其他值构造 符号（x。..).

符号s是不可变的，它们的实现对所有对象都重复使用相同的对象 符号s同名。

不像字符串, 符号s是不支持字符迭代的"原子"或"标量"实体。

Symbol(x...) -> Symbol

创建一个 符号通过将参数的字符串表示形式连接在一起。

例子

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4
Module

A 模块 是一个单独的全局变量工作区。 见 模块和 关于模块的手册部分有关详细信息。

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

返回具有指定名称的模块。 A 裸模,裸模 对应于 模块(:ModuleName,false)

一个不包含任何名称的空模块可以用 模块(:ModuleName,false,false). 此模块不会导入 基地 或 核心 并且不包含对自身的引用。

泛型函数

Function

所有函数的抽象类型。

例子

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (singleton type of function sin, subtype of Function)

julia> ans <: Function
true
hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter()) -> Bool

确定给定的泛型函数是否具有匹配给定的方法 元组 具有世界年龄上限的参数类型由 世界.

如果关键字参数名称的元组 姓名 被提供，这也检查是否的方法 f 匹配 t 具有给定的关键字参数名称。 如果匹配方法接受可变数量的关键字参数，例如 夸格斯。..，任何在 姓名 被认为是有效的。 否则，提供的名称必须是方法关键字参数的子集。

请参阅 适用.

兼容性

Julia1.2提供关键字参数名称需要Julia1.2或更高版本。

例子

julia> hasmethod(length, Tuple{Array})
true

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

julia> g(; xs...) = 4;

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g accepts arbitrary kwargs
true
applicable(f, args...) -> Bool

确定给定的泛型函数是否具有适用于给定参数的方法。

请参阅 哈斯米索德.

例子

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true
Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

确定是否两种方法 m1 和 m2 对于某些呼叫签名可能是模棱两可的。 此测试在相同功能的其他方法的上下文中执行;隔离, m1 和 m2 可能是模棱两可的，但是如果定义了解决模棱两可的第三种方法，则返回 错误. 或者，在隔离 m1 和 m2 可能是有序的，但如果第三种方法不能与它们排序，它们可能会导致歧义。

对于参数类型， 模棱两可的,模棱两可的 关键字参数控制是否 联合{} 算作类型参数的不明确交集—​when 真的，它被认为是模棱两可的，当 错误 事实并非如此。

例子

julia> foo(x::Complex{<:Integer}) = 1
foo (generic function with 1 method)

julia> foo(x::Complex{<:Rational}) = 2
foo (generic function with 2 methods)

julia>m1，m2=collect（方法（foo））;

julia>typeintersect(m1.sig，m2。sig）
元组{typeof(foo), Complex{Union{}}}

朱莉娅>基地。isambiguous(m1,m2,ambiguous_bottom=true)
真的

朱莉娅>基地。isambiguous(m1,m2,ambiguous_bottom=false)
错误
invoke(f, argtypes::Type, args...; kwargs...)
invoke(f, argtypes::Method, args...; kwargs...)
invoke(f, argtypes::CodeInstance, args...; kwargs...)

为给定的泛型函数调用方法 f 匹配指定的类型 [医]银型 在指定的参数上 阿格斯 并传递关键字参数 夸格斯. 论点 阿格斯 必须符合指定的类型 [医]银型，即不自动执行转换。 此方法允许调用最具体的匹配方法以外的方法，当显式需要更一般定义的行为时（通常作为相同函数的更具体方法的实现的一部分），这很有用。 但是，因为这意味着运行时必须做更多的工作, 调用 通常也比常规呼叫进行正常调度慢-有时明显如此。

使用时要小心 调用 对于你不写的函数。 什么定义用于给定 [医]银型 是一个实现细节，除非函数显式声明调用与某些 [医]银型 是公共API的一部分。 例如，之间的变化 f1 和 f2 在下面的示例中通常被认为是兼容的，因为该更改由具有正常（非-调用）打电话。 但是，如果您使用，则更改是可见的 调用.

通过 方法 而不是签名

该 [医]银型 参数可能是一个 方法，在这种情况下，完全绕过普通方法表查找，直接调用给定方法。 需要此功能并不常见。 特别要注意的是，指定 方法 普通调度（或普通调用）可能完全无法访问，例如，因为它被更具体的方法替换或完全复盖。 如果该方法是普通方法表的一部分，则此调用的行为类似于 调用（f，方法。sig，args。..).

兼容性

朱莉娅1.12通过a 方法 需要Julia1.12。

通过 [医]代码 而不是签名

该 [医]银型 参数可能是一个 [医]代码，绕过方法查找和特化。 此调用的语义类似于 [医]代码'的 调用 指针。 调用a是错误的 [医]代码 具有与其父级不匹配的参数 方法/方法 或来自一个不包括在 min_世界/最大世界 射程。 调用a是未定义的行为 [医]代码 其行为与其字段中指定的约束不匹配。 对于一些代码实例与 主人！==没什么 （即外部编译器生成的），在通过预编译后调用它们可能是错误的。 这是一个高级接口，用于外部编译器插件。

兼容性

朱莉娅1.12通过a [医]代码 需要Julia1.12。

例子

julia> f(x::Real) = x^2;

julia> f(x::Integer) = 1 + invoke(f, Tuple{Real}, x);

julia> f(2)
5

julia> f1(::Integer) = Integer
       f1(::Real) = Real;

julia> f2(x::Real) = _f2(x)
       _f2(::Integer) = Integer
       _f2(_) = Real;

julia> f1(1)
Integer

julia> f2(1)
Integer

julia> invoke(f1, Tuple{Real}, 1)
Real

julia> invoke(f2, Tuple{Real}, 1)
Integer
@invoke f(arg::T, ...; kwargs...)

提供了一个方便的呼叫方式 调用通过扩展 @invoke f(arg1::T1,arg2::T2;kwargs...) 到 调用(f,元组{T1,T2}，arg1，arg2;kwargs...). 当参数的类型注释被省略时，它将被替换为 核心。类型；类型 那个论点。 调用一个方法，其中一个参数是无类型的或显式类型为 任何，用注释参数 :：任何.

它还支持以下语法:

  • @invoke(x::X)。f 扩展到 调用（getproperty，元组{X,Symbol},x,:f)

  • @invoke(x::X)。f=v：：V 扩展到 调用（setproperty！,元组{X,Symbol,V},x,:f,v)

  • @invoke(xs::Xs)[i::I] 扩展到 调用(getindex,元组{Xs,I}，xs，i）

  • @invoke(xs::Xs)[i::I]=v::V 扩展到 调用（setindex！,元组{Xs,V,I}，xs，v，i）

例子

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))
兼容性

Julia1.7此宏需要Julia1.7或更高版本。
兼容性

Julia1.9此宏从Julia1.9导出。
兼容性

Julia1.10从Julia1.10开始支持附加语法。

 
invokelatest(f, args...; kwargs...)

电话 f(args...;夸格斯。..)，但保证了最新的方法 f 将被执行。 这在特殊情况下很有用，例如长时间运行的事件循环或可能调用函数过时版本的回调函数 f. （缺点是 invokelatest,invokelatest 比打电话慢一点 f 直接，并且结果的类型不能由编译器推断。)

兼容性

Julia1.9在Julia1.9之前，此函数未导出，并被调用为 基地。invokelatest,invokelatest.

 
@invokelatest f(args...; kwargs...)

提供了一个方便的呼叫方式 [医非专利]. @invokelatest f（args。..;夸格斯。..) 将简单地扩展到 基地。invokelatest(f,args...;夸格斯。..).

它还支持以下语法:

  • @invokelatest x.f 扩展到 基地。invokelatest(getproperty,x,:f)

  • @invokelatest x.f=v 扩展到 基地。invokelatest（setproperty！,x,:f,v)

  • @invokelatest xs[i] 扩展到 基地。invokelatest（getindex，xs，i）

  • @invokelatest xs[i]=v 扩展到 基地。invokelatest（setindex！，xs，v，i）

注意如果 f 是一个全球性的，它将在（最新的）世界中作为呼叫目标一致地解决。 但是，所有其他论点（以及 f 本身，如果它不是一个字面上的全球）将在当前的世界时代进行评估。
兼容性

Julia1.7此宏需要Julia1.7或更高版本。
兼容性

Julia1.9在Julia1.9之前，此宏未导出，并被称为 基地。@invokelatest.
兼容性

朱莉娅1.10附加 x.f 和 x[i] 语法要求Julia1.10。

 
new, or new{A,B,...}

内部构造函数可用的特殊函数，用于创建类型的新对象。 新表格{A,B,…​} 显式指定参数类型的参数值。 请参阅手册部分 内部构造函数方法以获取更多信息。

|>(x, f)

应用函数的中缀运算符 f 到论证 x. 这允许 f(g(x)) 要写 x/>g/>f. 当与匿名函数一起使用时，定义周围通常需要括号以获得预期的链。

例子

julia> 4 |> inv
0.25

julia> [2, 3, 5] |> sum |> inv
0.1

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14
f ∘ g

组成函数：即 (f≠g)(args...;夸格斯。..) 手段 f(g(args...;夸格斯。..)). 该 ∘ 符号可以通过键入在Julia REPL（和大多数编辑器，适当配置）中输入 \circ<tab>.

函数组合也以前缀形式工作: ∘(f,g) 是一样的 f＞g. 前缀形式支持多个函数的组合: ∘(f,g,h)=f∘g∘h 和飞溅 ∘(fs...) 用于组成可迭代的函数集合。 最后一个论点 ∘ 先执行。

兼容性

Julia1.4多功能组合至少需要Julia1.4。
兼容性

Julia1.5一个函数的组成∘（f）至少需要Julia1.5。
兼容性

Julia1.7使用关键字参数至少需要Julia1.7。

例子

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Vector{Char}:
 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
 'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
 'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)

julia> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

julia> fs = [
           x -> 2x
           x -> x-1
           x -> x/2
           x -> x+1
       ];

julia> ∘(fs...)(3)
2.0

请参阅 复合函数, !f::功能.

ComposedFunction{Outer,Inner} <: Function

表示两个可调用对象的组成 外::外 和 内::内. 那就是

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

构造一个实例的首选方法 复合函数 是使用组合运算符 ∘:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

组成的部分存储在 复合函数 并且可以如下检索:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true
兼容性

Julia1.6ComposedFunction至少需要Julia1.6。 在早期版本中 ∘ 返回一个匿名函数。

请参阅 ∘.

splat(f)

相当于

    my_splat(f) = args->f(args...)

即给定一个函数返回一个新函数，该函数接受一个参数并将其拆分到原始函数中。 作为适配器，这对于在需要单个参数的上下文中传递多参数函数非常有用，但将元组作为该单个参数传递。

例子

julia> map(splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6
Fix{N}(f, x)

表示函数的部分应用版本的类型 f，与论点 x 固定在位置 N::Int. 换句话说, 修复{3}(f,x) 行为类似于 (y1，y2，y3...;kws...）->f（y1，y2，x，y3。..;kws...).

兼容性

Julia1.12这个通用功能至少需要Julia1.12，而 修正1 和 修正2 更早可用。

嵌套多个时的注意事项 修复，请注意， N 在 修复{N} 是当前可用参数的_relative_，而不是目标函数的绝对排序。 例如, 修复{1}（修复{2}(f,4),4) 修复了第一个和第二个arg，而 修复{2}（修复{1}(f,4),4) 修复了第一个和第三个arg。

别名为 修复{1}. 见 修复.

别名为 修复{2}. 见 修复.

语法

Core.eval(m::Module, expr)

计算给定模块中的表达式并返回结果。

eval(expr)

计算包含模块的全局范围中的表达式。 每个 模块 （定义为 裸模,裸模）有一个私有的1参数定义 埃瓦尔，它计算该模块中的表达式，以便在该模块中使用。

@eval [mod,] ex

使用插值到表达式中的值计算表达式 埃瓦尔. 如果提供了两个参数，则第一个是要计算的模块。

evalfile(path::AbstractString, args::Vector{String}=String[])

使用以下方法将文件加载到匿名模块中 包括，计算所有表达式，并返回最后一个表达式的值。 可选项 阿格斯 参数可用于设置脚本的输入参数（即全局参数） 阿格斯 变量）。 请注意，定义（例如方法，全局变量）在匿名模块中进行评估，并且不会影响当前模块。

例子

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")
esc(e)

仅在一个上下文中有效 Expr从宏返回。 防止宏卫生传递将嵌入变量转换为gensym变量。 查看 宏手册元编程一章的部分，以获取更多细节和示例。

@inbounds(blk)

消除表达式内的数组边界检查。

在下面的示例中，引用元素的范围内检查 i 阵列的 A 被跳过以提高性能。

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i in eachindex(A)
        @inbounds r += A[i]
    end
    return r
end

使用警告 @inbounds 可能会为越界索引返回不正确的结果/崩溃/损坏。 用户负责手动检查。 只使用 @inbounds 当您确定所有访问都在边界中时（因为未定义的行为，例如崩溃，如果违反此断言，可能会发生）。 例如，使用 1:长度(A) 而不是 每个索引(A) 在像上面这样的函数中，由于第一个索引 A 可能不是 1 对于子类型的所有用户定义类型 抽象阵列.

 
@boundscheck(blk)

注释表达式 大厦 作为一个边界检查块，允许它被忽略 @inbounds.

注意其中的函数 @boundscheck 写入必须内联到其调用者中，以便 @inbounds 以产生效果。

例子

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accessing ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: attempt to access 2-element UnitRange{Int64} at index [-1]
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accessing (1:2)[-1]"

警告 @boundscheck annotation允许您作为库编写者选择允许_other code_删除您的边界检查 @inbounds. 如前所述，调用者必须使用他们可以访问的信息验证他们的访问是否有效，然后才能使用 @inbounds. 索引到您的 抽象阵列子类，例如，这涉及根据其检查索引 轴心. 因此, @boundscheck 注释只应添加到 getindex,getindex或 setindex！在你确定它的行为是正确的之后实现。

 
@propagate_inbounds

告诉编译器内联函数，同时保留调用方的inbounds上下文。

@inline

给编译器一个提示，这个函数值得内联。

小功能通常不需要 @内联 注释，正如编译器自动执行的那样。 通过使用 @内联 在更大的函数上，可以给编译器一个额外的轻推来内联它。

@内联 可以立即在函数定义之前或在函数体中应用。

# annotate long-form definition
@inline function longdef(x)
    ...
end

# annotate short-form definition
@inline shortdef(x) = ...

# annotate anonymous function that a `do` block creates
f() do
    @inline
    ...
end
兼容性

Julia1.8函数体内的用法至少需要Julia1.8。

 
@inline block

给内部调用的编译器一个提示 座 值得内联。

# The compiler will try to inline `f`
@inline f(...)

# The compiler will try to inline `f`, `g` and `+`
@inline f(...) + g(...)

注意callsite注释始终优先于应用于被调用函数定义的注释:

@noinline函数explicit_noinline（args。..)
    #身体
结束

让
    @inline explicit_noinline（args。..)#将内联
结束

注意当有嵌套的callsite注释时，最里面的注释具有优先级:

 
```朱莉娅
@noinline让a0，b0=。..
    a=@inline f(a0)#编译器将尝试内联此调用
    b=f(b0)#编译器不会尝试内联此调用
    返回a,b
结束
```

警告尽管callsite注释将尝试强制内联，而不管成本模型如何，但仍有可能无法成功。 特别是，递归调用不能内联，即使它们被注释为 @内联d.
兼容性

Julia1.8callsite注解至少需要Julia1.8。

 
@noinline

给编译器一个提示，它不应该内联函数。

小函数通常会自动内联。 通过使用 @noinline 在小功能上，可以防止自动内联。

@noinline 可以立即在函数定义之前或在函数体中应用。

# annotate long-form definition
@noinline function longdef(x)
    ...
end

# annotate short-form definition
@noinline shortdef(x) = ...

# annotate anonymous function that a `do` block creates
f() do
    @noinline
    ...
end
兼容性

Julia1.8函数体内的用法至少需要Julia1.8。

 
@noinline block

给编译器一个提示，它不应该内联调用 座.

# The compiler will try to not inline `f`
@noinline f(...)

# The compiler will try to not inline `f`, `g` and `+`
@noinline f(...) + g(...)

注意callsite注释始终优先于应用于被调用函数定义的注释:

@内联函数explicit_inline（args。..)
    #身体
结束

让
    @noinline explicit_inline（args。..)#不会内联
结束

注意当有嵌套的callsite注释时，最里面的注释具有优先级:

 
```朱莉娅
@inline让a0，b0=。..
    a=@noinline f(a0)#编译器不会尝试内联此调用
    b=f(b0)#编译器将尝试内联此调用
    返回a,b
结束
```
兼容性

Julia1.8callsite注解至少需要Julia1.8。

请注意，如果函数是微不足道的（例如返回一个常量），它可能会被内联。

 
@nospecialize

应用于函数参数名称，向编译器提示方法实现不应专门用于该参数的不同类型，而是使用该参数的声明类型。 它可以应用于形式参数列表中的参数，也可以应用于函数体中。 当应用于参数时，宏必须包装整个参数表达式，例如, @nospecialize(x::Real) 或 @nospecialize（i::Integer。..) 而不是只包装参数名称。 在函数体中使用时，宏必须出现在语句位置和任何代码之前。

在没有参数的情况下使用时，它适用于父范围的所有参数。 在局部作用域中，这意味着包含函数的所有参数。 在全局（顶级）范围中，这意味着随后在当前模块中定义的所有方法。

您可以使用以下方法重置回默认值 @专业.

function example_function(@nospecialize x)
    ...
end

function example_function(x, @nospecialize(y = 1))
    ...
end

function example_function(x, y, z)
    @nospecialize x y
    ...
end

@nospecialize
f(y) = [x for x in y]
@specialize

注 @nospecialize 影响代码生成但不影响推理：它限制了生成的本机代码的多样性，但它不会对类型推理施加任何限制（超出标准限制）。 使用方法 基地。@nospecializeinfer与 @nospecialize 以另外抑制推断。

例子

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

在这里， @nospecialize 注释结果相当于

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

确保只生成一个版本的本机代码 g，一个是通用的任何 抽象阵列. 但是，仍然为两者推断特定的返回类型 g 和 f，这仍然用于优化 f 和 g.

@specialize

将参数的特化提示重置为默认值。 有关详细信息，请参阅 @nospecialize.

Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

告诉编译器推断 f 使用已声明的 @nospecialized参数。 这可用于限制推理期间编译器生成的特化的数量。

例子

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

在这个例子中, f 将推断每个特定类型的 A，但是 g 只会用声明的参数类型推断一次 A::抽象阵列，这意味着编译器在无法推断其具体返回类型的情况下不会看到过多的推理时间。 没有 @nospecializeinfer, f([1.0]) 将推断返回类型 g 作为 漂浮64，表明推断为 g(::向量{Float64}) 尽管禁止专门的代码生成。

兼容性

Julia1.10使用 基地。@nospecializeinfer 需要Julia版本1.10。

 
Base.@constprop setting [ex]

控制带注释函数的过程间常数传播的模式。

二 设置支持s:

  • 基地。@constprop：咄咄逼人[ex]：积极应用恒定传播。 对于返回类型取决于参数值的方法，这可以以额外的编译时间为代价产生改进的推理结果。

  • 基地。@constprop:无[ex]：禁用常量传播。 这可以减少Julia认为值得常量传播的函数的编译时间。 常见的情况是功能与 布尔-或 符号-值参数或关键字参数。

基地。@constprop 可以立即在函数定义之前或在函数体中应用。

# annotate long-form definition
Base.@constprop :aggressive function longdef(x)
    ...
end

# annotate short-form definition
Base.@constprop :aggressive shortdef(x) = ...

# annotate anonymous function that a `do` block creates
f() do
    Base.@constprop :aggressive
    ...
end
兼容性

Julia1.10函数体内的用法至少需要Julia1.10。

 
gensym([tag])

生成一个不会与其他变量名（在同一模块中）冲突的符号。

@gensym

为变量生成gensym符号。 例如, @gensym x y 被转化为 x=gensym("x");y=gensym("y").

var

语法 var"示例" 引用一个名为 符号("例子")，尽管 例子 不是有效的Julia标识符名称。

这对于与具有用于构造有效标识符的不同规则的编程语言的互操作性非常有用。 例如，要参考 R 变量 画画。细分市场，您可以使用 var"画。段" 在你的朱莉娅密码里。

它还用于 展览 julia的源代码已经通过宏卫生或其他包含无法正常解析的变量名。

请注意，此语法需要解析器支持，因此它由解析器直接扩展，而不是作为普通字符串宏实现 @var_str.

兼容性

Julia1.3此语法至少需要Julia1.3。

 
@goto name

@后藤名 无条件跳转到该位置的语句 @标签名称.

@标签 和 @后藤 无法创建跳转到不同的顶级语句。 尝试会导致错误。 仍然使用 @后藤，附上 @标签 和 @后藤 在一个街区里。

@label name

用符号标签标记语句 姓名. 标签标志着无条件跳转的终点 @后藤名.

@simd

注释a 为 循环以允许编译器采取额外的自由以允许循环重新排序

警告此功能是实验性的，可能会在未来版本的Julia中更改或消失。 不正确使用 @simd 宏可能会导致意外的结果。

对象在一个 @simd for 循环应该是一维范围。 通过使用 @simd，你正在断言循环的几个属性:

*以任意或重叠顺序执行迭代是安全的，并特别考虑减少变量。 *减少变量上的浮点运算可以重新排序或收缩，可能会导致不同于没有的结果 @simd.

在许多情况下，Julia能够自动矢量化内部for循环，而无需使用 @simd. 使用 @simd 给编译器一点额外的余地，使其在更多的情况下成为可能。 在任何一种情况下，您的内部循环都应该具有以下属性以允许矢量化:

*循环必须是最内层的循环 *循环体必须是直线代码。 因此, @inbounds当前所有数组访问都需要。 编译器有时会变短 &&, ||，而 ?: 如果无条件地评估所有操作数是安全的，则表达式转换为直线代码。 考虑使用 ifelse功能而不是 ?: 在循环中，如果这样做是安全的。 *访问必须有一个步幅模式，不能是"聚集"（随机索引读取）或"分散"（随机索引写入）。 *步幅应为单位步幅。

注意 @simd 默认情况下不断言循环完全没有循环承载的内存依赖关系，这是一个在泛型代码中很容易违反的假设。 如果您正在编写非泛型代码，则可以使用 @simd ivdep为... 结束 还断言:

*不存在循环携带的内存依赖 *没有迭代会等待上一个迭代来向前推进。

@polly

告诉编译器将多面体优化器Polly应用于函数。

@generated f

@生成 用于注释将生成的函数。 在生成的函数的主体中，只能读取类型的参数（而不是值）。 函数返回调用函数时计算的带引号的表达式。 该 @生成 宏不应该用于改变全局范围的函数或依赖于可变元素。

见 元编程了解更多详情。

例子

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generic function with 1 method)

julia> bar(4)
16

julia> bar("baz")
"baz"
Base.@assume_effects setting... [ex]

复盖编译器的效果建模。 此宏可用于多种上下文:

  1. 紧接在方法定义之前，复盖应用方法的整个效果建模。

  2. 在没有任何参数的函数体中，复盖封闭方法的整个效果建模。

  3. 应用于代码块，以复盖所应用的代码块的局部效果建模。

例子

julia> Base.@assume_effects :terminates_locally function fact(x)
           # usage 1:
           # this :terminates_locally allows `fact` to be constant-folded
           res = 1
           0 ≤ x < 20 || error("bad fact")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # usage 2:
               # this :terminates_locally allows this anonymous function to be constant-folded
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("bad fact")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("bad fact")
               # usage 3:
               # with this :terminates_locally annotation the compiler skips tainting
               # `:terminates` effect within this `while` block, allowing the parent
               # anonymous function to be constant-folded
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}
兼容性

朱莉娅1.8使用 基地。@assume_effects 需要Julia版本1.8。
兼容性

Julia1.10函数体内的用法至少需要Julia1.10。
兼容性

Julia1.11代码块注释至少需要Julia1.11。

警告不当使用此宏会导致未定义的行为（包括崩溃，不正确的答案或其他难以跟踪的错误）。 使用时要小心,只有在绝对需要的情况下才作为最后的手段. 即使在这种情况下，您也应该采取所有可能的步骤来最小化效果断言的强度（例如，不要使用 :总计 如果 ：nothrow 本来就足够了）。

一般来说，每个 设置 value对函数的行为做出断言，而不要求编译器证明这种行为确实是正确的。 这些断言是为所有世界年龄。 因此，建议限制泛型函数的使用，这些泛型函数稍后可能会被扩展以使假设无效（这将导致未定义的行为）。

以下内容 设置s得到支持。

  • ：一致

  • ：effect_free

  • ：nothrow

  • :终止_全球

  • :终端_局部

  • ：notaskstate

  • ：inconcessiblemonly

  • ：noub

  • ：noub_if_noinbounds

  • :nortcall

  • :可折叠

  • :可拆卸

  • :总计

扩展帮助

：一致

该 ：一致 设置断言，对于egal（===)输入:

*终止的方式（返回值，异常，非终止）将始终相同。 *如果方法返回，结果将始终相等。

请注意，这特别意味着该方法不能返回新分配的可变对象。 可变对象的多个分配（即使具有相同的内容）也不是平等的。

注意 ：一致-cy断言是针对特定的世界范围作出的 R. 更正式地说，写 ᵢ 为评估 世界时代 ，那么这个设置需要:

增加我∈R,j∈R,x,y：x≡y→fᵢ(x)≡fⱼ(y)

为 @assume_effects，范围 R 是 m.primary_world：m.deleted_world 的注释或包含方法。

对于普通代码实例, R 是 慈min_world：ci。最大世界.

进一步的含义是 ：一致 函数不能使其返回值依赖于堆的状态或在给定的世界年龄范围内不恒定的任何其他全局状态。

注意 ：一致-cy包括优化器执行的所有合法重写。 例如，不考虑浮点fastmath操作 ：一致，因为优化器可能会重写它们导致输出不 ：一致，即使是同一个世界时代（例如，因为一个在解释器中运行，而另一个被优化）。

注意如果 ：一致 函数通过抛出异常终止，该异常本身不需要满足上面指定的egality要求。

：effect_free

该 ：effect_free 设置断言该方法没有外部语义上可见的副作用。 以下是外部语义上可见的副作用的不完整列表:

*更改全局变量的值。 *改变堆（例如数组或可变值），但下文指出的除外 *更改方法表（例如通过调用eval） *文件/网络/等。 I/O *任务切换

但是，以下内容在语义上是显式不可见的，即使它们可能是可观察的:

*内存分配（可变和不可变） *经过的时间 *垃圾收集 *生命周期不超过方法的对象的堆突变（即在方法中分配并且不转义）。 *返回的值（外部可见，但不是副作用）

这里的经验法则是，外部可见的副作用是任何会影响程序其余部分的执行，如果函数没有执行。

注意 ：effect_free 断言既针对方法本身，也针对方法执行的任何代码。 请记住，断言必须适用于所有世界年龄，并相应地限制使用此断言。

：nothrow

该 ：nothrow 设置断言此方法不会引发异常（即将始终返回值或从不返回）。

请注意，这是允许的 ：nothrow 带注释的方法，以在内部使用异常处理，只要异常不会从方法本身重新抛出。

注意如果方法的执行可能引发 方法；方法s和类似的例外，则该方法不被视为 ：nothrow. 但是，请注意，依赖于环境的错误，如 StackOverflowError 或 InterruptException异常 不是由这种效应建模的，因此是一种可能导致 StackOverflowError 不一定需要是 !：nothrow （虽然通常应该是 !:终止 过）。

:终止_全球

该 :终止_全球 设置断言此方法最终将终止（正常或异常），即不无限期循环。

注意这一点 :terminates_globally 断言复盖由带注释的方法调用的任何其他方法。

请注意，编译器将认为这是一个强烈的指示，该方法将相对_quickly_终止，并且可能（如果其他合法）在编译时调用此方法。 也就是说，在_technically_而不是_practically_终止的方法上注释此设置是一个坏主意。

:终端_locally

该 :终端_locally 设置就像 :终止_全球，不同之处在于它仅适用于语法控制流_within_the annotated方法。 因此，它是一个更弱（因此更安全）的断言，如果方法调用其他一些不终止的方法，则允许非终止的可能性。

注 :终止_全球 暗示 :终端_locally.

：notaskstate

该 ：notaskstate 设置断言该方法不使用或修改本地任务状态（任务本地存储，RNG状态等。），因此可以在没有可观察结果的情况下安全地在任务之间移动。

注意异常处理的实现利用了任务对象中存储的状态。 但是，这种状态目前不被认为是在 ：notaskstate 并使用 ：nothrow 效果。

注意 ：notaskstate 断言涉及_current running task_的状态。 如果一个引用 任务 对象是通过其他一些不考虑哪个任务正在运行的方法获得的， ：notaskstate 效果不需要被污染。 这是真的，即使所述任务对象恰好是 === 到当前运行的任务。

注意对任务状态的访问通常也会导致其他影响的污染，例如 ：effect_free （如果任务状态被修改）或 ：一致 （如果在计算结果时使用任务状态）。 特别是，不是的代码 ：notaskstate，但是 ：effect_free 和 ：一致 可能仍然是死代码消除，从而提升到 :总计.

：inconcessiblemonly

该 ：inconcessiblemonly 设置断言该方法不访问或修改外部可访问的可变内存。 这意味着该方法可以访问或修改新分配的对象的可变内存，这些对象在从该方法返回之前不能被其他方法或顶级执行访问，但它不能访问或修改其参数指向的任何可变全局状态或可变内存。

下面的注释是使此假设无效的示例的不完整列表:

 
-全球参考或 `[医]全球球` 访问可变全局变量的调用
-全局分配或 `setglobal！` 调用对非常量全局变量执行赋值

- `塞特菲尔德！` 更改全局可变变量字段的调用

注意这一点 ：inconcessiblemonly 断言涵盖了被注释方法调用的任何其他方法。

：noub

该 ：noub 设置断言该方法不会执行任何未定义的行为（对于任何输入）。 请注意，未定义的行为在技术上可能会导致方法违反任何其他效果断言（例如 ：一致 或 ：effect_free）以及，但我们没有对此进行建模，并且他们假设没有未定义的行为。

:nortcall

该 :nortcall 设置断言该方法不调用 核心。编译器。返回_类型，并且此方法可能调用的任何其他方法也不调用 核心。编译器。返回_类型.

确切地说，这个断言可以在调用 核心。编译器。返回_类型 不是在运行时进行的；也就是说，当 核心。编译器。返回_类型 在编译时确切地知道，并且优化器消除了调用。 然而，由于结果是否 核心。编译器。返回_类型 在编译时折叠在很大程度上取决于编译器的实现，如果有问题的方法使用，那么断言这个通常是有风险的 核心。编译器。返回_类型 以任何形式。

:可折叠

对于编译器需要保证在编译时常量折叠调用的一组效果，此设置是一个方便的快捷方式。 它目前相当于以下内容 设置s:

  • ：一致

  • ：effect_free

  • :terminates_globally

  • ：noub

  • :nortcall

注意此列表特别不包括 ：nothrow. 编译器仍然会尝试常量传播，并在编译时注意到任何抛出的错误。 但请注意，由 ：一致-cy要求，任何这样的带注释的调用必须一致地抛出给定相同的参数值。

注意一个明确的 @inbounds 函数内部的注释也将禁用常量折叠，而不会被复盖 :可折叠.

:可拆卸

对于编译器需要保证删除其结果在编译时未使用的调用的一组效果，此设置是一个方便的快捷方式。 它目前相当于以下内容 设置s:

  • ：effect_free

  • ：nothrow

  • :终止_全球

:总计

这 设置 是最大可能的效果集。 它目前意味着以下其他 设置s:

  • ：一致

  • ：effect_free

  • ：nothrow

  • :terminates_globally

  • ：notaskstate

  • ：inconcessiblemonly

  • ：noub

  • :nortcall

警告 :总计 是一个非常强大的断言，并且可能会在Julia的未来版本中获得额外的语义（例如，如果添加了额外的效果并包含在Julia的定义中 :总计). 因此，应该小心使用。 只要可能，优选使用特定应用所需的最小可能的特定效果断言集合。 在大量效果复盖应用于一组函数的情况下，建议使用自定义宏而不是使用 :总计.

否定效应

效果名称的前缀可以是 ! 以指示应从较早的元效应中移除该效应。 例如, ：总计！：nothrow 表示虽然调用通常是总计的，但它可能会抛出。

管理弃用

@deprecate old new [export_old=true]

弃用方法 老 并指定替换调用 新的，定义新方法 老 程中具有指定的签名。

为了防止 老 从被导出，设置 出口_old 到 错误.

请参阅 基地。德瓦恩().

兼容性

Julia1.5截至Julia1.5，由 @弃用 不要打印警告时 朱莉娅 是在没有 --depwarn=是 标志设置，作为默认值 --德瓦恩 选项是 非也。. 警告是从以下运行的测试中打印出来的 Pkg。测试().

例子

julia> @deprecate old_export(x) new(x)
old_export (generic function with 1 method)

julia> @deprecate old_public(x) new(x) false
old_public (generic function with 1 method)

致电 @弃用 没有显式的类型注释将定义弃用的方法，接受任意数量的类型的位置和关键字参数 任何.

兼容性

当Julia1.9没有显式类型注释时，将转发Julia1.9关键字参数。 对于旧版本，您可以通过执行以下操作手动转发位置参数和关键字参数 @弃用旧（args。..;夸格斯。..）新（args。..;夸格斯。..).

要将弃用限制为特定签名，请注释 老. 例如,

julia> new(x::Int) = x;

julia>new(x::Float64)=2x;

julia>@弃用旧(x::Int)新(x);

朱莉娅>方法(旧)
#1来自Main的泛型函数"old"的方法:
 [1]旧(x::Int64)
     @弃用。jl：94

将定义和弃用一个方法 旧(x::Int) 那镜子 新(x::Int) 但不会定义或弃用该方法 旧(X::Float64).

Base.depwarn(msg::String, funcsym::Symbol; force=false)

印刷业 味精 作为弃用警告。 符号 功能,功能 应该是调用函数的名称，用于确保只为每个调用地点第一次打印弃用警告。 套装 力=真 强制警告总是显示出来，即使茱莉亚是从 --depwarn=不 （默认）。

请参阅 @弃用.

例子

function deprecated_func()
    Base.depwarn("Don't use `deprecated_func()`!", :deprecated_func)

    1 + 1
end

缺失值

Missing

没有字段的类型，其单例实例 失踪用于表示缺失值。

请参阅: 跳板,跳板, nonmissingtype, 什么都没有.

missing

类型的单例实例 失踪表示缺失值。

请参阅: 南, 跳板,跳板, nonmissingtype.

coalesce(x...)

返回参数中的第一个值，该值不等于 失踪，如果有的话。 否则返回 失踪.

请参阅 跳板,跳板, 有些东西, @coalesce.

例子

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # returns `nothing`

julia> coalesce(missing, missing)
missing
@coalesce(x...)

短路版本的 聚结,聚结.

例子

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` is still missing")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` is still missing")
f(2)
f(3)
ERROR: `b` is still missing
[...]
兼容性

Julia1.7这个宏从Julia1.7开始可用。

 
ismissing(x)

指示是否 x 是 失踪.

请参阅: 跳板,跳板, 没有任何东西, 伊斯南.

skipmissing(itr)

返回一个迭代器，遍历 itr 跳绳 失踪值。 返回的对象可以使用 itr 如果后者是可转位的。 与缺失值对应的索引无效：它们被跳过 钥匙和 每个索引，和一 MissingException异常 试图使用它们时被抛出。

使用方法 收集资料获得一 阵列 包含非-失踪 价值 itr. 请注意，即使 itr 是一个多维数组，结果将始终是一个 向量资料 因为不可能在保留输入尺寸的同时删除缺失。

请参阅 聚结,聚结, 伊斯米辛, 有些东西.

例子

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

朱莉娅>总和(x)
3

朱莉娅>x[1]
1

朱莉娅>x[2]
错误：MissingException：缺少index(2,)处的值
[...]

朱莉娅>argmax(x)
3

朱莉娅>收集(钥匙(x))
2元素向量{Int64}:
 1
 3

朱莉娅>收集(skipmissing([1,失踪,2]))
2元素向量{Int64}:
 1
 2

朱莉娅>收集(skipmissing([1失踪;2失踪]))
2元素向量{Int64}:
 1
 2
nonmissingtype(T::Type)

如果 T 是包含的类型的联合 失踪，返回一个新的类型与 失踪 移走。

例子

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any
兼容性

Julia1.3此函数导出为Julia1.3。

系统

run(command, args...; wait::Bool = true)

运行一个用反引号构造的命令对象（请参阅 运行外部程序部分）。 如果出现任何错误，包括进程以非零状态退出（当 等等！ 是真的）。

该 args... 允许您将文件描述符传递给命令，并且像常规unix文件描述符一样排序（例如 stdin，stdout，stderr，FD（3），FD（4）。..).

如果 等等！ 为false，则进程异步运行。 您可以稍后等待它并通过调用来检查其退出状态 成功 返回的进程对象上。

何时 等等！ 为false，则进程’I/O流被定向到 德夫努尔. 何时 等等！ 是真的，I/O流与父进程共享。 使用方法 管道来控制I/O重定向。

devnull

在流重定向中使用，以丢弃写入其中的所有数据。 基本上等同于 /开发/空 在Unix或 NUL 在Windows上。 使用方法:

run(pipeline(`cat test.txt`, devnull))
success(command)

运行一个用反引号构造的命令对象（请参阅 运行外部程序部分），并告诉它是否成功（退出代码为0）。 如果进程无法启动，则会引发异常。

process_running(p::Process)

确定进程当前是否正在运行。

process_exited(p::Process)

确定进程是否已退出。

kill(p::Process, signum=Base.SIGTERM)

向进程发送信号。 默认是终止进程。 如果进程已经退出，则成功返回，但如果由于其他原因（例如权限不足）杀死进程失败，则会引发错误。

Sys.set_process_title(title::AbstractString)

设置进程标题。 在某些操作系统上没有操作。

Sys.get_process_title()

获取进程标题。 在某些系统上，将始终返回一个空字符串。

ignorestatus(command)

标记一个命令对象，以便在结果代码非零的情况下运行它不会引发错误。

detach(command)

标记一个命令对象，以便它将在一个新的进程组中运行，允许它比julia进程长，并且没有Ctrl-C中断传递给它。

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

构建一个新的 Cmd公司 对象，表示外部程序和参数，从 cmd公司，同时更改可选关键字参数的设置:

  • ignorestatus::Bool：如果 真的 （默认为 错误），则该 Cmd公司 如果返回代码非零，则不会抛出错误。

  • 分离::布尔：如果 真的 （默认为 错误），则该 Cmd公司 将在一个新的进程组中运行，使其比 朱莉娅 进程，而不是有Ctrl-C传递给它。

  • windows_verbatim::Bool：如果 真的 （默认为 错误），然后在Windows上 Cmd公司 将向进程发送一个命令行字符串，没有引用或转义参数，甚至包含空格的参数。 （在Windows上，参数作为单个"命令行"字符串发送到程序，程序负责将其解析为参数。 默认情况下，空参数和带空格或制表符的参数用双引号引起来 " 在命令行中，以及 \ 或 " 前面有反斜杠。 windows_verbatim=true 对于启动以非标准方式解析其命令行的程序非常有用。）对非Windows系统没有影响。

  • windows_hide::Bool：如果 真的 （默认为 错误），然后在Windows上，当 Cmd公司 被执行。 如果控制台已打开或在非Windows系统上，则此操作无效。

  • env：设置运行环境变量时使用 Cmd公司. env 是一个将字符串映射到字符串的字典，一个形式的字符串数组 "var=val"，数组或元组 "var"=>val 对。 为了修改（而不是替换）现有环境，初始化 env 与 副本(ENV) 然后设置 env["var"]=val 如所希望的。 要添加到一个环境块内 Cmd公司 对象而不替换所有元素，使用 addenv()这将返回一个 .adoc[] 对象与更新的环境。

  • dir::抽象字符串：指定命令的工作目录（而不是当前目录）。

对于未指定的任何关键字，当前设置从 cmd公司 被使用。

请注意， Cmd(执行) 构造函数不创建 执行董事. 任何后续更改 执行董事 将反映在 Cmd公司 对象。

最常见的构造方法 Cmd公司 对象带有命令文本（反引号），例如

`ls -l`

然后可以将其传递给 Cmd公司 修改其设置的构造函数，例如

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)
setenv(command::Cmd, env; dir)

设置运行给定环境时使用的环境变量 命令. env 是一个将字符串映射到字符串的字典，一个形式的字符串数组 "var=val"，或零或更多 "var"=>val 对参数。 为了修改（而不是替换）现有环境，创建 env 通过 副本(ENV) 然后设置 env["var"]=val 根据需要，或使用 增补,增补.

该 署长 关键字参数可用于指定命令的工作目录。 署长 默认为当前设置 署长 为 命令 （如果尚未指定，则为当前工作目录）。

请参阅 Cmd公司, 增补,增补, ENV, 残疾人士.

addenv(command::Cmd, env...; inherit::Bool = true)

将新的环境映射合并到给定的 Cmd公司对象，返回一个新的 Cmd公司 对象。 重复的键被替换。 如果 命令 不包含已设置的任何环境值，它在 addenv() 如果 继承 是 真的. 带值键 什么都没有 从env中删除。

请参阅 Cmd公司, setenv, ENV.

兼容性

Julia1.6此功能需要Julia1.6或更高版本。

 
withenv(f, kv::Pair...)

执行 f 在临时修改的环境中（不像在 setenv)由零或更多 "var"=>val 争论 千伏,千伏. withenv 通常通过 withenv(kv...）做。.. 结束 语法。 的值 什么都没有 可用于临时取消设置环境变量（如果已设置）。 何时 withenv 返回，原来的环境已经恢复。

警告更改环境不是线程安全的。 对于使用与父进程不同的环境运行外部命令，首选使用 增补,增补结束 withenv.

 
shell_escape(args::Union{Cmd,AbstractString...}; special::AbstractString="")

未报告的 贝壳形,贝壳形 函数是未报告的倒数 基地。shell_split（）函数：它接受一个字符串或命令对象，并以这样一种方式转义任何特殊字符，即调用 基地。shell_split（）上面会给出原始命令中的单词数组。 该 特别 关键字参数控制除了空格、反斜杠、引号和美元符号之外的哪些字符被认为是特殊的（默认：无）。

例子

julia> Base.shell_escape("cat", "/foo/bar baz", "&&", "echo", "done")
"cat '/foo/bar baz' && echo done"

julia> Base.shell_escape("echo", "this", "&&", "that")
"echo this && that"
shell_split(command::AbstractString)

将shell命令字符串拆分为其各个组件。

例子

julia> Base.shell_split("git commit -m 'Initial commit'")
4-element Vector{String}:
 "git"
 "commit"
 "-m"
 "Initial commit"
shell_escape_posixly(args::Union{Cmd,AbstractString...})

未报告的 贝壳_escape_posixly 函数接受字符串或命令对象并转义任何特殊字符，以便将其作为参数传递给posix shell是安全的。

请参阅: 基地。shell_escape()

例子

julia> Base.shell_escape_posixly("cat", "/foo/bar baz", "&&", "echo", "done")
"cat '/foo/bar baz' '&&' echo done"

julia> Base.shell_escape_posixly("echo", "this", "&&", "that")
"echo this '&&' that"
shell_escape_csh(args::Union{Cmd,AbstractString...})
shell_escape_csh(io::IO, args::Union{Cmd,AbstractString...})

此函数在字符串参数中引用任何元字符，以便返回的字符串可以插入到命令行中，以便由Unix c shell（csh，tcsh）进行解释，其中每个字符串参数将形成一个单词。

与POSIX shell相反，csh不支持在双引号字符串中使用反斜杠作为一般转义字符。 因此，此函数将可能包含元字符的字符串包装在单引号中，但包含单引号的部分除外，而是将单引号包装在双引号中。 它根据需要在这些类型的引号之间切换。 换行符用反斜杠转义。

此函数也应该适用于POSIX shell，除非输入字符串包含换行符（"\n"）性格。

请参阅: 基地。shell_escape_posixly（）

shell_escape_wincmd(s::AbstractString)
shell_escape_wincmd(io::IO, s::AbstractString)

未报告的 shell_escape_wincmd 函数转义窗口 cmd。exe文件 shell元字符。 它逃脱了 ()!^<>&| 通过放置一个 ^ 在前面。 一个 @ 仅在字符串开头转义。 对的 " 字符和它们所包含的字符串是通过非转义传递的. 任何剩余 " 被逃脱了 ^ 确保未转义的数目 " 结果中的字符保持均匀。

自 cmd。exe文件 替代变量引用（如 %用户%)_before_处理转义字符 ^ 和 "，此函数不尝试转义百分号（%），存在 % 在输入可能会导致严重的破损，这取决于在哪里使用的结果。

输入字符串与ASCII控制字符不能转义（NUL，CR，LF）将导致一个 [医]争论者 例外。

结果可以安全地作为参数传递给正在处理的命令调用 CMD。exe/S/C"。.. " （与周围的双引号对），并将由目标应用程序逐字接收，如果输入不包含 % （否则此功能将失败与ArgumentError）。 的存在 % 在输入字符串中可能会导致命令注入漏洞，并可能使此函数输出作为cmd参数的适用性的任何声明无效（由于上面描述的顺序），因此在从各种来源组装字符串时要小心。

此功能可能与 窗口_verbatim 旗帜至 Cmd公司构建过程管道时。

wincmd(c::String) =
   run(Cmd(Cmd(["cmd.exe", "/s /c \" $c \""]);
           windows_verbatim=true))
wincmd_echo(s::String) =
   wincmd("echo " * Base.shell_escape_wincmd(s))
wincmd_echo("hello $(ENV["USERNAME"]) & the \"whole\" world! (=^I^=)")

但请注意，如果输入字符串 s 包含一个 %，参数列表和echo’ed文本可能会损坏，导致任意命令执行。 该参数也可以作为环境变量传递，这避免了 % 以及对 窗口_verbatim 国旗:

cmdargs = Base.shell_escape_wincmd("Passing args with %cmdargs% works 100%!")
run(setenv(`cmd /C echo %cmdargs%`, "cmdargs" => cmdargs))

警告CMD在调用批处理文件时所做的参数解析（无论是在 .蝙蝠 文件或作为它们的参数）与此函数的输出不完全兼容。 特别是，处理 % 是不同的。

!!! 由于CMD解析器/解释器的特殊行为，每个命令后面都有文字 | 符（表示命令管道）必须具有 shell_escape_wincmd 应用两次，因为它将被CMD解析两次。 这意味着ENV变量也会被扩展两次！ 例如:

```朱莉娅
to_print="All for1&1for all!"
to_print_esc=Base。shell_escape_wincmd(Base.shell_escape_wincmd（to_print））
运行（Cmd（Cmd（["cmd"，"/S/C\"break|echo$（to_print_esc）\""]），windows_verbatim=true））
```

带有I/O流参数 伊俄，结果将写在那里，而不是作为字符串返回。

请参阅 基地。escape_microsoft_c_args（）, 基地。shell_escape_posixly（）.

例子

julia> Base.shell_escape_wincmd("a^\"^o\"^u\"")
"a^^\"^o\"^^u^\""
escape_microsoft_c_args(args::Union{Cmd,AbstractString...})
escape_microsoft_c_args(io::IO, args::Union{Cmd,AbstractString...})

将字符串参数集合转换为可传递给许多Windows命令行应用程序的字符串。

Microsoft Windows将整个命令行作为单个字符串传递给应用程序（与POSIX系统不同，其中shell将命令行拆分为参数列表）。 许多Windows API应用程序（包括julia。exe)，使用https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments[微软C/C++ 运行时]将该命令行拆分为字符串列表。

此函数为与这些规则兼容的解析器实现逆。 它连接要传递给Windows C/C的命令行参数++/Julia应用到命令行中，在需要的地方转义或引用元字符空格、制表符、双引号和反斜杠。

请参阅 基地。shell_escape_wincmd（）, 基地。escape_raw_string（）.

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

设置cpu亲和性的 命令 通过CPU Id列表（基于1） 中央处理器. 传球 cpu=无 表示如果 原创性_command 有没有。

此功能仅在Linux和Windows中受支持。 MacOS中不支持它，因为libuv不支持关联设置。

兼容性

Julia1.8此功能至少需要Julia1.8。

例子

在Linux中， 任务集 命令行程序可以用来查看如何 [医]血性 有效。

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

注意掩码值 13 反映第一，第二和第五位（从最低有效位置计数）导通:

julia> 0b010011
0x13
pipeline(from, to, ...)

创建从数据源到目标的管道。 源和目标可以是命令、I/O流、字符串或其他的结果 管道 电话。 至少有一个参数必须是命令。 字符串是指文件名。 当使用两个以上的参数调用时，它们从左到右链接在一起。 例如, 管道(a,b,c) 相当于 管道（管道（a，b），c）. 这提供了一种更简洁的方式来指定多级管道。

例子:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))
pipeline(command; stdin, stdout, stderr, append=false)

将I/O重定向到或从给定的 命令. 关键字参数指定应该重定向哪个命令的流。 追加 控制文件输出是否追加到文件。 这是2参数的更一般版本 管道 函数。 管道（从，到） 相当于 流水线(from,stdout=to) 何时 从 是一个命令，并 管道(to,stdin=from) 何时 从 是另一种数据源。

例子:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))
gethostname() -> String

获取本地计算机的主机名。

getpid() -> Int32

获取Julia的进程ID。

getpid(process) -> Int32

获取子进程ID，如果它仍然存在。

兼容性

Julia1.1此功能至少需要Julia1.1。

 
time() -> Float64

获取自epoch以来的系统时间（以秒为单位），具有相当高（通常为微秒）的分辨率。

请参阅 时间_ns.

time_ns() -> UInt64

获取相对于过去某些机器特定的任意时间的纳秒时间。 主要用途是测量程序执行期间的运行时间。 在系统运行时，返回值保证是单调的（mod2⁶⁴），并且不受时钟漂移或本地日历时间更改的影响，但它可能会在系统重新启动或暂停期间任意更改。

（虽然返回的时间总是以纳秒为单位，但定时分辨率取决于平台。)

@time expr
@time "description" expr

一个执行表达式的宏，在返回表达式的值之前，打印执行所用的时间、分配数以及执行导致分配的总字节数。 垃圾收集(gc)、编译新代码或重新编译无效代码所花费的任何时间都以百分比显示。 任何锁冲突的地方 重入锁,重入锁不得不等待显示为计数。

可选地提供要在时间报告之前打印的描述字符串。

在某些情况下，系统将查看 @时间 表达式并在顶级表达式开始执行之前编译一些被调用的代码。 当这种情况发生时，一些编译时间将不计算在内。 要包括这段时间，您可以运行 @时间@eval。...

请参阅 @表演时间, @timev, @定时, @经过, @分配，和 @分配.

注意对于更严重的基准测试，请考虑 @btime 从BenchmarkTools宏。jl包，其中除其他外，多次评估函数以减少噪声。
兼容性

Julia1.8在Julia1.8中引入了添加描述的选项。

 
在Julia1.8中引入了与编译时间分开显示的重新编译时间
兼容性

Julia1.11在Julia1.11中添加了任何锁冲突的报告。

 
julia> x = rand(10,10);

julia> @time x * x;
  0.606588 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)

julia> @time x * x;
  0.000009 seconds (1 allocation: 896 bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)
@showtime expr

像 @时间 但也打印正在计算的表达式以供参考。

兼容性

Julia1.8这个宏是在Julia1.8中添加的。

请参阅 @时间.

julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)
@timev expr
@timev "description" expr

这是一个详细的版本 @时间 宏。 它首先打印与 @时间，然后任何非零内存分配计数器，然后返回表达式的值。

可选地提供要在时间报告之前打印的描述字符串。

兼容性

Julia1.8在Julia1.8中引入了添加描述的选项。

请参阅 @时间, @定时, @经过, @分配，和 @分配.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1
@timed

一个执行表达式的宏，并返回表达式的值，以秒为单位的经过时间，分配的总字节，垃圾回收时间，具有各种内存分配计数器的对象，以秒为单位的编译时间， 任何锁冲突的地方 重入锁,重入锁不得不等待显示为计数。

在某些情况下，系统将查看 @定时 表达式并在顶级表达式开始执行之前编译一些被调用的代码。 当这种情况发生时，一些编译时间将不计算在内。 要包括这段时间，您可以运行 @定时@eval。...

请参阅 @时间, @timev, @经过, @分配, @分配，和 @lock_conflicts.

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0
兼容性

Julia1.5这个宏的返回类型从 元组 到 命名的,命名的 在朱莉娅1.5。
兼容性

朱莉娅1.11 锁,锁, 编译时间，而 重新编译_时间 在Julia1.11中添加了字段。

 
@elapsed

一个计算表达式的宏，丢弃结果值，而不是作为浮点数返回执行所需的秒数。

在某些情况下，系统将查看 @经过 表达式并在顶级表达式开始执行之前编译一些被调用的代码。 当这种情况发生时，一些编译时间将不计算在内。 要包括这段时间，您可以运行 @经过@eval。...

请参阅 @时间, @timev, @定时, @分配，和 @分配.

julia> @elapsed sleep(0.3)
0.301391426
@allocated

计算表达式的宏，丢弃结果值，而返回在计算表达式期间分配的总字节数。

如果表达式是函数调用，则会努力仅测量参数表达式和函数期间的分配，排除调用它的任何开销，并且不使用提供的参数值执行常量传播。 如果要包含这些效果，即测量呼叫站点，请使用以下语法 @分配(()->f(1))().

建议只用简单的参数表达式来测量函数调用，例如 x=[];@分配f(x) 而不是 @分配f([]) 为了澄清这一点 f 正在测量。

对于更复杂的表达式，代码只是在适当的位置运行，因此可能会看到由于周围上下文而产生的分配。 例如，这是可能的 @分配f(1) 和 @分配x=f(1) 以给出不同的结果。

请参阅 @分配, @时间, @timev, @定时，和 @经过.

julia> @allocated rand(10^6)
8000080
@allocations

一个计算表达式的宏，放弃结果值，而是返回计算表达式期间的分配总数。

请参阅 @分配, @时间, @timev, @定时，和 @经过.

julia> @allocations rand(10^6)
2
兼容性

Julia1.9这个宏是在Julia1.9中添加的。

 
@lock_conflicts

一个用于计算表达式的宏，丢弃结果值，而是返回在计算过程中锁定冲突的总数，其中锁定尝试 重入锁,重入锁导致等待，因为锁已经持有。

请参阅 @时间, @timev和 @定时.

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5
兼容性

Julia1.11这个宏是在Julia1.11中添加的。

 
EnvDict() -> EnvDict

此类型的单例为环境变量提供了哈希表接口。

ENV

对单例的引用 环境,环境，为系统环境变量提供字典接口。

（在Windows上，系统环境变量不区分大小写，并且 ENV 相应地将所有键转换为大写，以便显示，迭代和复制。 可移植代码不应该依赖于按大小写区分变量的能力，并且应该注意设置表面上小写的变量可能会导致大写 ENV 钥匙。)

警告改变环境不是线程安全的。

例子

julia> ENV
Base.EnvDict with "50" entries:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "username"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

请参阅: withenv, 增补,增补.

Sys.STDLIB::String

一个字符串，包含指向包含 stdlib 包裹。

Sys.isunix([os])

用于测试操作系统是否提供类Unix接口的谓词。 请参阅 处理操作系统变化。

Sys.isapple([os])

谓词用于测试操作系统是否是Apple Macintosh OS x或Darwin的衍生物。 请参阅 处理操作系统变化。

Sys.islinux([os])

谓词，用于测试操作系统是否是Linux的衍生物。 请参阅 处理操作系统变化。

Sys.isbsd([os])

谓词，用于测试OS是否是bsd的衍生物。 请参阅 处理操作系统变化。

请注意，达尔文内核是从BSD下降的，这意味着 系统。isbsd() 是 真的 在macOS系统上。 要从谓词中排除macOS，请使用 系统。isbsd()&&!系统。苹果().

 
Sys.isfreebsd([os])

谓词用于测试操作系统是否是FreeBSD的衍生物. 请参阅 处理操作系统变化。

注意不要与混淆 系统。isbsd()，这是 真的 在FreeBSD上，也在其他基于Bsd的系统上。 系统。isfreebsd() 仅指FreeBSD。
兼容性

Julia1.1此功能至少需要Julia1.1。

 
Sys.isopenbsd([os])

谓词，用于测试操作系统是否是OpenBSD的衍生物。 请参阅 处理操作系统变化。

注意不要与混淆 系统。isbsd()，这是 真的 在OpenBSD上，也在其他基于BSD的系统上。 系统。isopenbsd() 仅指OpenBSD。
兼容性

Julia1.1此功能至少需要Julia1.1。

 
Sys.isnetbsd([os])

谓词，用于测试操作系统是否是NetBSD的衍生物。 请参阅 处理操作系统变化。

注意不要与混淆 系统。isbsd()，这是 真的 在NetBSD上，也在其他基于BSD的系统上。 系统。isnetbsd() 仅指NetBSD。
兼容性

Julia1.1此功能至少需要Julia1.1。

 
Sys.isdragonfly([os])

谓词用于测试操作系统是否是DragonFly BSD的衍生物。 请参阅 处理操作系统变化。

注意不要与混淆 系统。isbsd()，这是 真的 在蜻蜓上，也在其他基于BSD的系统上。 系统。鹿isdragonfly 仅指蜻蜓。
兼容性

Julia1.1此功能至少需要Julia1.1。

 
Sys.iswindows([os])

谓词，用于测试操作系统是否是Microsoft Windows NT的衍生版本。 请参阅 处理操作系统变化。

Sys.windows_version()

返回Windows NT内核的版本号作为 版本号，即 v"少校。未成年人。建造"，或 v"0.0.0" 如果这不是在Windows上运行。

Sys.free_memory()

以字节为单位获取RAM中的总可用内存。

Sys.total_memory()

以字节为单位获取RAM中的总内存（包括当前使用的内存）。 这个数量可能会受到限制，例如Linux控制组。 有关无约束量，请参阅 系统。total_physical_memory().

Sys.free_physical_memory()

以字节为单位获取系统的可用内存。 整个金额可能无法用于当前流程;使用 系统。自由记忆() 为实际可用的量。

Sys.total_physical_memory()

以字节为单位获取RAM中的总内存（包括当前使用的内存）。 整个金额可能无法用于当前流程;请参阅 系统。total_memory().

Sys.uptime()

在几秒钟内获得当前系统的正常运行时间。

Sys.isjsvm([os])

用于测试Julia是否在JavaScript VM（JSVM）中运行的谓词，包括例如在web浏览器中嵌入WebAssembly JavaScript。

兼容性

Julia1.2此功能至少需要Julia1.2。

 
Sys.loadavg()

得到负载平均值。 见:https://en.wikipedia.org/wiki/Load_（计算）。

isexecutable(path::String)

回来吧 真的 如果给定 路径 具有可执行权限。

注意此权限可能会在用户执行之前更改 路径，所以建议执行文件并在失败时处理错误，而不是调用 isexecutable的 首先。

请注意，在Julia1.6之前，它没有正确地询问Windows上的文件系统Acl，因此它将返回 真的 对于任何文件。 从Julia1.6开始，它正确地确定文件是否标记为可执行文件。

请参阅 ispath, 可读性, iswritable缧.

isreadable(path::String)

回来吧 真的 如果给定的访问权限 路径 允许当前用户阅读。

注意此权限可能会在用户调用之前更改 打开，所以建议直接打电话 打开 单独处理错误，如果失败，而不是调用 可读性 首先。

注意目前此函数不能正确查询Windows上的文件系统Acl，因此它可能返回错误的结果。
兼容性

Julia1.11此功能至少需要Julia1.11。

请参阅 ispath, isexecutable的, iswritable缧.

isreadable(io) -> Bool

回来吧 错误 如果指定的IO对象不可读。

例子

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")
iswritable(path::String)

回来吧 真的 如果给定的访问权限 路径 当前用户允许写入。

注意此权限可能会在用户调用之前更改 打开，所以建议直接打电话 打开 单独处理错误，如果失败，而不是调用 iswritable缧 首先。

注意目前此函数不能正确查询Windows上的文件系统Acl，因此它可能返回错误的结果。
兼容性

Julia1.11此功能至少需要Julia1.11。

请参阅 ispath, isexecutable的, 可读性.

iswritable(io) -> Bool

回来吧 错误 如果指定的IO对象不可写。

例子

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")
Sys.username() -> String

返回当前用户的用户名。 如果用户名无法确定或为空，此函数将引发错误。

检索可通过环境变量复盖的用户名，例如, 用户，考虑使用

user = get(Sys.username, ENV, "USER")
兼容性

Julia1.11此功能至少需要Julia1.11。

请参阅 首页.

@static

在宏扩展时部分评估表达式。

这在构造在某些情况下无效的情况下很有用，例如 ccall 到依赖于操作系统的函数，或在未导入的包中定义的宏。

@静态 需要一个条件。 条件可以在 如果 语句，三元运算符，或 &&`||`. 条件是通过递归扩展宏、降低和执行结果表达式来计算的。 然后，返回匹配的分支（如果有的话）。 条件的所有其他分支在宏展开（并降低或执行）之前被删除。

例子

假设我们要解析一个表达式 expr 这仅在macOS上有效。 我们可以用 @静态 与 @static if Sys。isapple()expr结束. 万一我们有 expr_苹果 适用于macOS和 其他人 对于其他操作系统，解决方案与 @静态 会是 @静态Sys。isapple（）？ expr_apple：expr_others.

版本控制

VersionNumber

遵循以下规范的版本号类型https://semver.org/spec/v2.0.0-rc.2.html[语义版本控制（semver）]，由主要，次要和补丁数字值组成，然后是预发布和构建字母数字注释。

版本号 对象可以与所有标准比较运算符（==, <, <= 等。），结果如下semver v2.0.0-rc。2规则。

版本号 具有以下公共字段:

  • v.主要::整数

  • v.minor::整数

  • v.补丁::整数

  • v.预发行::元组{Vararg{Union{Integer, AbstractString}}}

  • 五、build::元组{Vararg{Union{Integer, AbstractString}}}

请参阅 @v_str有效地建造 版本号 来自semver的对象-格式文字字符串, 版本为 版本号 朱莉娅本身，和 版本号文字。

例子

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

julia> b >= v"2.0.1"
false
@v_str

字符串宏，用于将字符串解析为 版本号.

例子

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

错误

error(msg...)

提出一个 ErrorException异常 用一个由 字符串（味精。..).

error(message::AbstractString)

提出一个 ErrorException异常 与给定的消息。

throw(e)

抛出一个对象作为异常。

请参阅: 重新思考, 错误.

rethrow()

从内部重新抛出当前异常 渔获 块。 Rethrown异常将继续传播，就好像它没有被捕获一样。

注意替代形式 重新思考(e) 允许您关联替代异常对象 e 随着目前的倒退。 但是，这会在错误发生时歪曲程序状态，因此鼓励您使用以下方法引发新的异常 投掷(e). 在Julia1.1及以上版本中，使用 投掷(e) 将保留堆栈上的根本原因异常，如 当前概念.

 
backtrace()

获取当前程序点的backtrace对象。

catch_backtrace()

获取当前异常的回溯，以供内 渔获 街区。

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

获取当前正在处理的异常堆栈。 对于嵌套的catch块，可能存在多个当前异常，在这种情况下，最近抛出的异常是堆栈中的最后一个。 堆栈返回为 [医]常规草堆 它是命名元组的AbstractVector （例外，回溯）. 如果 后退,后退 为false，则每对中的backtrace将设置为 什么都没有.

显式传递 任务 将返回任意任务上的当前异常堆栈。 这对于检查由于未捕获异常而失败的任务非常有用。

兼容性

Julia1.7这个函数按实验名称去了 草堆() 在Julia1.1—​1.6中，并有一个简单的元组向量作为返回类型。

 
@assert cond [text]

扔一个 断言错误如果 康德 是 错误. 这是编写断言的首选语法，断言是假定为true的条件，但用户可能会决定检查，以便在失败时进行调试。 可选消息 文本 在断言失败时显示。

警告在某些优化级别可能会禁用assert。 因此，Assert应仅用作调试工具，而不用于身份验证验证（例如，验证密码或检查数组边界）。 代码不能依赖于运行的副作用 康德 为函数的正确行为。

例子

julia> @assert iseven(3) "3 is an odd number!"
ERROR: AssertionError: 3 is an odd number!

julia> @assert isodd(3) "What even are numbers?"
Experimental.register_error_hint(handler, exceptiontype)

注册"提示"功能 处理程序（io，异常） 这可以为用户提供规避错误的潜在方法。 处理程序 应检查 例外情况 查看是否满足适合提示的条件，如果满足，则生成输出到 伊俄. 包裹应该打电话 register_error_hint 从他们的内部 __init__ 函数。

对于特定的异常类型, 处理程序 需要接受额外的参数:

  • 方法；方法：提供 处理程序(io,exc::MethodError,argtypes,kwargs)，它将组合参数拆分为位置参数和关键字参数。

发出提示时，输出通常应以 \n.

如果您定义自定义异常类型，您的 n.淋浴器 方法可以通过调用支持提示 实验性的。show_error_hints.

例子

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # Color is not necessary, this is just to show it's possible.
                    print(io, "\nDid you mean to call ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

如果你打电话 欣特只有_int 在一个不是 Int型 （从而触发一个 方法；方法），它发出提示:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
The function `only_int` exists, but no method is defined for this combination of argument types.
Did you mean to call `any_number`?
Closest candidates are:
    ...
兼容性

Julia1.5自定义错误提示自Julia1.5起可用。

警告此接口是实验性的,如有更改或删除,恕不另行通知. 要使自己免受更改的影响，请考虑将任何注册放在 if isdefined(Base.实验，：register_error_hint）。.. 结束 块。

 
Experimental.show_error_hints(io, ex, args...)

从 实验性的。register_error_hint对于特定的异常类型 类型(ex). 阿格斯 必须包含该类型的处理程序期望的任何其他参数。

兼容性

Julia1.5自定义错误提示自Julia1.5起可用。

警告此接口是实验性的,如有更改或删除,恕不另行通知.

 
ArgumentError(msg)

传递给函数的参数无效。 味精 是描述性错误消息。

AssertionError([msg])

断言的条件没有评估到 真的. 可选参数 味精 是描述性错误字符串。

例子

julia> @assert false "this is not true"
ERROR: AssertionError: this is not true

断言错误 通常是从 @断言.

BoundsError([a],[i])

数组的索引操作, a，试图访问索引处的越界元素 i.

例子

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]


julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]
CompositeException

包装一个 向量资料 由a抛出的异常 任务（例如，从通道上的远程工作程序生成，或异步执行本地I/O写入或下的远程工作程序生成 pmap）与有关的一系列异常的信息。 例如，如果一组工作程序正在执行多个任务，并且多个工作程序失败，则结果 CompositeException 将包含来自每个worker的信息"捆绑"，指示异常发生的位置和原因。

DimensionMismatch([msg])

调用的对象不具有匹配的维数。 可选参数 味精 是描述性错误字符串。

DivideError()

整数除法尝试分母值为0。

例子

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]
DomainError(val)
DomainError(val, msg)

论点 瓦尔 函数或构造函数在有效域之外.

例子

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]
EOFError()

没有更多的数据可用于从文件或流中读取。

ErrorException(msg)

泛型错误类型。 错误消息，在 .味精 字段，可以提供更具体的细节。

例子

julia> ex = ErrorException("I've done a bad thing");

julia> ex.msg
"I've done a bad thing"
FieldError(type::DataType, field::Symbol)

试图访问无效的操作 领域 在一个对象 类型.

兼容性

Julia1.12在Julia1.12之前，无效的字段访问抛出了一个 ErrorException异常

见 盖菲尔德

例子

julia> struct AB
          a::Float32
          b::Float64
       end

julia> ab = AB(1, 3)
AB(1.0f0, 3.0)

朱莉娅>ab。c#字段 `c` 不存在
错误：FieldError：AB型没有字段 `c`，可用字段: `a`, `b`
[医]堆垛机:
[...]
InexactError(name::Symbol, T, val)

不能完全转换 瓦尔 要键入 T 函数的方法中 姓名.

例子

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]
InterruptException()

该过程被终端中断（CTRL+C）停止。

请注意，在Julia脚本中没有 -我 (互动)选项, InterruptException异常 默认情况下不抛出。 打电话来 基地。exit_on_sigint(false)在脚本中可以恢复REPL的行为。 或者，可以从Julia脚本开始

julia -e "include(popfirst!(ARGS))" script.jl

让 InterruptException异常 在执行过程中由CTRL+c抛出。

KeyError(key)

将索引操作转换为 摘要;摘要 (Dict,Dict)或 套装 像对象试图访问或删除一个不存在的元素。

LoadError(file::AbstractString, line::Int, error)

同时发生错误 包括ing, 要求ing，或 使用一个文件。 错误细节应该在 .错误 场。

兼容性

Julia1.7LoadErrors不再由 @macroexpand, @macroexpand1，而 宏扩展 截至朱莉娅1.7。

 
MethodError(f, args)

给定的泛型函数中不存在具有所需类型签名的方法。 或者，没有唯一的最具体的方法。

MissingException(msg)

当 失踪值在不支持的情况下遇到。 错误消息，在 味精 字段可以提供更具体的细节。

OutOfMemoryError()

操作为系统或垃圾回收器分配了太多内存，无法正确处理。

ReadOnlyMemoryError()

试图写入只读内存的操作。

OverflowError(msg)

表达式的结果对于指定的类型来说太大，并且会导致包装。

ProcessFailedException

指示进程有问题的退出状态。 当运行命令或管道时，这被抛出以指示返回非零退出代码（即调用的进程失败）。

TaskFailedException

这个异常是由一个 等待(t)任务时呼叫 t 失败。 TaskFailedException异常 包装失败的任务 t.

StackOverflowError()

函数调用超出了调用堆栈的大小。 这通常发生在调用无限递归时。

SystemError(prefix::AbstractString, [errno::Int32])

系统调用失败，并带有错误代码（在 厄尔诺 全局变量）。

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

类型断言失败，或使用不正确的参数类型调用内部函数。

UndefKeywordError(var::Symbol)

所需的关键字参数 瓦尔 未在函数调用中分配。

例子

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1
UndefRefError()

没有为给定对象定义项或字段。

例子

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]
UndefVarError(var::Symbol, [scope])

未定义当前范围中的符号。

例子

julia> a
ERROR: UndefVarError: `a` not defined in `Main`

julia> a = 1;

julia> a
1
StringIndexError(str, i)

尝试访问时出错 斯特拉 在索引 i 这是无效的。

InitError(mod::Symbol, error)

运行模块时发生错误 __init__ 函数。 抛出的实际错误可在 .错误 场。

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

返回一个调用函数的匿名函数 f. 如果出现例外情况, f 被重复地再次调用，每次 支票 申报表 真的，在等待指定的秒数后 延误. 支票 应输入 延误目前的状态和 例外情况.

兼容性

Julia1.2在Julia1.2之前此签名仅限于 f::功能.

例子

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)
ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

A 漂浮64长度的迭代器 n 其元素以区间内的速率呈指数增长 因素 * (1 ± 抖动,抖动). 第一个元素是 第一，第二 所有元素都被夹紧到 max_delay.

活动

Timer(callback::Function, delay; interval = 0, spawn::Union{Nothing,Bool}=nothing)

创建一个运行函数的计时器 回调；回调 在每个定时器到期。

等待任务被唤醒和功能 回调；回调 在初始延迟后调用 延迟 秒，然后用给定的重复 间隔时间 几秒钟内。 如果 间隔时间 等于 0，回调只运行一次。 的功能 回调；回调 用一个参数调用，即计时器本身。 通过调用停止计时器 接近/接近. 该 回调；回调 如果计时器已经过期，仍然可以运行最后一次。

如果 产卵,产卵 是 真的，创建的任务将被产生，这意味着它将被允许移动线程，这避免了强制父任务卡在它所在的线程上的副作用。 如果 产卵,产卵 是 什么都没有 （默认），如果父任务不粘，则会生成该任务。

兼容性

朱莉娅1.12 产卵,产卵 论证在Julia1.12中引入。

例子

这里第一个数字在延迟两秒后打印，然后快速打印下面的数字。

julia> begin
           i = 0
           cb(timer) = (global i += 1; println(i))
           t = Timer(cb, 2, interval=0.2)
           wait(t)
           sleep(0.5)
           close(t)
       end
1
2
3
Timer(delay; interval = 0)

创建一个定时器，唤醒等待它的任务（通过调用 等等！在定时器对象上）。

等待任务至少在初始延迟后被唤醒 延迟 秒，然后在至少之后重复 间隔时间 秒又过去了。 如果 间隔时间 等于 0，定时器只触发一次。 当计时器关闭时（由 接近/接近)等待的任务会被错误唤醒。 使用方法 isopen的检查计时器是否仍处于活动状态。 使用方法 t.超时 和 t.间隔 要读取a的设置条件 定时器 t.

julia> t = Timer(1.0; interval=0.5)
Timer (open, timeout: 1.0 s, interval: 0.5 s) @0x000000010f4e6e90

julia> isopen(t)
true

julia> t.timeout
1.0

julia> close(t)

julia> isopen(t)
false

注 间隔时间 受到累积时间偏斜的影响。 如果您需要在特定的绝对时间精确事件，请在每次到期时创建一个新的计时器，并计算到下一次的差异。

注A 定时器 需要屈服点来更新其状态。 例如, isopen(t::定时器) 不能用于超时非屈服的while循环.

 
AsyncCondition()

创建唤醒等待它的任务的异步条件（通过调用 等等！在对象上）当通过调用从C通知到 uv_async_发送. 当对象关闭时，等待的任务会被错误唤醒（由 接近/接近). 使用方法 isopen的来检查它是否仍然处于活动状态。

这提供了发送线程和等待线程之间的隐式获取和释放内存顺序。

AsyncCondition(callback::Function)

创建调用给定的异步条件 回调；回调 函数。 该 回调；回调 传递一个参数，即异步条件对象本身。

反射;反射

nameof(m::Module) -> Symbol

获取a的名称 模块 作为一个 符号.

例子

julia> nameof(Base.Broadcast)
:Broadcast
parentmodule(m::Method) -> Module

返回给定方法所在的模块 m 被定义。

兼容性

朱莉娅1.9通过a 方法 作为一个参数需要Julia1.9或更高版本。

 
parentmodule(f::Function, types) -> Module

确定包含泛型函数的第一个方法的模块 f 匹配指定的 类别.

parentmodule(f::Function) -> Module

确定包含泛型函数的（第一个）定义的模块。

parentmodule(t::DataType) -> Module

确定包含定义a的模块（可能 联合所有-包装) 数据类型.

例子

julia> module Foo
           struct Int end
       end
Foo

julia> parentmodule(Int)
Core

julia> parentmodule(Foo.Int)
Foo
parentmodule(m::Module) -> Module

获取模块的封闭 模块. 主要 是它自己的父母。

请参阅: 姓名, 名称；名称, 全名, @__模块__.

例子

julia> parentmodule(Main)
Main

julia> parentmodule(Base.Broadcast)
Base
pathof(m::Module)

返回的路径 m.jl 用于的文件 进口 模块 m，或 什么都没有 如果 m 不是从包导入的。

使用方法 迪拉姆获取目录部分和 基本名称来获取路径的文件名部分。

请参阅 pkg迪尔.

pkgdir(m::Module[, paths::String...])

返回声明模块的包的根目录 m，或 什么都没有 如果 m 没有在一个包中声明。 可选地，还可以提供进一步的路径组件字符串来构造包根目录内的路径。

要获取实现当前模块的包的根目录，请使用表单 pkgdir(@__模块__) 可以使用。

如果给出了扩展模块，则返回父包的根。

julia> pkgdir(Foo)
"/path/to/Foo.jl"

julia> pkgdir(Foo, "src", "file.jl")
"/path/to/Foo.jl/src/file.jl"

请参阅 [医路径].

兼容性

Julia1.7可选参数 路径 至少需要Julia1.7。

 
pkgversion(m::Module)

返回导入模块的包的版本 m，或 什么都没有 如果 m 不是从包导入的，也不是从没有设置版本字段的包导入的。

版本是从包的项目中读取的。包加载期间的toml。

要获取导入当前模块的包的版本，请使用表单 pkgversion(@__模块__) 可以使用。

兼容性

Julia1.9这个函数是在Julia1.9中引入的。

 
moduleroot(m::Module) -> Module

查找给定模块的根模块。 这是父模块链中的第一个模块 m 它要么是注册的根模块，要么是它自己的父模块。

# __模块__-密码_

__module__

论点 __模块__ 仅在宏内部可见，它提供信息（以 模块 对象）关于宏调用的扩展上下文。 请参阅手册部分 宏调用以获取更多信息。

# __来源__-密码_

__source__

论点 __来源__ 仅在宏内部可见，它提供信息（以 N.线,线 对象）关于解析器的位置 @ 从宏调用中签名。 请参阅手册部分 宏调用以获取更多信息。

# 基地。@__模块__-马科罗_

@__MODULE__ -> Module

获取 模块 的顶层eval，这是 模块 目前正在读取代码。

# 基地。@__文件__-马科罗_

@__FILE__ -> String

展开为一个字符串，其中包含宏调用的文件的路径，或者一个空字符串，如果由 朱莉娅-e<expr>. 回来吧 什么都没有 如果宏缺少解析器源信息。 或者参见 程序文件.

# 基地。@__DIR__-马科罗_

@__DIR__ -> String

宏以字符串的形式获取当前目录的绝对路径。

如果在脚本中，则返回包含 @__DIR__ 宏观球。 如果从REPL运行或通过 朱莉娅-e<expr>，返回当前工作目录。

例子

这个例子说明了 @__DIR__ 和 残疾人士()，通过在与当前工作目录不同的目录中创建一个简单脚本并执行这两个命令:

julia> cd("/home/JuliaUser") # working directory

julia> # create script at /home/JuliaUser/Projects
       open("/home/JuliaUser/Projects/test.jl","w") do io
           print(io, """
               println("@__DIR__ = ", @__DIR__)
               println("pwd() = ", pwd())
           """)
       end

julia> # outputs script directory and current working directory
       include("/home/JuliaUser/Projects/test.jl")
@__DIR__ = /home/JuliaUser/Projects
pwd() = /home/JuliaUser

# 基地。@__线__-马科罗_

@__LINE__ -> Int

扩展到宏调用位置的行号。 回来吧 0 如果无法确定行号。

fullname(m::Module)

获取模块的完全限定名称作为符号元组。 例如,

例子

julia> fullname(Base.Iterators)
(:Base, :Iterators)

julia> fullname(Main)
(:Main,)
names(x::Module; all::Bool=false, imported::Bool=false, usings::Bool=false) -> Vector{Symbol}

获取a的公共名称的向量 模块，不包括已弃用的名称。 如果 全部 为true，那么该列表还包括在模块中定义的非公共名称，不推荐使用的名称和编译器生成的名称。 如果 进口 是真的，那么从其他模块显式导入的名称也包括在内。 如果 使用方法 为true，则通过以下方式显式或隐式导入名称 使用 也包括在内。 名称按排序顺序返回。

作为一个特例，所有定义在 主要 被认为是"公开的"，因为明确地标记名称不是惯用的 主要 作为公众。

注 系统名称(SomeModule) 是否暗示 定义(SomeModule,sym). 姓名 可返回标有 公众人士 或 出口，即使它们没有在模块中定义。

警告 姓名 可能会返回重复的名称。 重复发生，例如，如果 进口ed名称与已存在的标识符冲突。
兼容性

朱莉娅1.12 使用方法 参数需要Julia1.12或更高版本。

请参阅: 基地。isexported, 基地。公共的,公共的, 基地。@当地人, @__模块__.

isexported(m::Module, s::Symbol) -> Bool

返回是否从模块导出符号。

请参阅: 公共的,公共的, 姓名

julia> module Mod
           export foo
           public bar
       end
Mod

julia> Base.isexported(Mod, :foo)
true

julia> Base.isexported(Mod, :bar)
false

julia> Base.isexported(Mod, :baz)
false
ispublic(m::Module, s::Symbol) -> Bool

返回一个符号是否在模块中标记为public。

导出的符号被认为是公共的。

兼容性

Julia1.11在Julia1.11中增加了这个功能和宣传的概念。

请参阅: isexported, 姓名

julia> module Mod
           export foo
           public bar
       end
Mod

julia> Base.ispublic(Mod, :foo)
true

julia> Base.ispublic(Mod, :bar)
true

julia> Base.ispublic(Mod, :baz)
false
nameof(f::Function) -> Symbol

获取泛型的名称 功能 作为符号。 对于匿名函数，这是编译器生成的名称。 对于显式声明的子类型 功能，它是函数类型的名称。

functionloc(f::Function, types)

返回一个元组 （文件名，行） 给出一个通用的位置 功能 定义。

functionloc(m::Method)

返回一个元组 （文件名，行） 给出一个 方法 定义。

@locals()

构造一个包含调用站点定义的所有局部变量的名称（作为符号）和值的字典。

兼容性

Julia1.1这个宏至少需要Julia1.1。

例子

julia> let x = 1, y = 2
           Base.@locals
       end
Dict{Symbol, Any} with 2 entries:
  :y => 2
  :x => 1

julia> function f(x)
           local y
           show(Base.@locals); println()
           for i = 1:1
               show(Base.@locals); println()
           end
           y = 2
           show(Base.@locals); println()
           nothing
       end;

julia> f(42)
Dict{Symbol, Any}(:x => 42)
Dict{Symbol, Any}(:i => 1, :x => 42)
Dict{Symbol, Any}(:y => 2, :x => 42)
getglobal(module::Module, name::Symbol, [order::Symbol=:monotonic])

检索绑定的值 姓名 从模块 模块. 可选地，可以为操作定义原子排序，否则它默认为单调。

访问模块绑定时使用 盖菲尔德仍然支持保持兼容性，使用 [医]全球球 应始终首选，因为 [医]全球球 允许控制原子排序（盖菲尔德 总是单调的），并且更好地向用户和编译器表示代码的意图。

大多数用户不应该直接调用这个函数-- 获得财产函数或相应的语法（即 module.name）应该在除了少数非常具体的用例之外的所有情况下都是首选。

兼容性

Julia1.9此功能需要Julia1.9或更高版本。

请参阅 获得财产和 setglobal！.

例子

julia> a = 1
1

julia> module M
       a = 2
       end;

julia> getglobal(@__MODULE__, :a)
1

julia> getglobal(M, :a)
2
setglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

设置或更改绑定的值 姓名 在模块中 模块 到 x. 不执行类型转换，因此如果已经为绑定声明了类型, x 必须是适当的类型，否则会引发错误。

此外，可以为此操作指定原子排序，否则它默认为单调。

用户通常会通过 setproperty！函数或相应的语法（即 module.name =x）相反，所以这只适用于非常具体的用例。

兼容性

Julia1.9此功能需要Julia1.9或更高版本。

请参阅 setproperty！和 [医全球球]

例子

julia> module M; global a; end;

julia> M.a  # same as `getglobal(M, :a)`
ERROR: UndefVarError: `a` not defined in `M`
Suggestion: add an appropriate import or assignment. This global was declared but not assigned.
Stacktrace:
 [1] getproperty(x::Module, f::Symbol)
   @ Base ./Base_compiler.jl:40
 [2] top-level scope
   @ none:1

julia> setglobal!(M, :a, 1)
1

julia> M.a
1
modifyglobal!(module::Module, name::Symbol, op, x, [order::Symbol=:monotonic]) -> Pair

在应用函数后，原子地执行获取和设置全局的操作 op的.

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

请参阅 modifyproperty！和 setglobal！.

swapglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

原子地执行操作以同时获取和设置全局。

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

请参阅 swapproperty！和 setglobal！.

setglobalonce!(module::Module, name::Symbol, value,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

原子地执行将全局设置为给定值的操作，只有在以前未设置全局值的情况下。

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

请参阅 setpropertyonce！和 setglobal！.

replaceglobal!(module::Module, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

原子地执行操作以获取并有条件地将全局设置为给定值。

兼容性

Julia1.11此功能需要Julia1.11或更高版本。

请参阅 更换产品！和 setglobal！.

文件

（另请参阅 文档章节。)

文件

函数、方法和类型可以通过在定义之前放置一个字符串来记录:

"""
    foo(x)

Return a fooified version of `x`.
"""
foo(x) = ...

该 @doc 宏可以直接用于设置和检索文档/元数据。 宏具有特殊的解析，以便记录的对象可能出现在下一行:

@doc "blah"
function foo() ...

默认情况下，文档编写为Markdown，但任何对象都可以用作第一个参数。

将对象与其定义分开记录

您可以在对象定义之前或之后使用

@doc "foo" function_to_doc
@doc "bar" TypeToDoc

对于宏，语法为 @doc"宏doc":(模块。@宏） 或 @doc"宏doc"：（string_macro""） 对于字符串宏。 没有报价 :() 宏的扩展将被记录下来。

检索文档

您可以检索函数、宏和其他对象的文档，如下所示:

@doc foo
@doc @time
@doc md""

功能和方法

将文档放在方法定义之前（例如 函数foo()。.. 或 foo（）=。..）将导致该特定方法被记录，而不是整个函数。 方法文档按照定义的顺序连接在一起，以便为函数提供文档。

HTML("<div>foo</div>")

您还可以将流用于大量数据:

HTML() do io
  println(io, "<div>foo</div>")
end

警告 HTML格式 当前导出是为了保持向后兼容性，但不赞成此导出。 建议使用这种类型作为 文件。HTML格式或从显式导入 文件.

文本(s)：创建一个渲染的对象 s 作为纯文本。

Text("foo")

您还可以将流用于大量数据:

Text() do io
  println(io, "foo")
end

警告 文本 当前导出是为了保持向后兼容性，但不赞成此导出。 建议使用这种类型作为 文件。文本或从显式导入 文件.

 
Docs.hasdoc(mod::Module, sym::Symbol)::Bool

回来吧 真的 如果 西姆 在 国防部 有一个docstring和 错误 否则。

undocumented_names(mod::Module; private=false)

返回未记录符号的排序向量 模块 （即缺乏docstrings）。 私人=错误 （默认值）仅返回声明为 公众人士 和/或 出口，而 私人=真 返回模块中的所有符号（不包括编译器生成的以 #).

请参阅: 姓名, 文件。哈斯多克, 基地。公共的,公共的.

代码加载

Base.identify_package(name::String)::Union{PkgId, Nothing}
Base.identify_package(where::Union{Module,PkgId}, name::String)::Union{PkgId, Nothing}

从当前环境堆栈中按其名称标识包，返回其 PkgId,PkgId，或 什么都没有 如果找不到。

如果只有 姓名 提供了参数，它搜索堆栈中的每个环境及其命名的直接依赖项。

该 哪里 argument提供了从哪里搜索包的上下文：在这种情况下，它首先检查名称是否与上下文本身匹配，否则它搜索所有递归依赖项（从每个环境的已解析清单中），直到 哪里，并从那里识别具有相应名称的依赖关系。

julia> Base.identify_package("Pkg") # Pkg is a dependency of the default environment
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]

julia> using LinearAlgebra

julia> Base.identify_package(LinearAlgebra, "Pkg") # Pkg is not a dependency of LinearAlgebra
Base.locate_package(pkg::PkgId)::Union{String, Nothing}

标识符对应的包的入口点文件的路径 pkg,pkg，或 什么都没有 如果没有找到。 请参阅 标识_包装.

julia> pkg = Base.identify_package("Pkg")
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]

julia> Base.locate_package(pkg)
"/path/to/julia/stdlib/v1.12/Pkg/src/Pkg.jl"
require(into::Module, module::Symbol)

此功能是实现的一部分 使用 / 进口，如果模块尚未在 主要. 它也可以直接调用以强制重新加载模块，而不管它之前是否已加载（例如，在交互式开发库时）。

加载源文件，在 主要 模块，在每个活动节点上，搜索文件的标准位置。 要求 被认为是顶级操作，因此它设置当前 包括 路径，但不使用它来搜索文件（请参阅帮助 包括). 此函数通常用于加载库代码，并由 使用 来加载包。

搜索文件时, 要求 首先在全局数组中查找包代码 LOAD_PATH. 要求 在所有平台上都区分大小写，包括那些不区分大小写的文件系统，如macOS和Windows。

有关代码加载的更多详细信息，请参阅 模块和 并行计算。

Base.compilecache(module::PkgId)

为模块及其所有依赖项创建预编译缓存文件。 这可用于减少包加载时间。 缓存文件存储在 DEPOT_PATH[1]/编译. 见 模块初始化和预编译的重要注意事项。

Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)

返回活动项目中的给定PkgId是否已预编译。

默认情况下，此检查遵循代码加载所采用的相同方法，即当前将不同版本的依赖项加载到预期的依赖项。 要忽略加载的模块并像在新的julia会话中那样回答指定 ignore_loaded=true.

兼容性

Julia1.10此功能至少需要Julia1.10。

 
get_extension(parent::Module, extension::Symbol)

返回模块 扩展 的 家长/家长 或返回 什么都没有 如果未加载扩展。

内部件

GC.gc([full=true])

执行垃圾回收。 论点 全 确定集合的类型：完整集合（默认）遍历所有活动对象（即完整标记），并应从所有无法访问的对象中回收内存。 增量集合仅从无法访问的年轻对象中回收内存。

即使请求了增量收集，GC也可以决定执行完整收集。

警告过度使用可能会导致性能不佳。

 
GC.enable(on::Bool)

使用布尔参数控制是否启用垃圾回收（真的 对于已启用, 错误 为残疾人士)。 返回以前的GC状态。

警告禁用垃圾回收应谨慎使用，因为它可能导致内存使用增长而不绑定。

 
GC.@preserve x1 x2 ... xn expr

标记对象 x1，x2，。.. 在表达式的计算过程中作为_in use_ expr. 这只在不安全的代码中需要 expr _impl隐式使用内存或由其中一个拥有的其他资源 xs.

[计]用途 x 涵盖逻辑上拥有的资源的任何间接使用 x 编译器看不到的。 一些例子:

*直接通过访问对象的内存 Ptr *将指针传递到 x 到 ccall *使用 x 这将在终结器中清理。

@保留 在短暂延长对象生存期的典型用例中，通常不应该对性能产生任何影响。 在实施中, @保留 具有保护动态分配的对象免受垃圾回收等效果。

例子

当从指针加载与 卸载/卸载，底层对象被隐式地使用，例如 x 被隐式地使用 卸载(p) 在以下:

julia> let
           x = Ref{Int}(101)
           p = Base.unsafe_convert(Ptr{Int}, x)
           GC.@preserve x unsafe_load(p)
       end
101

当传递指针到 ccall，指向对象是隐式使用的，应该保留。 （但请注意，您通常应该只是通过 x 直接至 ccall 这是一个明确的使用。)

julia> let
           x = "Hello"
           p = pointer(x)
           Int(GC.@preserve x @ccall strlen(p::Cstring)::Csize_t)
           # Preferred alternative
           Int(@ccall strlen(x::Cstring)::Csize_t)
       end
5
GC.safepoint()

在程序中插入一个可能运行垃圾回收的点。

安全点很快,本身不会触发垃圾收集. 但是，如果另一个线程请求GC运行，则到达安全点将导致当前线程阻塞并等待GC。

在一些任务分配内存（因此可能需要运行GC）但其他任务只执行简单操作（没有分配，任务切换或I/O）的多线程程序中，这在极少数情况下非常有用，这些操作 在非分配任务中定期调用此函数允许垃圾回收运行。

请注意，即使安全点很快（通常在2个时钟周期左右），如果在紧密循环中调用，它们仍然会降低性能。

兼容性

Julia1.4此功能自Julia1.4起可用。

 
GC.enable_logging(on::Bool)

打开时，将有关每个GC的统计信息打印到stderr。

GC.logging_enabled()

通过以下方式返回是否启用了GC日志记录 GC。n.封存,封存.

lower(m, x)

接受表达式 x 并返回一个降低形式的等效表达式，以便在模块中执行 m. 请参阅 [医鳕鱼].

@lower [m] x

返回表达式的降低形式 x 在模块中 m. 默认情况下 m 是调用宏的模块。 请参阅 较低.

parse(str, start; greedy=true, raise=true, depwarn=true, filename="none")

解析表达式字符串并返回一个表达式（稍后可以传递给eval执行）。 开始 是代码单元索引成 斯特拉 开始解析的第一个字符（与所有字符串索引一样，这些不是字符索引）。 如果 贪婪 是 真的 (默认), 解析,解析 将尝试消耗尽可能多的输入，否则，一旦解析了有效的表达式，它就会停止。 不完整但在语法上有效的表达式将返回 Expr(:不完整,"(错误消息)"). 如果 加薪 是 真的 （默认），不完整表达式以外的语法错误将引发错误。 如果 加薪 是 错误, 解析,解析 将返回一个表达式，该表达式将在计算时引发错误。 如果 德普瓦恩 是 错误，弃用警告将被抑制。 该 文件名 参数用于在引发错误时显示诊断。

julia> Meta.parse("(α, β) = 3, 5", 1) # start of string
(:((α, β) = (3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 1, greedy=false)
(:((α, β)), 9)

julia> Meta.parse("(α, β) = 3, 5", 16) # end of string
(nothing, 16)

julia> Meta.parse("(α, β) = 3, 5", 11) # index of 3
(:((3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 11, greedy=false)
(3, 13)
parse(str; raise=true, depwarn=true, filename="none")

贪婪地解析表达式字符串，返回单个表达式。 如果第一个表达式后面有其他字符，则会引发错误。 如果 加薪 是 真的 （默认），语法错误将引发错误;否则, 解析,解析 将返回一个表达式，该表达式将在计算时引发错误。 如果 德普瓦恩 是 错误，弃用警告将被抑制。 该 文件名 参数用于在引发错误时显示诊断。

julia> Meta.parse("x = 3")
:(x = 3)

julia> Meta.parse("1.0.2")
ERROR: ParseError:
# Error @ none:1:1
1.0.2
└──┘ ── invalid numeric constant
[...]

朱莉娅>元。解析("1.0.2";提高=错误)
:($(Expr(:error, "invalid numeric constant "1.0."")))

朱莉娅>元。解析("x=")
:($(Expr(:incomplete, "incomplete: premature end of input")))
ParseError(msg)

传递给 解析,解析函数不能被解释为有效的Julia表达式。

QuoteNode

一段带引号的代码，不支持插值。 查看 关于QuoteNodes的手册部分了解详情。

macroexpand(m::Module, x; recursive=true)

取表达式 x 并返回一个等价表达式，其中删除（展开）所有宏以便在模块中执行 m. 该 递归 关键字控制是否也扩展嵌套宏的更深层次。 下面的示例演示了这一点:

julia> module M
           macro m1()
               42
           end
           macro m2()
               :(@m1())
           end
       end
M

julia> macroexpand(M, :(@m2()), recursive=true)
42

julia> macroexpand(M, :(@m2()), recursive=false)
:(#= REPL[16]:6 =# M.@m1)
@macroexpand [mod,] ex

返回删除（展开）所有宏的等效表达式。 如果提供了两个参数，则第一个是要计算的模块。

之间存在差异 @macroexpand 和 宏扩展.

*同时 宏扩展接受关键字参数 递归, @macroexpand 总是递归的。 有关非递归宏版本，请参阅 @macroexpand1. *同时 宏扩展有明确的 模块 论点, @macroexpand 始终相对于调用它的模块展开。

这在以下示例中最好看到:

julia> module M
           macro m()
               1
           end
           function f()
               (@macroexpand(@m),
                macroexpand(M, :(@m)),
                macroexpand(Main, :(@m))
               )
           end
       end
M

julia> macro m()
           2
       end
@m (macro with 1 method)

julia> M.f()
(1, 1, 2)

与 @macroexpand 表达式在哪里展开 @macroexpand 出现在代码（模块 M 例中）。 与 宏扩展 表达式在作为第一个参数给出的模块中展开。

兼容性

Julia1.11双参数形式至少需要Julia1.11。

 
@macroexpand1 [mod,] ex

非递归版本的 @macroexpand.

code_lowered(f, types; generated=true, debuginfo=:default)

为匹配给定泛型函数和类型签名的方法返回降低形式（IR）的数组。

如果 生成的 是 错误，返回 代码信息 实例将对应于回退实现。 如果不存在回退实现，则会引发错误。 如果 生成的 是 真的，这些 代码信息 实例将对应于通过扩展生成器产生的方法体。

关键字 debuginfo,debuginfo 控制输出中存在的代码元数据量。

请注意，如果 类别 不是具体类型时 生成的 是 真的 和任何相应的方法是一个 @生成 方法。

code_typed(f, types; kw...)

返回匹配给定泛型函数和类型签名的方法的类型推断降低形式（IR）数组。

关键字参数

  • 优化::Bool=true:可选，控制是否也应用其他优化，例如内联。

  • debuginfo::符号=:默认值：可选，控制输出中存在的代码元数据的数量，可能的选项有 :资料来源 或 :无.

内部关键字参数

本节应该被认为是内部的，并且只适用于理解Julia编译器内部的人。

  • 世界::UInt=基地。get_world_counter()：可选，控制查找方法时使用的世界年龄，如果没有指定，请使用当前世界年龄。

  • interp::核心。编译器。AbstractInterpreter=核心。编译器。NativeInterpreter(世界)：可选，控制抽象解释器使用，如果未指定，请使用本机解释器。

例子

可以将参数类型放在元组中以获取相应的 代码类型.

julia> code_typed(+, (Float64, Float64))
1-element Vector{Any}:
 CodeInfo(
1 ─ %1 = Base.add_float(x, y)::Float64
└──      return %1
) => Float64
precompile(f, argtypes::Tuple{Vararg{Any}}, m::Method)

预编译给定参数类型的特定方法。 这可以用于预编译与通常由dispatch选择的方法不同的方法，从而模拟 调用.

precompile(f, argtypes::Tuple{Vararg{Any}})

编译给定的函数 f 对于参数元组（类型） [医]银型，但不执行它。

Base.jit_total_bytes()

返回just-in-time编译器为例如本机代码和数据分配的总量（以字节为单位）。

元,元

Meta.quot(ex)::Expr

引用表达式 前 用head生成表达式 报价. 例如，这可以用来表示类型的对象 Expr 在AST。 另请参阅手册部分关于 QuoteNode。

例子

julia> eval(Meta.quot(:x))
:x

julia> dump(Meta.quot(:x))
Expr
  head: Symbol quote
  args: Array{Any}((1,))
    1: Symbol x

julia> eval(Meta.quot(:(1+2)))
:(1 + 2)
Meta.isexpr(ex, head[, n])::Bool

回来吧 真的 如果 前 是一个 Expr 与给定的类型 头 并且可选的参数列表是长度的 n. 头 可能是一个 符号 或收集 符号例如，要检查宏是否传递了函数调用表达式，您可以使用 isexpr(ex,:呼叫).

例子

julia> ex = :(f(x))
:(f(x))

julia> Meta.isexpr(ex, :block)
false

julia> Meta.isexpr(ex, :call)
true

julia> Meta.isexpr(ex, [:block, :call]) # multiple possible heads
true

julia> Meta.isexpr(ex, :call, 1)
false

julia> Meta.isexpr(ex, :call, 2)
true
 isidentifier(s) -> Bool

返回符号还是字符串 s 包含在Julia代码中被解析为有效的普通标识符（不是二进制/一元运算符）的字符;另请参阅 基地。等效器,等效器.

内部Julia允许任何字符序列 符号 （除 \0s），并且宏自动使用包含 # 以避免与周围代码的命名冲突。 为了使解析器识别一个变量，它使用一组有限的字符（由Unicode大大扩展）。 科学() 使得可以直接查询解析器符号是否包含有效字符。

例子

julia> Meta.isidentifier(:x), Meta.isidentifier("1x")
(true, false)
isoperator(s::Symbol)

回来吧 真的 如果符号可以用作运算符, 错误 否则。

例子

julia> Meta.isoperator(:+), Meta.isoperator(:f)
(true, false)
isunaryoperator(s::Symbol)

回来吧 真的 如果符号可以用作一元（前缀）运算符, 错误 否则。

例子

julia> Meta.isunaryoperator(:-), Meta.isunaryoperator(:√), Meta.isunaryoperator(:f)
(true, true, false)
isbinaryoperator(s::Symbol)

回来吧 真的 如果符号可以用作二进制（中缀）运算符, 错误 否则。

例子

julia> Meta.isbinaryoperator(:-), Meta.isbinaryoperator(:√), Meta.isbinaryoperator(:f)
(true, false, false)
Meta.show_sexpr([io::IO,], ex)

显示表达 前 作为lisp风格的s-表达式。

例子

julia> Meta.show_sexpr(:(f(x, g(y,z))))
(:call, :f, :x, (:call, :g, :y, :z))