Переменная в Julia – это имя, привязанное к значению. Она используется, когда вы хотите сохранить значение (полученное, например, после математических вычислений) для последующего использования. Например:
● Присвоить значение 100 переменной x
julia> x = 100
100
● Выполнение математических операций со значением x
julia> x * 5
500
● Переназначить значение x
julia> x = 10 + 10
20
● Можно присваивать и значения других типов, например, строки текста
julia> x = "Hello World!"
"Hello World!"
Присвоение "имя = значение" привязывает переменную имени к значению, вычисленному в правой части, и все присваивание рассматривается Julia как выражение, равное значению правой части. Это означает, что присваивания можно объединять (одно и то же значение присваивается нескольким переменным переменная1 = переменная2 = значение) или использовать в других выражениях, а также то, почему их результат отображается в REPL как значение правой части. Например, здесь значение 4 из b = 2+2 используется в другой арифметической операции и присваивании:
julia> a = (b = 2 + 2) * 5
20
julia> a
20
julia> b
4
При знакомстве с переменными в Julia у новых пользователей часто возникает путаница между присвоением имени и изменением значения. Если вы выполнили a = 2, а затем a = 3, то вы изменили имя a, чтобы оно ссылалось на новое значение 3. Вы не изменили число 2, поэтому 2+2 по-прежнему дает 4, а не 6! Это различие становится более очевидным при работе с мутабельными типами данных, такими как массивы, содержимое которых может быть изменено:
julia> a=[1,2,3]
3-element Vector{Int64}:
1
2
3
julia> b=a
3-element Vector{Int64}:
1
2
3
Здесь строка b = a не создает копию массива a, а просто связывает имя b с тем же массивом: a и b "указывают" на один массив [1,2,3] в памяти.
Изменим значение первого элемента массива:
julia> a[1] = 42
42
Присваивание a[i] = value изменяет содержимое массива, измененный массив будет виден через имена a и b:
julia> a
3-element Vector{Int64}:
42
2
3
julia> b
3-element Vector{Int64}:
42
2
3
Пусть a теперь является именем другого объекта:
julia> a= 3.14159
3.14159
Установка a = 3.14159 не изменяет массив, а просто привязывает a к другому объекту, массив по-прежнему доступен через b:
julia> b
3-element Vector{Int64}:
42
2
3
Имена переменных в Julia могут быть любой длины,а также могут содержать в себе почти все символы Unicode, но не могут начинаться с цифры. В именах можно использовать прописные и строчные буквы, символ подчеркивания ('_') также может использоваться в имени переменной в любом месте. Имена переменных чувствительны к регистру.
Единственными явно запрещенными именами переменных являются имена встроенных ключевых слов: baremodule, begin, break, catch, const, continue, do, else, elseif, end, export, false, finally, for, function, global, if, import, let, local, macro, module, quote, return, struct, true, try, using, while.
Примеры допустимых и недопустимых имен:
julia> х1 = 100
100
julia> 1x=100
ERROR: syntax: "1" is not a valid function argument name around REPL[2]:1
julia> ●="Точка"
"Точка"
julia> text@ = "Строка текста"
ERROR: syntax: extra token "@" after end of expression
По умолчанию Julia автоматически определяет какой тип данных использовать для значения переменной, но в некоторых случая, во избежании ошибок, следует указать тип данных для значений вручную.
Ниже приведен пример такой ошибки. Здесь функция typeof() возвращающая тип аргумента, а sqrt() – корень квадратный из аргумента:
julia> x=-2.0
–2.0
julia> typeof(x)
Float64
julia> sqrt(x)
ERROR: DomainError with -2.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Происходит следующее: Julia автоматически определяет тип значения переменной, как Float64, исходя из того, что в большинстве случаев используются действительные числа, а не комплексные, что и вызывало ошибку. Теперь тот же пример используя комплексную форму записи:
julia> x=-2.0+0im
–2.0 + 0.0im
julia> typeof(x)
ComplexF64 (alias for Complex{Float64})
julia> sqrt(x)
0.0 + 1.4142135623730951im
В этом случае Julia определяет тип значения исходя из формы записи как Complex{Float64}, по сути формой записи мы задали тип значения переменной.
Типы есть только у значений. У переменных типов нет. Переменные – это просто имена, связанные со значениями, хотя для простоты можно говорить "тип переменной", как сокращение от "тип значения, на которое ссылается переменная".
Julia изначально предоставляет довольно полный и иерархически организованный набор предопределенных типов, особенно числовых. Это либо скаляры, такие как: целые числа (Int), числа с плавающей запятой (Float) и символы (Char). Либо контейнероподобные структуры, способные хранить другие объекты, такие как: многомерные массивы (Array), словари (Dict), наборы (Set) и т. д. По стилистическим соглашениям названия типов начинаются с заглавной буквы, например Int64 или Bool. Иногда в фигурных скобках за именем типа следуют другие параметры, например типы содержащихся элементов или количество измерений. Эти параметры встречаются у всех контейнероподобных структур и некоторых неконтейнерных. Например тип Array{Int64,2} будет использоваться для двумерного массива целых 64-битных чисел со знаком. В терминологии Julia такие типы называются параметрическими.
Оператор :: можно использовать для присоединения аннотаций типов к выражениям и переменным в программах, например:
julia> (2+2)::Int
4
julia> (2+2)::AbstractFloat
ERROR: TypeError: in typeassert, expected AbstractFloat, got a value of type Int64
julia> (2.0+2.0)::AbstractFloat
4.0
При добавлении к выражению, вычисляющему значение, оператор :: читается как "является экземпляром". Его можно использовать в любом месте, чтобы утверждать, что значение выражения слева является экземпляром типа справа. Если тип справа конкретный, то значение слева должно иметь этот тип в качестве своей реализации. Если тип абстрактный, то достаточно, чтобы значение было реализовано конкретным типом, который является подтипом абстрактного типа. Если утверждение о типе не истинно, выбрасывается исключение, в противном случае возвращается левое значение.
Пример используемый выше, теперь нет нужды использовать комплексную форму записи:
julia> x::Complex{Float64}=-2
–2
julia> typeof(x)
ComplexF64 (alias for Complex{Float64})
julia> sqrt(x)
0.0 + 1.4142135623730951im
Когда оператор :: добавляется к переменной в левой части присваивания, он означает немного другое: он объявляет переменную всегда имеющей указанный тип, как объявление типа в статически типизированном языке, таком как C. Каждое значение, присвоенное переменной, будет преобразовано к объявленному типу с помощью функции convert(), если это возможно.