ch03-02

rustbook-ru/src/ch03-02-data-types.md

@@ -8,7 +8,7 @@
 let guess: u32 = "42".parse().expect("Not a number!");
 ```
 
-Если мы не добавим аннотацию типа `: u32` выше, Rust отобразит ошибку, потому что компилятору нужно больше информации от нас, чтобы узнать, какой тип мы хотим использовать:
+Если мы не добавим аннотацию типа `: u32` как показано выше, Rust отобразит ошибку, что компилятору нужно больше информации от нас, чтобы узнать, какой тип мы хотим использовать:
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/output-only-01-no-type-annotations/output.txt}}
@@ -35,7 +35,7 @@ let guess: u32 = "42".parse().expect("Not a number!");
 128 бит | `i128` | `u128`
 arch | `isize` | `usize`
 
-Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement)<!-- ignore -->.
+Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Характеристика типа как *знаковый* и *без знаковый* определяет возможность числа быть отрицательным, другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement)<!-- ignore -->.
 
 Каждый вариант со знаком может хранить числа от -(2 <sup>n - 1</sup> ) до 2 <sup>n - 1</sup> - 1 включительно, где *n* — количество битов, которые использует этот вариант. Таким образом, `i8` может хранить числа от -(2 <sup>7</sup> ) до 2 <sup>7</sup> - 1, что равно значениям от -128 до 127. Варианты без знака могут хранить числа от 0 до 2 <sup>n</sup> - 1, поэтому `u8` может хранить числа от 0 до 2 <sup>8</sup> - 1, что равно значениям от 0 до 255.
 
@@ -57,7 +57,7 @@ arch | `isize` | `usize`
 
 > ##### Целочисленное переполнение
 >
-> Допустим, у вас есть переменная типа `u8`, которая может содержать значения от 0 до 255. Если вы попытаетесь изменить переменную на значение вне этого диапазона, например 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Когда вы компилируете в режиме отладки, Rust включает проверки целочисленного переполнения, которые вызывают *панику* вашей программы во время работы, если происходит переполнение. Rust использует термин «паника», когда программа завершает работу с ошибкой; мы обсудим паники более подробно в разделе [«Неисправимые ошибки с `panic!`»]<!-- ignore --> в главе 9.
+> Допустим, у вас есть переменная типа `u8`, которая может содержать значения от 0 до 255. Если вы попытаетесь изменить переменную на значение вне этого диапазона, например 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Когда вы компилируете в режиме отладки, Rust включает проверки целочисленного переполнения, которые вызывают *панику* вашей программы во время выполнения, если происходит переполнение. Rust использует термин «паника», когда программа завершает работу с ошибкой; мы обсудим паники более подробно в разделе [«Неисправимые ошибки с `panic!`»][unrecoverable-errors-with-panic]<!-- ignore --> в Главе 9.
 >
 > Когда вы компилируете финальную версию программы с флагом `--release`, Rust *не* включает проверки целочисленного переполнения, вызывающего панику. Вместо этого, если происходит переполнение, Rust выполняет *оборачивание дополнительного кода (two's complement)*. Если описывать в двух словах, то значения, превышающие максимальное значение, которое может содержать тип, «переходят» к минимуму значений. В случае `u8` значение 256 становится равным 0, значение 257 становится равным 1 — и так далее. Программа не будет паниковать, но переменная будет иметь значение, которое, вероятно, будет не таким, как вы ожидали. Полагаться на такое поведение считается ошибкой.
 >
@@ -92,7 +92,7 @@ Rust поддерживает основные математические оп
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-07-numeric-operations/src/main.rs}}
 ```
 
-Каждое из этих выражений использует математические операции и вычисляет значение, которое затем присваивается переменной. [Приложение Б](appendix-02-operators.html)<!-- ignore --> содержит список всех операторов, имеющихся в Rust.
+Каждое из этих выражений использует математические операции и вычисляет значение, которое затем присваивается переменной. ["Приложение B"][appendix_b]<!-- ignore --> содержит список всех операторов, имеющихся в Rust.
 
 #### Логический тип данных
 
@@ -104,7 +104,7 @@ Rust поддерживает основные математические оп
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-08-boolean/src/main.rs}}
 ```
 
-Основной способ использования значений логического типа — условные конструкции, такие как выражение `if`. Мы расскажем про работу выражения `if` в разделе [«Условные конструкции»]<!-- ignore -->.
+Основной способ использования значений логического типа - это условные конструкции, такие как выражение `if`. Мы расскажем про работу выражения `if` в разделе ["Управляющие конструкции"][control-flow]<!-- ignore -->.
 
 #### Символьный тип данных
 
@@ -116,13 +116,13 @@ Rust поддерживает основные математические оп
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-09-char/src/main.rs}}
 ```
 
