Основные элементы

Введение

Стандартная библиотека Julia содержит множество функций и макросов, подходящих для научных и численных вычислений, но также столь же обширна, как и библиотеки многих языков программирования общего назначения. Дополнительные возможности доступны из постоянно растущего набора доступных пакетов. Функции сгруппированы по темам ниже.

Некоторые общие замечания:

• За исключением функций встроенных модулей (Pkg, Collections, Test и Profile), все документированные здесь функции напрямую доступны для использования в программах.
• Для использования функций модуля используйте import Module для импорта модуля и Module.fn(x) для использования функций.
• В качестве альтернативы, using Module импортирует все экспортированные Module функции в текущее пространство имен.
• По соглашению, имена функций, оканчивающиеся восклицательным знаком (!), изменяют свои аргументы. Некоторые функции имеют как изменяющие (например, sort!) версии, так и неизменяющие (sort) версии.

Перемещение

exit([code])

Выход (или Ctrl+D в командной строке). Значение кода выхода по умолчанию равно нулю, что указывает на успешное завершение процессов.

quit()

Завершение программы со значением кода выхода, указывающим на успешное завершение процессов. Эта функция вызывает exit(0) (см. exit()).

atexit(f)

Регистрирует функцию без аргументов f() для вызова при выходе процесса. atexit() обработчики вызываются в порядке LIFO (последний вошел — первый вышел) и выполняются до финализаторов объектов.

atreplinit(f)

Регистрирует функцию с одним аргументом, которая будет вызвана перед инициализацией интерфейса REPL в интерактивных сеансах; это полезно для настройки интерфейса. Аргумент функции f — объект REPL. Эта функция должна вызываться из файла инициализации .juliarc.jl.

isinteractive() → Bool

Определяет, работает ли Julia в интерактивном сеансе.

whos([io,] [Module,] [pattern::Regex])

Выводит информацию об экспортированных глобальных переменных в модуле, при необходимости ограничив вывод переменными, соответствующими pattern.

Оценка потребления памяти является приблизительным нижним пределом размера внутренней структуры объекта.

Base.summarysize(obj; exclude=Union{Module, Function, DataType, TypeName}) → Int

Вычисляет объем памяти, используемый всеми уникальными объектами, достижимыми из аргумента. Параметр exclude определяет тип объектов, которые нужно исключить из обхода.

edit(path::AbstractString[, line])

Редактирует файл или каталог, необязательно указав номер строки для редактирования файла. Возвращается к приглашению julia при выходе из редактора.

edit(function[, types])

Редактирует определение функции, необязательно указав кортеж типов, чтобы указать, какой метод редактировать.

@edit()

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает функцию edit с полученным выражением.

less(file::AbstractString[, line])

Отображает файл с помощью стандартного обозревателя, необязательно указав начальную строку. Возвращается к приглашению julia при выходе из обозревателя.

less(function[, types])

Отображает определение функции с помощью стандартного обозревателя, необязательно указав кортеж типов, чтобы указать, какой метод отобразить.

@less()

Вычисляет аргументы вызова функции или макроса, определяет их типы и вызывает функцию less с полученным выражением.

clipboard(x)

Отправляет печатную форму x в буфер обмена операционной системы («копировать»).

clipboard() → AbstractString

Возвращает строку с содержимым буфера обмена операционной системы («вставить»).

reload(name::AbstractString)

Принудительно перезагружает пакет, даже если он был загружен ранее. Предназначено для использования во время разработки пакета, когда код изменяется.

require(module::Symbol)

Эта функция является частью реализации using / import, если модуль еще не определен в Main. Также может быть вызвана напрямую для принудительной перезагрузки модуля, независимо от того, был ли он загружен ранее (например, при интерактивной разработке библиотек).

Загружает исходные файлы в контексте модуля Main на каждом активном узле, ищет файлы в стандартных расположениях. require считается операцией верхнего уровня, поэтому она устанавливает текущий include путь, но не использует его для поиска файлов (см. справку по include). Эта функция обычно используется для загрузки кода библиотеки и неявно вызывается using для загрузки пакетов.

При поиске файлов require сначала ищет код пакета в Pkg.dir(), затем пытается получить пути из глобального массива LOAD_PATH. require регистрозависимая на всех платформах, включая платформы с регистронезависимыми файловыми системами, такими как macOS и Windows.

Base.compilecache(module::String)

Создаёт файл предварительно скомпилированного кэша для модуля (см. справку по require) и всех его зависимостей. Это может использоваться для уменьшения времени загрузки пакетов. Файлы кэша хранятся в LOAD_CACHE_PATH[1], по умолчанию ~/.julia/lib/VERSION. См. Инициализация и предварительная компиляция модулей для важных замечаний.

__precompile__(isprecompilable::Bool=true)

Указывает, является ли файл, вызывающий эту функцию, предварительно компилируемым. Если isprecompilable равно true, то __precompile__ выбрасывает исключение, когда файл загружается using/import/require, *кроме* случаев предварительной компиляции файла, и в файле модуля это заставляет модуль автоматически предварительно компилироваться при импорте. Обычно __precompile__() должно происходить до объявления module в файле, или ещё лучше VERSION >= v"0.4" && __precompile__() для обратной совместимости с Julia 0.3.

Если модуль или файл *не* безопасно предварительно компилируется, он должен вызывать __precompile__(false) для того, чтобы сгенерировать ошибку, если Julia попытается его предварительно скомпилировать.

