Merge pull request #33 from SBozhko/patch-6

Fix grammar issues in chapter 4

Author: maxpoletaev

src/_book/chapter-04-variables.md

@@ -4,7 +4,7 @@ layout: "chapter"
 
 ---
 
-Ранее в этой книге мы имели дело с литеральными значениями (числами, строками, и
+Ранее в этой книге мы имели дело с литеральными значениями (числами, строками и
 т.д.), но программы с одними только литералами фактически бесполезны. Для того,
 чтобы сделать по-настоящему полезные программы, нам нужно узнать о двух важных
 вещах: переменных и инструкциях, управляющих ходом исполнения. В этой главе
@@ -42,12 +42,12 @@ layout: "chapter"
 
 Переменные в Go похожи на переменные в алгебре, но есть несколько различий:
 
-Во первых, когда мы видим символ `=`, мы по привычки читаем его как «х равен
+Во первых, когда мы видим символ `=`, мы по привычке читаем его как «х равен
 строке Hello World». Нет ничего неверного в том, чтобы читать программу таким
-образом, но лучше читать это как: «х принимает значение строки Hello World» или
-«x присваивается строка Hello World». Это различие важно потому, что (как
-понятно по их названию) переменные могут менять свои значения во время
-выполнения программы. Попробуйте сделать следующее:
+образом, но лучше читать это как «х принимает значение строки Hello World» или
+«x присваивается строка Hello World». Это различие важно потому, что
+переменные могут менять свои значения во время выполнения программы
+(как понятно по их названию). Попробуйте сделать следующее:
 
     package main
 
@@ -61,7 +61,7 @@ layout: "chapter"
         fmt.Println(x)
     }
 
-На самом деле, вы можете сделать даже так:
+На самом деле вы можете сделать даже так:
 
     var x string
     x = "first "
@@ -70,20 +70,20 @@ layout: "chapter"
     fmt.Println(x)
 
 Эта программа будет бессмысленной, если вы будете читать её как теорему из
-алгебры. Но она обретет смысл если вы будете внимательно читать программу как
-список команд. Когда вы видим `x = x + "second"`, то должны читать это так:
-«присвоить конкатенацию значения переменной x и литерала строки переменной x».
-Операции справа от `=` выполняются первыми и результат присваивается левой
+алгебры. Но она обретет смысл, если вы будете внимательно читать программу как
+список команд. Когда мы видим `x = x + "second"`, то должны читать это так:
+«Присвоить конкатенацию значения переменной x и литерала строки переменной x».
+Операции справа от `=` выполняются первыми, и результат присваивается левой
 части.
 
 Запись `x = x + y` настолько часто встречается в программировании, что в Go есть
 специальный оператор присваивания `+=`.  Мы можем записать `x = x + "second"`
-как `x += "second"` и результат будет тем же. (Прочие операторы могут быть
-использованы подобным образом)
+как `x += "second"`, и результат будет тем же. (Прочие операторы могут быть
+использованы подобным образом).
 
 Другое отличие между Go и алгеброй в том, что используется другой символ для
-равенства: `==`. (Два знака равно, один за другим) `==` - это оператор, как и `+`
-и он возвращает логический тип. Например:
+равенства: `==`. (Два знака равно, один за другим) `==` - это оператор. Как и `+`,
+он возвращает логический тип. Например:
 
     var x string = "hello"
     var y string = "world"
@@ -95,17 +95,17 @@ layout: "chapter"
     var y string = "hello"
     fmt.Println(x == y)
 
-Напечатает `true`, потому что обе строки одинаковы.
+напечатает `true`, потому что обе строки одинаковы.
 
 Если мы хотим присвоить значение переменной при её создании, то можем
 использовать сокращенную запись:
 
     x := "Hello World"
 
