Кодирование - Переменные

## Переменные, что это такое?

Переменные позволяют вашему скрипту хранить информацию. Используя переменную, вы можете сохранить некоторый фрагмент данных один раз, а затем ссылаться на него позже, когда захотите. Lua не требует, чтобы вы объявляли переменную строго определенного типа, поэтому они могут содержать абсолютно все, включая ничего (nil).

Сохранение и запуск скриптов

Предполагается, что с этого момента вам не нужны объяснения по поводу открытия блокнота, сохранения и загрузки скрипта в Garry's Mod. Обратитесь к первой странице, если вы забыли.

Откройте свой редактор. Мы будем создавать новый скрипт с переменными!

В прошлом уроке мы узнали, как вывести простую строку на консоль:

```
print( "Привет, мир!" )

```
Это было достаточно просто: всякий раз, когда запускался наш скрипт, он говорил "Привет, мир!" в консоли:

print() - это функция. Функция - это команда, которая что-то делает, когда вы ее вызываете. Многие функции могут принимать аргументы, то есть данные, которые вы предоставляете функции, чтобы изменить именно то, что она делает. В этом случае print() принимает один аргумент, который представляет собой строку (последовательность букв, цифр, пробелов и так далее), и когда вызывается print(), он помещает эту строку в консоль.

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

```
print( "Привет, мир!" )

```
***print*** - это имя функции, которую мы вызываем. ***(*** и ***)*** (эти символы называются круглыми скобками) - это место, куда вы помещаете текст, который хотите напечатать, чтобы поместить в консоль.
"Привет, мир!" - это текст, который мы выбрали для печати; это ***строка*** - обратите внимание на ***" "*** (кавычки). Кавычки говорят Lua, что все, что находится между ними, является строкой, а не именем переменной. Делая это:

```
print( Привет, мир! )

```
не сработает, потому что у нас отсутствуют кавычки! Если мы сделаем это, Lua подумает, что Привет и мир! это имена двух переменных, а не строковый литерал. Помните: каждый раз, когда мы хотим, чтобы Lua знал, что информация, которую мы ему предоставляем, представляет собой некоторую форму текста, мы помещаем текст между кавычками, чтобы представить его в виде строки.

Фух! Ты все еще со мной? Это слова, которые вам нужно запомнить:

* ***Переменная*** (содержит значение)
* ***Функция*** (что-то делает, может принимать аргументы)
* ***Аргументы***, также известные как параметры (функции принимают их и что-то с ними делают)
* ***print**()* (функция, которая выводит текст в консоль)
* ***Строка*** (тип переменной, которая содержит текстовые данные)
* ***Скобки***
* ***Кавычки***

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

## Определяющие переменные

Переменная может быть создана, выполнив это:

```
myName = "Макс"

```
Имя переменной (*myName*) находится слева. Знак равенства говорит о том, что вы хотите установить значение этой переменной равным тому, что находится справа. Если вы помните, "Макс" - это строка, потому что она заключена в кавычки. *myName* - это имя переменной, потому что оно не заключено в кавычки! Осваиваешься с этим?

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

Но сначала давайте посмотрим, как использовать ***print***() с переменной вместо текста. Как вы уже знаете, первый способ, которым мы использовали сообщение, был примерно таким.

```
print( "Привет, мир!" )

```
Мы используем строку внутри *print()*, чтобы указать ей, что печатать. Но если мы хотим использовать переменную, мы делаем это:

```
myName = "Макс"
print( myName )

```
Всякий раз, когда это выполняется, ***print****()* выводит Макс в консоль, потому что мое имя - Макс. Хех, видишь?
Вы можете изменять переменные так же, как вы их создаете. Вот так:

```
myName = "Макс"
print( myName )

myName = "Игорь"
print( myName )

```
В приведенном выше примере сначала выводится Макс, а затем Игорь.

Сбит с толку? Вспомните алгебру

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

```
x = 4

```

Это означает, что ***x***, имя переменной, содержит значение 4, которое также можно выразить как "4 присваивается x" или "x равно 4".

В алгебре мы, возможно, также видели функцию с именем ***f***, определенную как

```
f(x) = 2x + 1

```

Если бы мы "подключили" или "передали" значение нашей переменной ***x*** функции ***f(x)***, функция использовала бы его для вычисления ***9***, потому что она умножила бы **2** на ***4*** и добавила ***1***. В этом случае ***f*** - это функция, ***x*** - аргумент, и все, что вычисляется внутри функции ***(2x + 1)***, полностью зависит от значения переданного ей аргумента ***x***. Например, если бы мы передали ***3*** в качестве аргумента вместо этого, то функция вычисляла бы ***7***.