__precompile__() не должно использоваться в модуле, если все его зависимости также используют __precompile__(). Несоблюдение этого может привести к ошибке выполнения при загрузке модуля.

include(path::AbstractString)

Вычисляет содержимое исходного файла в текущем контексте. Во время включения путь включения, относящийся к задаче, устанавливается в каталог, содержащий файл. Вложенные вызовы include будут искать относительно этого пути. Все пути относятся к файлам на узле 1 при выполнении в параллельном режиме, и файлы будут получены с узла 1. Эта функция обычно используется для интерактивной загрузки исходного кода или для объединения файлов в пакетах, которые разбиты на несколько исходных файлов.

include_string(code::AbstractString[, filename])

Подобно include, но читает код из заданной строки, а не из файла. Поскольку путь файла не используется, обработка путей или получение из узла 1 не выполняется.

include_dependency(path::AbstractString)

В модуле укажите, что файл, указанный path (относительный или абсолютный), является зависимостью для предварительной компиляции; то есть модуль потребуется перекомпилировать, если этот файл изменится.

Это необходимо только если ваш модуль зависит от файла, который не используется через include. Он не оказывает никакого влияния за пределами компиляции.

apropos(string)

Ищет строку во всей документации, не учитывая регистр.

which(f, types)

Возвращает метод f (объект Method) для аргументов заданных types.

Если types — абстрактный тип, то возвращается метод, который будет вызываться invoke.

which(symbol)

Возвращает модуль, в котором было создано связывание для переменной, на которую ссылается symbol.

@which()

Применяется к вызову функции или макроса, вычисляет аргументы указанного вызова и возвращает объект Method для метода, который будет вызван для этих аргументов. Применяется к переменной, возвращает модуль, в котором переменная была связана. Вызывает функцию which.

methods(f[, types])

Возвращает таблицу методов для f.

Если types указан, возвращает массив методов, типы которых соответствуют.

methodswith(typ[, module or function][, showparents])

Возвращает массив методов с аргументом типа typ.

Необязательный второй аргумент сужает поиск до конкретного модуля или функции (по умолчанию — все модули, начиная с Main).

Если необязательный showparents равен true, также возвращает аргументы с родительским типом typ, исключая тип Any.

@show()

Отображает выражение и результат, возвращая результат.

versioninfo([verbose::Bool])

Вывести информацию о версии используемой Julia. Если аргумент verbose равен true, также отображается подробная информация о системе.

workspace()

Заменить модуль верхнего уровня (Main) на новый, создавая чистую рабочую среду. Предыдущий модуль Main становится доступным как LastMain. Загруженный ранее пакет можно получить, используя выражение, подобное using LastMain.Package.

Эта функция предназначена только для интерактивного использования.

ans

Переменная, ссылающаяся на последнее вычисленное значение, автоматически устанавливается в интерактивном режиме.

Все объекты

is(x, y) → Bool

===(x, y) → Bool

≡(x, y) → Bool

Определяет, являются ли x и y идентичными в том смысле, что ни одна программа не могла бы их различить. Сравнивает изменяемые объекты по адресу в памяти, а неизменяемые объекты (такие как числа) по содержимому на уровне битов. Иногда эта функция называется egal.

isa(x, type) → Bool

Определяет, относится ли x к заданному type типу.

isequal(x, y)

Аналогично ==, за исключением того, что все значения с плавающей точкой NaN считаются равными друг другу, и -0.0 считается неравным 0.0. По умолчанию isequal вызывает ==, поэтому если у вас есть тип, у которого нет этих тонкостей с плавающей точкой, вам, вероятно, нужно определить только ==.

isequal — это функция сравнения, используемая хэш-таблицами (Dict). isequal(x,y) должно подразумевать, что hash(x) == hash(y).

Это обычно означает, что если вы определите свою собственную функцию ==, то вам необходимо определить соответствующую функцию hash (и наоборот). Коллекции обычно реализуют isequal, вызывая isequal рекурсивно для всего содержимого.

Скалярные типы обычно не нуждаются в реализации isequal отдельно от ==, за исключением случаев, когда они представляют числа с плавающей точкой, допускающие более эффективную реализацию, чем предоставляемый универсальный вариант (основанный на isnan, signbit, и ==).

isless(x, y)

Проверить, является ли x меньше y в соответствии с каноническим полным порядком. Значения, которые обычно не упорядочиваются, такие как NaN, упорядочиваются произвольным, но согласованным способом. Это по умолчанию используется для сравнения sort. Типы, не являющиеся числовыми, с каноническим полным порядком должны реализовывать эту функцию. Числовые типы нуждаются в её реализации только если у них есть специальные значения, такие как NaN.

ifelse(condition::Bool, x, y)

Возвращает x если condition является true, в противном случае возвращает y. Это отличается от ? или if тем, что является обычной функцией, поэтому все аргументы вычисляются сначала. В некоторых случаях использование ifelse вместо оператора if может устранить ветвление в сгенерированном коде и обеспечить более высокую производительность в циклах с высокой частотой.

lexcmp(x, y)

Сравнивает x и y лексикографически и возвращает -1, 0 или 1 в зависимости от того, является ли x меньше, равно или больше y соответственно. Эта функция должна быть определена для лексикографически сравнимых типов, и lexless по умолчанию вызовет lexcmp.

lexless(x, y)

