Переменные

Для хранения данных в программе в языке Rust используются переменные. Каждая переменная характиризуется тремя элементами: названием переменной, типом данных переменной и ее значением.

Для определения переменной в Rust применяется ключевое слово let:

let название_переменной: тип_переменной;

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

Например:

let age: u32;

В данном случае переменная называется age и имеет тип u32. Тип u32 представляет положительное целое число. То есть переменная age может хранить положительное целое число.

После определения переменной ей можно присвоить значение. Присваиваемое переменной значение должно соответствовать ее типу. Например, выше переменная age имеет тип u32, то есть целое число. Поэтому ей можно присвоить только целое число. Для присвоения переменной значения применяется знак "равно" (=):

let age: u32;
age = 36;

В данном случае переменная age хранит число 36. Присвоение переменной начального значения называется инициализацией, а переменная после первого присвоения ей значения является инициализированной.

Также можно сразу присвоить переменной значение при ее определении:

let age: u32 = 36;

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

let age = 36;

Использование переменных. Вывод на консоль

После того как мы определили и инициализировали переменную, мы можем ее использовать. Например, выведем значение переменной на консоль:

fn main(){
	let age: u32;
	age = 36;
    println!("Age = {}", age);
}

Для вывода на консоль применяется макрос println!. Он выводит строку текста, которая заключается в двойные кавычки:

println!("Age = ");

А чтобы добавить в выводимую строку значение переменной, в строке применяются фигурные скобки "{}". А выводимая переменная указывается после строки через запятую:

println!("Age = {}", age);

То есть вместо фигурных скобок будет вставляться значение переменной age.

В итоге на консоль будет выведено:

Age = 36

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

fn main(){
	let age = 36;
	let name = "Tom";
    println!("Name = {}  Age = {}", name, age);
}

В данном случае определяются две переменных. Одна переменная - age хранит числа, другая переменная - name хранит строки и имеет значение "Tom".

Так как теперь нам надо вывести значения двух переменных, в строке, которая передается макросу println! определяются две пары фигурных скобок:

"Name = {}  Age = {}"

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

"Name = {}  Age = {}", name, age

Первая переменная в этом списке - name предоставляет значение для первой пары фигурных скобок, вторая переменная - age - для второй пары фигурных скобок. В итоге на консоль будет выведено:

Name = Tom  Age = 36

Макрос println!() добавляет перевод на новую строку. То есть каждый новый вызов данного макроса выводит данные на новой строке. Но также есть макрос print!(), который выводит данные на той же строке:

fn main(){
	let age = 36;
	let name = "Tom";
    print!("Name = {} ", name);
	print!("Age = {}", age);
}

Стоит отметить, что мы не можем использовать неинициализированную переменную (то есть переменную, которой не присвоено значение). Например, в следующем случае при компиляции компилятор отобразит нам ошибку:

fn main(){
	let age: u32;
    println!("Age = {}", age);	// переменная age неинициализирована 
}

Изменение значения переменной

По умолчанию все переменные в Rust являются неизменяемыми (immutable). А это значит, что после присвоения переменной значения, по умолчанию ее значение больше нельзя изменить. Если мы попробуем это сделать, то мы столкнемся с ошибкой, как, например, в следующем случае:

fn main(){
	let age = 36;
	age = 25;		// ошибка!
    println!("Age = {}", age);
}

Тем не менее иногда может возникать необходимость изменить значение переменной. Чтобы значение переменной можно было менять в процессе программы, при определении переменной перед ее именем указывается ключевое слово mut:

let mut age = 36;

После этого можно изменять значение переменной:

fn main(){
	let mut age = 36;
    println!("Начальное значение: {}", age);
	age = 25;
    println!("Конечное значение: {}", age);
}

Затенение переменных

В Rust можно применять то, что называется shadowing или затенение/скрытие переменных. То есть мы можем определить переменную с одним и тем же именем и она будет скрывать (затенять) определение предыдущей переменной с тем же именем.

fn main(){
	let number = 10;
	println!("number = {}", number);
	let number = 15;
	println!("number = {}", number);
	let number = 254;
	println!("number = {}", number);
}

Консольный вывод:

number = 10
number = 15
number = 254