Зная, как это работает, мы могли бы попробовать написать это на Lua, используя то, что мы узнали. Поскольку мы еще не знаем, как определить наши собственные функции, мы просто скажем коду напечатать результат 2x + 1 с помощью функции печати:

```
x = 4
print( 2 \* x + 1 ) --печатает 9

x = 3
print( 2 \* x + 1 ) --печатает 7

```
Надеюсь, это поможет вам немного лучше понять переменные, функции и аргументы.

## Локальные переменные

Локальные переменные - это переменные, которые доступны только в блоке кода, в котором они определены (также известном как "область видимости", в которой они определены), и во всех последующих дочерних блоках кода. Они определяются следующим образом:

```
local myName = "Макс"
print( myName )

```
В большинстве случаев вы захотите использовать локальные переменные, чтобы другие скрипты не могли их переопределять, или чтобы ваш скрипт не переопределял что-то из другого скрипта.
Этот пример показывает разницу между глобальной переменной и локальной переменной - в частности, как работает область видимости:

```
-- 2 Локальные переменные:
local myName = "Макс"
local myAge = 18

-- 2 глобальные переменные:
myPetName = "Питер"
filename = "test.lua"

print( myName, myPetName, myLastName, myAge, filename )
-- (Да, print может принимать более 1 аргумента)

if ( true ) then
    --теперь мы находимся в другом блоке кода:
    --любая локальная переменная, которую мы назначаем в этом блоке, будет
    --доступна только внутри этого блока, пока мы не достигнем "конца"
	local myName = "Георгий"
	local myLastName = "Игорь"
	local filename = "nope.jpg"

	myPetName = "Боб"
	myAge = 20

	print( myName, myPetName, myLastName, myAge, filename )
end

-- myPetName и myAge были изменены в приведенном выше блоке!
-- Остальные не были, так как они были локальными.
print( myName, myPetName, myLastName, myAge, filename )

```
Этот код будет иметь такой вывод:

```
Макс	Питер 	 nil  18	test.lua
Георгий	Боб	   Игорь  20	nope.jpg
Макс	Боб  	 nil  20	test.lua

```

## Сцепление

Объединение двух типов данных вместе для получения строки называется конкатенацией. Чтобы объединить, вам просто нужно использовать ***..*** Вот пример:

```
print( "Мне не нравится " .. "быть в разлуке.")

```
"***Мне не нравится*** " ***..*** "***быть в разлуке.***" стало ***"Мне не нравится быть в разлуке"***.

Обратите внимание!

Теперь струны счастливы, потому что они вместе, как одна струна.

Аналогично, вы можете объединить строковый литерал и переменную:

```
local myName = "Макс"
print( "Добро пожаловать в Москву," .. myName )

```
При этом выводится "Добро пожаловать в Москву, Макс", потому что ***myName*** содержит значение "Макс". Что он на самом деле делает, так это: "Добро пожаловать в Москву," **..** "Макс"
Вы можете использовать .. столько раз, сколько захотите. Смотреть ниже:

```
local myName = "Макс"
print( "Привет, " .. myName .. ". Я слышал, что тебя зовут " .. myName .. "! Хорошее имя." )
-- Это печатает: Привет, Макс. Я слышал, тебя зовут Макс! Хороший мем =)

```
Мы даже можем объединить другие типы значений, например числа, со строкой:

```
local myAge = 69
print( "Мне " .. myAge .. " лет." )
-- Печатает: Мне 69 лет..

```

## Новые строки

Последнее, что мы рассмотрим здесь, - это как использовать новые строки внутри строк. Новые строки создаются путем записи **\n** в строке, с которой вы хотите, чтобы начиналась новая строка. Вы можете использовать новые строки в любом месте строки, чтобы вставить новую строку (см. Ниже).:

```
local myName = "Макс"
print( "Привет, " .. myName .. "!\nКак у тебя дела?\nЯ чувствую себя великолепно." )

```
Это выводит это в консоль:

```
Привет, Джефф!
Как у тебя дела сегодня?
Я чувствую себя великолепно.

```

Многострочные строки также могут быть определены с помощью двойных квадратных скобок (**[[ ]]**) вместо кавычек. Это позволяет вам создавать новые строки в строке без использования **\n**.

Пример:

```
print( [[Привет, Джефф!
Как у тебя дела сегодня?
Я чувствую себя великолепно.]] )

```
Печатает:

```
Привет, Джефф!
Как у тебя дела сегодня?
Я чувствую себя великолепно.

```