Определяет, меньше ли x лексикографически, чем y.

typeof(x)

Получить конкретный тип x.

tuple(xs...)

Создать кортеж из заданных объектов.

ntuple(f::Function, n)

Создаёт кортеж длиной n, вычисляя каждый элемент как f(i), где i — индекс элемента.

object_id(x)

Получить значение хэша для x на основе идентификатора объекта. object_id(x)==object_id(y) если x === y.

hash(x[, h::UInt])

Вычислить целочисленное хэш-значение, такое что isequal(x,y) подразумевает hash(x)==hash(y). Необязательный второй аргумент h — это хэш-код, который нужно смешать с результатом.

Новые типы должны реализовывать двухаргументную форму, обычно вызывая двухаргументный метод hash рекурсивно, чтобы смешать хэши содержимого друг с другом (и с h). Как правило, любой тип, который реализует hash должен также реализовывать свою собственную функцию == (отсюда и isequal) для гарантии указанного выше свойства.

finalizer(x, function)

Зарегистрировать функцию f(x) для вызова, когда нет доступных в программе ссылок на x. Поведение этой функции непредсказуемо, если x относится к типу битов.

finalize(x)

Немедленно выполнить финализаторы, зарегистрированные для объекта x.

copy(x)

Создать поверхностную копию x: копируется внешняя структура, но не все внутренние значения. Например, копирование массива создаёт новый массив с идентичными элементами, как у исходного.

deepcopy(x)

Создать глубокую копию x: всё копируется рекурсивно, что приводит к полностью независимому объекту. Например, глубокое копирование массива создаёт новый массив, элементы которого являются глубокими копиями исходных элементов. Вызов deepcopy для объекта, как правило, эквивалентен его сериализации и последующей десериализации.

В качестве специального случая, функции могут быть глубоко скопированы только если они анонимные, в противном случае они просто копируются. Разница актуальна только в случае замыканий, то есть функций, которые могут содержать скрытые внутренние ссылки.

Хотя это обычно не нужно, пользовательские типы могут переопределить поведение по умолчанию deepcopy путём определения специализированной версии функции deepcopy_internal(x::T, dict::ObjectIdDict) (которую иначе не следует использовать), где T — тип, для которого требуется специализация, а dict отслеживает объекты, скопированные до сих пор во время рекурсии. В определении deepcopy_internal должно использоваться вместо deepcopy, и переменная dict должна быть обновлена соответствующим образом перед возвращением.

isdefined([m::Module, ]s::Symbol)

isdefined(object, s::Symbol)

isdefined(object, index::Int)

isdefined(a::Array, index::Int)

Проверяет, определён ли присваиваемый фрагмент памяти. Аргументами могут быть модуль и символ, составной объект и имя поля (как символ) или индекс, или Array и индекс. При единственном символьном аргументе, проверяет, определена ли глобальная переменная с этим именем в current_module().

Примечание: для AbstractArray типов, отличных от Array, isdefined проверяет, определён ли данный индекс поля, а не данный индекс массива. Для проверки определения индекса массива используйте isassigned().

convert(T, x)

Преобразовать x в значение типа T.

Если T является типом Integer, будет поднято исключение InexactError, если x не может быть представлено типом T, например, если x не целое число или находится вне диапазона, поддерживаемого T.

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError()
 in convert(::Type{Int64}, ::Float64) at ./int.jl:239
 ...

Если T является типом AbstractFloat или Rational, то возвращается самое близкое значение к x, представимое типом T.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(Rational{Int32}, x)
1//3

julia> convert(Rational{Int64}, x)
6004799503160661//18014398509481984

Если T — это тип коллекции, а x — коллекция, то результат convert(T, x) может ссылаться на x.

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

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

julia> y === x
true

Аналогично, если T — составной тип, а x — связанный экземпляр, результат convert(T, x) может ссылаться на часть или всё содержимое x.

julia> x = speye(5);

julia> typeof(x)
SparseMatrixCSC{Float64,Int64}

julia> y = convert(SparseMatrixCSC{Float64,Int64}, x);

julia> z = convert(SparseMatrixCSC{Float32,Int64}, y);

julia> y === x
true

julia> z === x
false

julia> z.colptr === x.colptr
true

promote(xs...)

Преобразует все аргументы к их общему типу повышения (если таковой имеется) и возвращает их все (как кортеж).

oftype(x, y)

Преобразовать y к типу x (convert(typeof(x), y)).

widen(x)

Если x — это тип, возвращает «более широкий» тип (для числовых типов это тип с не меньшим диапазоном и точностью, чем аргумент, и обычно больше). В противном случае x преобразуется к widen(typeof(x)).

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

Функция тождества. Возвращает свой аргумент.

Типы

supertype(T::DataType)

Возвращает супертип типа данных T.

issubtype(type1, type2)

Возвращает true тогда и только тогда, когда все значения type1 также являются значениями типа type2. Также может быть записано с помощью инфиксного оператора <: как type1 <: type2.

<:(T1, T2)

Оператор подтипа, эквивалентный issubtype(T1,T2).

subtypes(T::DataType)

Возвращает список непосредственных подтипов типа данных T. Обратите внимание, что включаются все загруженные в настоящее время подтипы, включая те, которые не отображаются в текущем модуле.

typemin(T)

Наименьшее значение, представимое заданным (вещественным) числовым типом данных T.

typemax(T)