-Обратите внимание на то что `:` стоит перед `=` и на отсутствие типа. Тип в
-данном случае указывать необязательно, так как компилятор Go способен определить
-тип по литералу, которым мы инициализируем переменную. (Тут мы присваиваем
-строку, поэтому x будет иметь тип `string`) Компилятор может определить тип и
+Обратите внимание на то, что `:` стоит перед `=` и на отсутствие типа. Тип в
+данном случае указывать не обязательно, так как компилятор Go способен определить
+тип по литералу, которым мы инициализируем переменную. Тут мы присваиваем
+строку, поэтому x будет иметь тип `string`. Компилятор может определить тип и
 при использовании `var`:
 
     var x = "Hello World"
@@ -128,7 +128,7 @@ layout: "chapter"
     x := "Max"
     fmt.Println("My dog's name is", x)
 
-В этом случае, `x` - это не самое лучшее имя переменной. Лучше было бы так:
+В этом случае `x` не самое лучшее имя переменной. Лучше было бы так:
 
     name := "Max"
     fmt.Println("My dog's name is", name)
@@ -141,7 +141,7 @@ layout: "chapter"
 В последнем случае мы использовали специальный способ написания имени
 переменной, состоящей из нескольких слов, известный как lower CamelCase (или
 camelBack). Первая буква первого слова записывается в нижнем регистре, первая
-буква последующих слов записывается в верхнем регистре - всё остальное в нижнем.
+буква последующих слов записывается в верхнем регистре, всё остальное - в нижнем.
 
 ## Область видимости
 
@@ -199,16 +199,16 @@ camelBack). Первая буква первого слова записывае
 
 Компилятор говорит вам, что переменная `x` внутри функции `f` не существует. Она
 существует только внутри функции `main`. Места, где может использоваться
-переменная `x` называется областью видимости переменной. Согласно спецификации:
-«В Go область видимости ограничена блоками». В основном, это значит, что
+переменная `x`, называются областью видимости переменной. Согласно спецификации,
+«в Go область видимости ограничена блоками». В основном, это значит, что
 переменные существуют только внутри текущих фигурных скобок `{` `}` (в блоке),
 включая все вложенные скобки (блоки). Область видимости поначалу может запутать
 вас, но когда вы увидите больше примеров, то всё станет ясно.
 
 ## Константы
 
 Go также поддерживает константы. Константы — это переменные, чьи значения не
-могут быть изменены после инициализации. Они создаются таки же образом, как и
+могут быть изменены после инициализации. Они создаются таким же образом, как и
 переменные, только вместо `var` используется ключевое слово `const`:
 
     package main
@@ -229,12 +229,12 @@ Go также поддерживает константы. Константы 
 
     .\main.go:7: cannot assign to x
 
-Константы — хороший способ использовать определенные значения в программе, без
+Константы — хороший способ использовать определенные значения в программе без
 необходимости писать их каждый раз. Например, константа `Pi` из пакета `math`.
 
 ## Определение нескольких переменных
 
-В Go существует еще одно сокращение, на случай, если необходимо определить несколько переменных:
+В Go существует еще одно сокращение на случай, если необходимо определить несколько переменных:
 
     var (
         a = 5
@@ -263,8 +263,8 @@ Go также поддерживает константы. Константы 
 
 
 Тут мы используем другую функцию из пакета `fmt`, чтобы считать пользовательский
-ввод (`Scanf`). `&input` будет объяснен в следующий главах, и все что нам нужно
-знать сейчас — что `Scanf` заполняет переменную `input` числом, введенным нами.
+ввод (`Scanf`). `&input` будет объяснен в следующих главах, а все, что нам нужно
+знать сейчас, это то, что `Scanf` заполняет переменную `input` числом, введенным нами.
 
 ## Задачи
 
@@ -280,4 +280,4 @@ Go также поддерживает константы. Константы 
 *   Используя пример программы выше, напишите программу, переводящую температуру
     из градусов Фаренгейта в градусы Цельсия. (`C = (F - 32) * 5/9`)
 
-*   Напишите другую программу, для перевода футов в метры. (1 фут = 0.3048 метр)
+*   Напишите другую программу для перевода футов в метры. (1 фут = 0.3048 метр)