-Обратите внимание, что мы указываем литералы `char` в одинарных кавычках, в отличие от строковых литералов, которые используют двойные кавычки. Тип `char` в Rust имеет размер четыре байта и представляет собой скалярное значение Unicode. Это значит, что он может представлять гораздо больше, чем просто ASCII. Буквы с ударением; китайские, японские и корейские иероглифы; эмодзи и пробелы нулевой ширины являются допустимыми значениями `char` в Rust. Скалярные значения Unicode находятся в диапазоне от `U+0000` до `U+D7FF` и от `U+E000` до `U+10FFFF` включительно. Однако «символ» на самом деле не является концепцией в Unicode, поэтому интуитивно может не совпадать с тем, что такое `char` в Rust. Мы подробно обсудим эту тему в разделе [«Сохранение текста в кодировке UTF-8 со строками»]<!-- ignore --> в главе 8.
+Обратите внимание, что мы указываем литералы `char` в одинарных кавычках, в отличие от строковых литералов, которые используют двойные кавычки. Тип `char` в Rust имеет размер четыре байта и представляет собой Скалярное Значение Unicode, что означает, что он может представлять гораздо больше, чем просто ASCII. Буквы с ударением; китайские, японские и корейские иероглифы; эмодзи; и пробелы нулевой ширины являются допустимыми значениями `char` в Rust. Скалярные Значения Unicode находятся в диапазоне от `U+0000` до `U+D7FF` и от `U+E000` до `U+10FFFF` включительно. Однако «символ» на самом деле не является концепцией в Unicode, поэтому интуитивно может не совпадать с тем, что такое `char` в Rust. Мы подробно обсудим эту тему в разделе [«Сохранение текста с UTF-8 кодировкой в строках»][strings]<!-- ignore --> в Главе 8.
 
 ### Сложные типы данных
 
 *Сложные типы* могут группировать несколько значений в один тип. В Rust есть два примитивных сложных (комбинированных) типа: кортежи и массивы.
 
-#### Кортежи
+#### Кортежи<a id="the-tuple-type"/>
 
 Кортеж является общим способом совместной группировки нескольких значений различного типа в единый комбинированный тип. Кортежи имеют фиксированную длину: после объявления они не могут расти или уменьшаться в размере.
 
@@ -168,7 +168,7 @@ Rust поддерживает основные математические оп
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-13-arrays/src/main.rs}}
 ```
 
-Массивы полезны, когда вы хотите, чтобы ваши данные размещались в стеке, а не в куче (мы более подробно обсудим стек и кучу в [главе 4]<!-- ignore -->), или когда вы хотите, чтобы у вас всегда было фиксированное количество элементов. Однако массив не такой гибкий, как векторный тип. Вектор — это аналогичный тип коллекции, предоставляемый стандартной библиотекой, размер которого *может* увеличиваться или уменьшаться. Если вы не уверены, использовать массив или вектор, скорее всего, вам следует использовать вектор. [Глава 8]<!-- ignore --> раскрывает векторы более подробно.
+Массивы полезны, когда вы хотите, чтобы ваши данные размещались в стеке, а не в куче (мы более подробно обсудим стек и кучу в [Главе 4][stack-and-heap]<!-- ignore -->) или когда вы хотите, чтобы у вас всегда было фиксированное количество элементов. Однако массив не такой гибкий, как векторный тип. Вектор — это аналогичный тип коллекции, предоставляемый стандартной библиотекой, размер *которого* может увеличиваться или уменьшаться. Если вы не уверены, использовать ли массив или вектор, скорее всего, вам следует использовать вектор. [Глава 8][vectors]<!-- ignore --> раскрывает векторы более подробно.
 
 Однако массивы более полезны, когда вы знаете, что количество элементов не нужно будет изменять. Например, если бы вы использовали названия месяцев в программе, вы, вероятно, использовали бы массив, а не вектор, потому что вы знаете, что он всегда будет содержать 12 элементов:
 
@@ -232,9 +232,11 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 Это пример принципов безопасности памяти Rust в действии. Во многих низкоуровневых языках такая проверка не выполняется, и когда вы указываете неправильный индекс, доступ к памяти может быть некорректным. Rust защищает вас от такого рода ошибок, немедленно закрываясь вместо того, чтобы разрешать доступ к памяти и продолжать работу. В главе 9 подробнее обсуждается обработка ошибок в Rust и то, как вы можете написать читаемый, безопасный код, который не вызывает панику и не разрешает некорректный доступ к памяти.
 
-
-[«Условные конструкции»]: ch03-05-control-flow.html#control-flow
-[«Сохранение текста в кодировке UTF-8 со строками»]: ch08-02-strings.html#storing-utf-8-encoded-text-with-strings
-[главе 4]: ch04-01-what-is-ownership.html#the-stack-and-the-heap
-[Глава 8]: ch08-01-vectors.html
-[«Неисправимые ошибки с `panic!`»]: ch09-01-unrecoverable-errors-with-panic.html
+[comparing-the-guess-to-the-secret-number]: ch02-00-guessing-game-tutorial.html#comparing-the-guess-to-the-secret-number
+[control-flow]: ch03-05-control-flow.html#control-flow
+[strings]: ch08-02-strings.html#storing-utf-8-encoded-text-with-strings
+[stack-and-heap]: ch04-01-what-is-ownership.html#the-stack-and-the-heap
+[vectors]: ch08-01-vectors.html
+[unrecoverable-errors-with-panic]: ch09-01-unrecoverable-errors-with-panic.html
+[wrapping]: https://doc.rust-lang.org/std/num/struct.Wrapping.html
+[appendix_b]: appendix-02-operators.md