Наибольшее значение, представимое заданным (вещественным) числовым типом DataType.

realmin(T)

Наименьшее по модулю не-поднормализованное значение, представимое заданным типом данных с плавающей запятой T.

realmax(T)

Наибольшее конечное значение, представимое заданным типом данных с плавающей запятой T.

maxintfloat(T)

Наибольшее целое число, представимое заданным типом данных с плавающей запятой T без потерь.

sizeof(T)

Размер, в байтах, канонического двоичного представления заданного типа данных T (если таковой имеется).

eps(T)

Расстояние между 1.0 и следующим большим представимым значением с плавающей запятой типа DataType T. В качестве аргументов уместны только типы с плавающей запятой.

eps()

Расстояние между 1.0 и следующим большим представимым значением с плавающей запятой типа Float64.

eps(x)

Расстояние между x и следующим большим представимым значением с плавающей запятой того же типа DataType что и x.

promote_type(type1, type2)

Определяет тип, достаточно большой для хранения значений каждого типа аргумента без потерь, если это возможно. В некоторых случаях, когда нет типа, в который оба типа могут быть преобразованы без потерь, допускаются некоторые потери; например, promote_type(Int64,Float64) возвращает Float64, хотя строго говоря, не все значения Int64 могут быть представлены точно как значения Float64.

promote_rule(type1, type2)

Указывает, какой тип следует использовать функции promote при передаче значений типов type1 и type2. Эта функция не должна вызываться напрямую, а должна иметь определения, добавленные в нее для новых типов по мере необходимости.

getfield(value, name::Symbol)

Извлечение именованного поля из value составного типа. Синтаксис a.b вызывает getfield(a, :b).

setfield!(value, name::Symbol, x)

Присваивание x именованному полю в value составного типа. Синтаксис a.b = c вызывает setfield!(a, :b, c).

fieldoffset(type, i)

Смещение в байтах поля i типа относительно начала данных. Например, мы можем использовать его для подведения итогов информации о типе структуры:

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

julia> structinfo(Base.Filesystem.StatStruct)
12-element Array{Tuple{UInt64,Symbol,DataType},1}:
 (0x0000000000000000,:device,UInt64)
 (0x0000000000000008,:inode,UInt64)
 (0x0000000000000010,:mode,UInt64)
 (0x0000000000000018,:nlink,Int64)
 (0x0000000000000020,:uid,UInt64)
 (0x0000000000000028,:gid,UInt64)
 (0x0000000000000030,:rdev,UInt64)
 (0x0000000000000038,:size,Int64)
 (0x0000000000000040,:blksize,Int64)
 (0x0000000000000048,:blocks,Int64)
 (0x0000000000000050,:mtime,Float64)
 (0x0000000000000058,:ctime,Float64)

fieldtype(T, name::Symbol | index::Int)

Определяет объявленный тип поля (указанного по имени или индексу) в составном типе данных T.

isimmutable(v)

Возвращает true тогда и только тогда, когда значение v неизменяемое. Подробное обсуждение неизменяемости см. в разделе Неизменяемые составные типы. Обратите внимание, что эта функция работает со значениями, поэтому если вы передадите ей тип, она скажет вам, что значение типа DataType изменяемое.

isbits(T)

Возвращает true если T является типом «простых данных», то есть неизменяемым и не содержащим ссылок на другие значения. Типичными примерами являются числовые типы, такие как UInt8, Float64, и Complex{Float64}.

julia> isbits(Complex{Float64})
true

julia> isbits(Complex)
false

isleaftype(T)

Определяет, является ли T конкретным типом, который может иметь экземпляры, то есть его единственными подтипами являются он сам и Union{} (но T сам по себе не является Union{}).

typejoin(T, S)

Вычисляет тип, содержащий как T, так и S.

typeintersect(T, S)

Вычисляет тип, содержащий пересечение T и S . Обычно это будет наименьший такой тип или близкий к нему.

Val{c}()

Создает «тип значения» из c, которое должно быть значением isbits типа. Цель этого конструкта — возможность выполнения диспетчеризации по константам, например, f(Val{false}) позволяет напрямую (во время компиляции) выполнить диспетчеризацию к реализации f(::Type{Val{false}}), не проверяя булевое значение во время выполнения.

@enum EnumName EnumValue1[=x] EnumValue2[=y]

Создает тип перечисления с именем EnumName и значениями членов перечисления EnumValue1 и EnumValue2 с необязательными присвоенными значениями x и y соответственно. EnumName можно использовать как и другие типы и значения членов перечисления как обычные значения, такие как

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"

instances(T::Type)

Возвращает коллекцию всех экземпляров данного типа, если применимо. В основном используется для типов перечислений (см. @enum).

Общие функции

method_exists(f, Tuple type) → Bool

Определяет, имеет ли заданная общая функция метод, соответствующий заданному Tuple типов аргументов.

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

applicable(f, args...) → Bool

Определяет, имеет ли заданная общая функция метод, применимый к заданным аргументам.

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

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

invoke(f, (types...), args...)

Вызывает метод для данной общей функции, соответствующей заданным типам (как кортеж), по заданным аргументам. Аргументы должны быть совместимы с указанными типами. Это позволяет вызывать метод, отличный от метода, наиболее точно соответствующего методу, что полезно, когда явно требуется поведение более общего определения (часто в рамках реализации более конкретного метода той же функции).

|>(x, f)

Применяет функцию к предыдущему аргументу. Это позволяет легко создавать цепочки функций.

julia> [1:5;] |> x->x.^2 |> sum |> inv
0.01818181818181818

Синтаксис

eval([m::Module, ]expr::Expr)

Вычисляет выражение в заданном модуле и возвращает результат. Каждый Module (кроме тех, которые определены с помощью baremodule) имеет собственное определение eval с 1 аргументом, которое вычисляет выражения в этом модуле.

@eval()

Вычисляет выражение и возвращает значение.

evalfile(path::AbstractString)

Загружает файл с помощью include, вычисляет все выражения и возвращает значение последнего.

esc(e::ANY)

Действительно только в контексте Expr возвращаемого макросом. Препятствует прохождению очистки макросов по встроенным переменным в gensym переменные. См. раздел Макросы в главе «Метапрограммирование» руководства для получения дополнительной информации и примеров.

gensym([tag])

Генерирует символ, который не будет конфликтовать с другими именами переменных.

@gensym()

Генерирует символ gensym для переменной. Например, @gensym x y преобразуется в x = gensym("x"); y = gensym("y").

parse(str, start; greedy=true, raise=true)

Парсит строку выражения и возвращает выражение (которое затем можно передать в eval для выполнения). start — индекс первого символа для начала парсинга. Если greedy равно true (по умолчанию), parse попытается прочитать как можно больше входных данных; в противном случае, он остановится, как только будет проанализировано допустимое выражение. Неполные, но в противном случае синтаксически корректные выражения вернут Expr(:incomplete, "(error message)"). Если raise равно true (по умолчанию), синтаксические ошибки, отличные от неполных выражений, вызовут ошибку. Если raise равно false, parse вернёт выражение, которое при вычислении вызовет ошибку.

parse(str; raise=true)

Жадно парсит строку выражения, возвращая одно выражение. Выбрасывается ошибка, если после первого выражения есть дополнительные символы. Если raise равно true (по умолчанию), синтаксические ошибки вызовут ошибку; в противном случае, parse вернёт выражение, которое при вычислении вызовет ошибку.

Типы с возможностью null

Nullable(x)

Оборачивает значение x в объект типа Nullable, который указывает, присутствует ли значение. Nullable(x) возвращает непустой обертка, а Nullable{T}() возвращает пустой экземпляр обертки, который может содержать значение типа T.

get(x::Nullable[, y])

Попытка доступа к значению x. Возвращает значение, если оно присутствует; в противном случае возвращает y при его наличии или бросает исключение NullException в противном случае.

isnull(x)

Является ли объект Nullable x null, т.е. отсутствует значение?

Система

run(command)

Запустить объект команды, созданный с помощью обратных кавычек. Бросает ошибку, если что-то пойдёт не так, включая завершение процесса с ненулевым статусом.

spawn(command)

Асинхронно запустить объект команды, возвращая полученный объект Process.

DevNull

Используется в перенаправлении потока для отбрасывания всех данных, записанных в него. По сути, эквивалентно /dev/null в Unix или NUL в Windows. Использование:

run(pipeline(`cat test.txt`, DevNull))

success(command)

Запустить объект команды, созданный с помощью обратных кавычек, и определить, был ли он успешным (завершился с кодом 0). Если процесс не может быть запущен, вызывается исключение.

process_running(p::Process)

Определить, запущен ли процесс в данный момент.

process_exited(p::Process)

Определить, завершился ли процесс.

kill(p::Process, signum=SIGTERM)

Отправить сигнал процессу. По умолчанию процесс завершается.

Sys.set_process_title(title::AbstractString)

Установить заголовок процесса. Нет действия на некоторых операционных системах. (не экспортируется)

Sys.get_process_title()

Получить заголовок процесса. На некоторых системах всегда возвращает пустую строку. (не экспортируется)

readandwrite(command)

Начинает асинхронное выполнение команды и возвращает кортеж (stdout, stdin, process) из потока вывода, потока ввода процесса и самого объекта процесса.

ignorestatus(command)

Отметить объект команды так, чтобы его выполнение не вызывало ошибку, если код результата не равен нулю.

detach(command)

Отметить объект команды так, чтобы он выполнялся в новой группе процессов, позволяя ему жить дольше процесса Julia и не получать прерывания Ctrl-C.

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide,

env, dir)

Создать новый объект Cmd , представляющий внешнюю программу и аргументы, из cmd, изменяя настройки необязательных ключевых аргументов:

• ignorestatus::Bool: Если true (по умолчанию false), то Cmd не будет бросать ошибку, если код возврата не равен нулю.
• detach::Bool: Если true (по умолчанию false), то Cmd будет выполняться в новой группе процессов, позволяя ему существовать дольше процесса julia и не получать Ctrl-C.
• windows_verbatim::Bool: Если true (по умолчанию false), то в Windows Cmd будет отправлять строку командной строки в процесс без кавычек или экранирования аргументов, даже аргументов, содержащих пробелы. (В Windows аргументы отправляются в программу как одна строка «командной строки», и программы отвечают за её разбор на аргументы. По умолчанию пустые аргументы и аргументы с пробелами или табуляцией заключаются в двойные кавычки " в командной строке, а \ или " предваряются обратными слешами. windows_verbatim=true полезно для запуска программ, которые анализируют командную строку нестандартными способами.) Не имеет эффекта на системах, отличных от Windows.
• windows_hide::Bool: Если true (по умолчанию false), то в Windows при выполнении Cmd новое окно консоли не отображается. Это не имеет эффекта, если консоль уже открыта или на системах, отличных от Windows.
• env: Установите переменные среды, которые нужно использовать при запуске Cmd . env это либо словарь, отображающий строки в строки, массив строк вида "var=val", массив или кортеж пар "var"=>val, или nothing. Чтобы изменить (а не заменить) существующую среду, создайте env с помощью copy(ENV) и затем установите env["var"]=val как нужно.
• dir::AbstractString: Укажите рабочую директорию для команды (вместо текущей директории).

Для любых ключевых слов, которые не указаны, используются текущие настройки из cmd. Обычно для создания объекта Cmd в первую очередь используется обратные кавычки, например:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

setenv(command, env; dir=working_dir)

Установить переменные среды, которые нужно использовать при запуске данной command . env это либо словарь, отображающий строки в строки, массив строк вида "var=val", или нуль или более пар аргументов "var"=>val. Чтобы изменить (а не заменить) существующую среду, создайте env с помощью copy(ENV) и затем установите env["var"]=val, или используйте withenv.

Ключевой аргумент dir может быть использован для указания рабочей директории для команды.

withenv(f::Function, kv::Pair...)

Выполнить f() в среде, которая временно модифицируется (а не заменяется, как в setenv) нулем или более аргументов "var"=>val kv. withenv обычно используется через синтаксис withenv(kv...) do ... end. Значение nothing может быть использовано для временного отключения переменной среды (если она установлена). После возвращения из withenv, исходная среда восстанавливается.

pipeline(from, to, ...)

Создать конвейер из источника данных в место назначения. Источник и место назначения могут быть командами, потоками ввода-вывода, строками или результатами других вызовов pipeline. Хотя бы один аргумент должен быть командой. Строки относятся к именам файлов. При вызове с более чем двумя аргументами они объединяются слева направо. Например, pipeline(a,b,c) эквивалентно pipeline(pipeline(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)

Перенаправить ввод-вывод в или из указанного command . Ключевые аргументы указывают, какие потоки команды следует перенаправить. append управляет тем, добавляется ли вывод в файл или нет. Это более общая версия функции pipeline с двумя аргументами. pipeline(from, to) эквивалентно pipeline(from, stdout=to) когда from является командой и pipeline(to, stdin=from) когда from является другим типом источника данных.

Примеры:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

gethostname() → AbstractString

Получить имя хоста локальной машины.

getipaddr() → IPAddr

Получить IP-адрес локальной машины.

getpid() → Int32

Получить идентификатор процесса Julia.

time()

Получить системное время в секундах с начала эпохи с достаточно высокой (обычно микросекундной) точностью.

time_ns()

Получить время в наносекундах. Время, соответствующее 0, не определено и обнуляется каждые 5,8 лет.

tic()

Установить таймер для последующего считывания с помощью следующего вызова toc() или toq(). Макрос @time expr также может использоваться для измерения времени выполнения.

toc()

Вывести и вернуть время, прошедшее с момента последнего вызова tic(). Макрос @time expr также может использоваться для измерения времени выполнения.

toq()

Возвращает, но не выводит, время, прошедшее с момента последнего вызова tic(). Макросы @timed expr и @elapsed expr также возвращают время выполнения.

@time()

Макрос для выполнения выражения, выводящий время выполнения, количество выделений памяти и общее количество байтов, выделенных во время его выполнения, прежде чем вернуть значение выражения.

См. также @timev(), @timed(), @elapsed() и @allocated().

@timev()

Это расширенная версия макроса @time. Она сначала выводит ту же информацию, что и @time, затем любые не нулевые счетчики выделения памяти, а затем возвращает значение выражения.

См. также @time(), @timed(), @elapsed() и @allocated().

@timed()

Макрос, который выполняет выражение и возвращает значение выражения, время выполнения, общее количество выделенных байтов, время работы сборщика мусора и объект с различными счетчиками выделения памяти.

См. также @time(), @timev(), @elapsed() и @allocated().

@elapsed()

Макрос, который вычисляет выражение, игнорируя возвращаемое значение, и вместо этого возвращает количество секунд, затраченных на его выполнение, как число с плавающей точкой.

См. также @time(), @timev(), @timed() и @allocated().

@allocated()

Макрос, который вычисляет выражение, игнорируя возвращаемое значение, и вместо этого возвращает общее количество байтов, выделенных во время вычисления выражения. Примечание: выражение вычисляется внутри локальной функции, а не в текущем контексте, чтобы устранить влияние компиляции, однако все же могут быть выделения из-за компиляции JIT. Это также делает результаты несовместимыми с макросами @time, которые не пытаются скорректировать влияние компиляции.

См. также @time(), @timev(), @timed() и @elapsed().

EnvHash() → EnvHash

Экземпляр этого типа предоставляет интерфейс таблицы хешей для переменных среды.

ENV

Ссылка на синглтон EnvHash, предоставляющий интерфейс словаря для системных переменных среды.

is_unix([os])

Предикат для проверки, предоставляет ли ОС интерфейс, похожий на Unix. См. документацию в Обработка различий операционных систем.

is_apple([os])

Предикат для проверки, является ли ОС производной от Apple Macintosh OS X или Darwin. См. документацию в Обработка различий операционных систем.

is_linux([os])

Предикат для проверки, является ли ОС производной от Linux. См. документацию в Обработка различий операционных систем.

is_bsd([os])

Предикат для проверки, является ли ОС производной от BSD. См. документацию в Обработка различий операционных систем.

is_windows([os])

Предикат для проверки, является ли ОС производной от Microsoft Windows NT. См. документацию в Обработка различий операционных систем.

windows_version()

Возвращает номер версии ядра Windows NT как пару (major, minor) или (0, 0), если это не Windows.

@static()

Частично вычисляет выражение во время разбора.

Например, @static is_windows() ? foo : bar вычислит is_windows() и вставит либо foo, либо bar в выражение. Это полезно в тех случаях, когда конструкция не будет действительной на других платформах, например, ccall для несуществующей функции.

Ошибки

error(message::AbstractString)

Вызвать ErrorException с заданным сообщением.

throw(e)

Выбросить объект в качестве исключения.

rethrow([e])

Выбросить объект без изменения текущего стека вызовов исключения. По умолчанию аргумент - текущее исключение (если вызов производится внутри блока catch).

backtrace()

Получить объект стека вызовов для текущей точки программы.

catch_backtrace()

Получить стек вызовов текущего исключения для использования внутри блоков catch.

assert(cond)

Выбросить AssertionError если cond равно false. Также доступен как макрос @assert expr.

@assert cond [text]

Выбросить AssertionError если cond равно false. Предпочтительный синтаксис для написания утверждений. Сообщение text необязательно отображается при ошибке утверждения.

ArgumentError(msg)

Параметры вызова функции не соответствуют допустимой сигнатуре. Аргумент msg - это описательное сообщение об ошибке.

AssertionError([msg])

Утверждаемое условие не оценивается как true. Необязательный аргумент msg — описательное сообщение об ошибке.

BoundsError([a][, i])

Операция индексирования в массиве, a, попыталась получить доступ к элементу за пределами границ, i.

DimensionMismatch([msg])

Вызываемые объекты не имеют совпадающих размерностей. Необязательный аргумент msg — описательное сообщение об ошибке.

DivideError()

Попытка целочисленного деления с делителем 0.

DomainError()

Аргументы функции или конструктора находятся за пределами допустимой области.

EOFError()

Больше нет данных для чтения из файла или потока.

ErrorException(msg)

Общий тип ошибки. Сообщение об ошибке в поле .msg может содержать более подробную информацию.

InexactError()

Преобразование типов невозможно выполнить точно.

InterruptException()

Процесс был остановлен прерыванием терминала (CTRL+C).

KeyError(key)

Операция индексирования в Associative (Dict) или подобном объекте пыталась получить доступ к или удалить несуществующий элемент.

LoadError(file::AbstractString, line::Int, error)

Во время includeing, requireing или using файла произошла ошибка. Подробности об ошибке должны быть доступны в поле .error.

MethodError(f, args)

Метод с требуемой сигнатурой типа отсутствует в данной обобщенной функции. Или же нет уникального наиболее специфичного метода.

NullException()

Попытка доступа к Nullable без определения значения.

OutOfMemoryError()

Операция выделила слишком много памяти для обработки системой или сборщиком мусора.

ReadOnlyMemoryError()

Операция пыталась записать в память, которая является только для чтения.

OverflowError()

Результат выражения слишком велик для указанного типа и приведет к переполнению.

ParseError(msg)

Выражение, переданное функции parse, не может быть интерпретировано как допустимое выражение Julia.

ProcessExitedException()

После завершения дочернего процесса Julia попытка повторной ссылки на него приведет к этому исключению.

StackOverflowError()

Вызов функции превысил размер стека вызовов. Это обычно происходит, когда вызов рекурсивно вызывает себя бесконечно.

SystemError(prefix::AbstractString[, errno::Int32])

Системный вызов завершился ошибкой с кодом ошибки (в глобальной переменной errno).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Ошибка проверки типа или вызов внутренней функции с неправильным типом аргумента.

UndefRefError()

Элемент или поле не определены для данного объекта.

UndefVarError(var::Symbol)

Символ в текущем пространстве имен не определен.

InitError(mod::Symbol, error)

Произошла ошибка при выполнении функции __init__ модуля. Фактическая ошибка доступна в поле .error.

retry(f, [retry_on]; n=1, max_delay=10.0) → Function

Возвращает лямбда-функцию, которая повторно пытается выполнить функцию f до n раз в случае возникновения исключения. Если retry_on является типом исключения, то попытки повтора выполняются только для исключений этого типа. Если retry_on является функцией test_error(::Exception) -> Bool, то попытки повтора выполняются только если она возвращает true.

Первая повторная попытка выполняется после задержки в 50 миллисекунд или max_delay, в зависимости от того, что меньше. Впоследствии, задержки между повторными попытками экспоненциально увеличиваются с случайным коэффициентом до max_delay.

Примеры

retry(http_get, e -> e.status == "503")(url)
retry(read, UVError)(io)

События

Timer(callback::Function, delay, repeat=0)

Создает таймер для вызова заданной функции callback. Функции callback передаётся один аргумент — объект таймера. Обработчик вызывается после указанного начального delay, а затем повторяется с заданным repeat интервалом. Если repeat равно 0, таймер запускается только один раз. Время задаётся в секундах. Таймер останавливается и освобождает ресурсы при вызове close на нём.

Timer(delay, repeat=0)

Создаёт таймер, который пробуждает задачи, ожидающие его (вызывая wait на объекте таймера), с указанным интервалом. Время задаётся в секундах. Ожидающие задачи пробуждаются с ошибкой при закрытии таймера (close). Используйте isopen для проверки активности таймера.

AsyncCondition()

Создаёт асинхронную условную переменную, которая пробуждает задачи, ожидающие её (вызывая wait на объекте), при уведомлении из C через вызов uv_async_send. Ожидающие задачи пробуждаются с ошибкой при закрытии объекта (close). Используйте isopen для проверки активности.

AsyncCondition(callback::Function)

Создаёт асинхронную условную переменную, которая вызывает указанную функцию callback. Функции callback передаётся один аргумент — объект асинхронной условной переменной.

Рефлексия

module_name(m::Module) → Symbol

Получает имя модуля как символ.

module_parent(m::Module) → Module

Получает модуль, содержащий данный модуль. Модуль является своим собственным родителем, также как и LastMain после workspace().

current_module() → Module

Получает динамически текущий модуль, из которого в настоящий момент читается код. Как правило, это не тот же модуль, который содержит вызов этой функции.

fullname(m::Module)

Получает полное имя модуля как кортеж символов. Например, fullname(Base.Pkg) даёт (:Base,:Pkg), а fullname(Main) даёт ().

names(x::Module[, all=false[, imported=false]])

Получает массив имён, экспортируемых модулем, с дополнительными глобальными переменными, если указаны.

nfields(x::DataType) → Int

Получает количество полей объекта.

fieldnames(x::DataType)

Получает массив имён полей объекта.

fieldname(x::DataType, i)

Получает имя поля i объекта.

Base.datatype_module(t::DataType) → Module

Определяет модуль, содержащий определение типа данных.

isconst([m::Module, ]s::Symbol) → Bool

Определяет, является ли глобальная переменная константой в данном модуле. По умолчанию Module равно current_module().

Base.function_name(f::Function) → Symbol

Получает имя обобщённой функции как символ, или :anonymous.

Base.function_module(f::Function) → Module

Определяет модуль, содержащий (первое) определение обобщённой функции.

Base.function_module(f::Function, types) → Module

Определяет модуль, содержащий данное определение обобщённой функции.

functionloc(f::Function, types)

Возвращает кортеж (filename,line), содержащий местоположение определения обобщённой функции.

functionloc(m::Method)

Возвращает кортеж (filename,line), содержащий местоположение определения функции.

@functionloc()

Применяется к вызову функции или макроса. Вычисляет аргументы вызова и возвращает кортеж (filename,line) с местоположением вызываемого метода. Использует функцию functionloc.

Внутренности

gc()

Выполняет сборку мусора. Не следует использовать в общем случае.

gc_enable(on::Bool)

Управляет включением/выключением сбора мусора, используя булевый аргумент (true для включения, false для выключения). Возвращает предыдущее состояние GC. Выключение сбора мусора следует использовать с большой осторожностью, так как это может привести к неограниченному росту использования памяти.

macroexpand(x)

Принимает выражение x и возвращает эквивалентное выражение без макросов (с расширением).

expand(x)

Принимает выражение x и возвращает эквивалентное выражение в пониженном виде.

code_lowered(f, types)

Возвращает массив пониженных AST для методов, соответствующих данной обобщённой функции и подписи типа.

@code_lowered()

Вычисляет аргументы функции или макроса, определяет их типы и вызывает code_lowered() на результирующем выражении.

code_typed(f, types; optimize=true)

Возвращает массив пониженных и типизированных AST для методов, соответствующих данной обобщённой функции и подписи типа. Ключевой аргумент optimize управляет применением дополнительных оптимизаций, таких как инлайнинг.

@code_typed()

Вычисляет аргументы функции или макроса, определяет их типы и вызывает code_typed() на результирующем выражении.

code_warntype([io, ]f, types)

Выводит пониженные и типизированные AST для методов, соответствующих данной обобщённой функции и подписи типа, в io, по умолчанию в STDOUT. AST анотированы таким образом, чтобы подчеркнуть «нелистовые» типы (в случае наличия цвета, выведены красным). Это служит предупреждением о потенциальной нестабильности типа. Не все нелистовые типы проблематичны для производительности, поэтому результаты следует использовать с осторожностью. См. @code_warntype для более подробной информации.

@code_warntype()

Вычисляет аргументы функции или макроса, определяет их типы и вызывает code_warntype() на результирующем выражении.

code_llvm([io, ]f, types)

Выводит LLVM-биткоды, сгенерированные для выполнения метода, соответствующего данной обобщённой функции и подписи типа, в io, по умолчанию в STDOUT.

Все метаданные и вызовы dbg.* удаляются из выводимого биткода. Используйте code_llvm_raw для полного IR.

@code_llvm()

Вычисляет аргументы функции или макроса, определяет их типы и вызывает code_llvm() на результирующем выражении.

code_native([io, ]f, types)

Выводит инструкции машинного кода, сгенерированные для выполнения метода, соответствующего данной обобщённой функции и подписи типа, в io, по умолчанию в STDOUT.

@code_native()

Оценивает аргументы вызова функции или макроса, определяет их типы и вызывает code_native() для полученного выражения.

precompile(f, args::Tuple{Vararg{Any}})

Компилирует данную функцию f для кортежа аргументов (типов) args, но не выполняет её.