From 5b9d79b202fc527c136a6988cedbb6b23a3b631e Mon Sep 17 00:00:00 2001 From: Roman Ponomarev Date: Mon, 16 Oct 2023 11:46:05 +0000 Subject: [PATCH 1/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 31 +++++++++++---------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index b1f2f07ce..f99f0ecdb 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -29,13 +29,13 @@ let guess: u32 = "42".parse().expect("Not a number!"); Длина | Со знаком | Без знака --- | --- | --- 8-бит | `i8` | `u8` -16 бит | `i16` | `u16` -32 бита | `i32` | `u32` -64 бита | `i64` | `u64` -128 бит | `i128` | `u128` +16-bit | `i16` | `u16` +32-bit | `i32` | `u32` +64-bit | `i64` | `u64` +128-bit | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` -Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода]. +Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement). Каждый вариант со знаком может хранить числа от -(2 n - 1 ) до 2 n - 1 - 1 включительно, где *n* — количество битов, которые использует этот вариант. Таким образом, `i8` может хранить числа от -(2 7 ) до 2 7 - 1, что равно значениям от -128 до 127. Варианты без знака могут хранить числа от 0 до 2 n - 1, поэтому `u8` может хранить числа от 0 до 2 8 - 1, что равно значениям от 0 до 255. @@ -45,17 +45,17 @@ let guess: u32 = "42".parse().expect("Not a number!"); Таблица 3-2: Целочисленные литералы в Rust -Числовой литерал | Пример +Числовой литерал | Example --- | --- -Десятичный | `98_222` -Шестнадцатеричный | `0xff` -Восьмеричный | `0o77` +Decimal | `98_222` +Hex | `0xff` +Octal | `0o77` Двоичный | `0b1111_0000` Байт (только `u8`) | `b'A'` Как же узнать, какой тип целого числа использовать? Если вы не уверены, значения по умолчанию в Rust, как правило, подходят для начала: целочисленные типы по умолчанию `i32`. Основной случай, в котором вы должны использовать `isize` или `usize`, — это индексация какой-либо коллекции. -> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"] в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: +> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"](ch09-01-unrecoverable-errors-with-panic.html) в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: > - Обёртывание во всех режимах с помощью методов `wrapping_*`, таких как `wrapping_add`. > - Возврат значения `None` при переполнении с помощью методов `checked_*`. > - Возврат значения и логический индикатор, указывающий, произошло ли переполнение при использовании методов `overflowing_*`. @@ -98,7 +98,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-08-boolean/src/main.rs}} ``` -Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"]. +Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"](ch03-05-control-flow.html#control-flow). #### Символьный тип данных @@ -162,7 +162,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-13-arrays/src/main.rs}} ``` -Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4]) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8]. +Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4](ch04-01-what-is-ownership.html#the-stack-and-the-heap)) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8](ch08-01-vectors.html). Однако массивы более полезны, когда вы знаете, что количество элементов не нужно будет изменять. Например, если бы вы использовали названия месяцев в программе, вы, вероятно, использовали бы массив, а не вектор, потому что вы знаете, что он всегда будет содержать 12 элементов: @@ -225,10 +225,3 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace Программа столкнулась с ошибкой во *времени выполнения* на этапе применения недопустимого значения в операции индексирования. Программа завершилась с сообщением об ошибке и не выполнила финальный оператор `println!`. При попытке доступа к элементу с помощью индексирования Rust проверяет, что указанный индекс меньше длины массива. Если индекс больше или равен длине, Rust паникует. Эта проверка должна происходить во время выполнения, особенно в данном случае, потому что компилятор не может знать, какое значение введёт пользователь при последующем выполнении кода. Это пример принципов безопасности памяти Rust в действии. Во многих низкоуровневых языках такая проверка не выполняется, и когда вы указываете неправильный индекс, доступ к памяти может быть некорректным. Rust защищает вас от такого рода ошибок, немедленно закрываясь вместо того, чтобы разрешать доступ к памяти и продолжать работу. В главе 9 подробнее обсуждается обработка ошибок в Rust и то, как вы можете написать читаемый, безопасный код, который не вызывает панику и не разрешает некорректный доступ к памяти. - - -[дополнительного кода]: https://en.wikipedia.org/wiki/Two%27s_complement -["Поток управления"]: ch03-05-control-flow.html#control-flow -[Главе 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 \ No newline at end of file From ada79d999a48d86f018667244f1d52caf3c67d6e Mon Sep 17 00:00:00 2001 From: Dmitry Luschan Date: Mon, 16 Oct 2023 11:46:07 +0000 Subject: [PATCH 2/8] Translate ch03-02-data-types.md via GitLocalize From aff4ec8438e3460541e541e6c96b8b812d0cf576 Mon Sep 17 00:00:00 2001 From: Sergey Astakhov Date: Mon, 16 Oct 2023 11:46:08 +0000 Subject: [PATCH 3/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index f99f0ecdb..2e17409f1 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -28,11 +28,11 @@ let guess: u32 = "42".parse().expect("Not a number!"); Длина | Со знаком | Без знака --- | --- | --- -8-бит | `i8` | `u8` -16-bit | `i16` | `u16` +8 бит | `i8` | `u8` +16 бит | `i16` | `u16` 32-bit | `i32` | `u32` 64-bit | `i64` | `u64` -128-bit | `i128` | `u128` +128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement). @@ -45,9 +45,9 @@ let guess: u32 = "42".parse().expect("Not a number!"); Таблица 3-2: Целочисленные литералы в Rust -Числовой литерал | Example +Числовой литерал | Пример --- | --- -Decimal | `98_222` +Десятичный | `98_222` Hex | `0xff` Octal | `0o77` Двоичный | `0b1111_0000` From bbb33368010bcf86ccb45d9ed575dc26c155061d Mon Sep 17 00:00:00 2001 From: Tatyana Date: Mon, 16 Oct 2023 11:46:08 +0000 Subject: [PATCH 4/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index 2e17409f1..93385ae8b 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -30,7 +30,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); --- | --- | --- 8 бит | `i8` | `u8` 16 бит | `i16` | `u16` -32-bit | `i32` | `u32` +32 бита | `i32` | `u32` 64-bit | `i64` | `u64` 128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` From 6cca3efe29e53fc840b49ff0a0ddf5defb5ccc5a Mon Sep 17 00:00:00 2001 From: Pavel-i-tel Date: Mon, 16 Oct 2023 11:46:09 +0000 Subject: [PATCH 5/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index 93385ae8b..21ec25b54 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -31,7 +31,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); 8 бит | `i8` | `u8` 16 бит | `i16` | `u16` 32 бита | `i32` | `u32` -64-bit | `i64` | `u64` +64 бита | `i64` | `u64` 128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` @@ -48,8 +48,8 @@ let guess: u32 = "42".parse().expect("Not a number!"); Числовой литерал | Пример --- | --- Десятичный | `98_222` -Hex | `0xff` -Octal | `0o77` +Шестнадцатиричный | `0xff` +Восьмиричный | `0o77` Двоичный | `0b1111_0000` Байт (только `u8`) | `b'A'` From 49ef5414b290a23483ea8924ba491777a8b90f4b Mon Sep 17 00:00:00 2001 From: Yuriy Larin Date: Mon, 16 Oct 2023 11:46:09 +0000 Subject: [PATCH 6/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index 21ec25b54..09ecb72c3 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -35,7 +35,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); 128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` -Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement). +Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода]. Каждый вариант со знаком может хранить числа от -(2 n - 1 ) до 2 n - 1 - 1 включительно, где *n* — количество битов, которые использует этот вариант. Таким образом, `i8` может хранить числа от -(2 7 ) до 2 7 - 1, что равно значениям от -128 до 127. Варианты без знака могут хранить числа от 0 до 2 n - 1, поэтому `u8` может хранить числа от 0 до 2 8 - 1, что равно значениям от 0 до 255. @@ -55,7 +55,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); Как же узнать, какой тип целого числа использовать? Если вы не уверены, значения по умолчанию в Rust, как правило, подходят для начала: целочисленные типы по умолчанию `i32`. Основной случай, в котором вы должны использовать `isize` или `usize`, — это индексация какой-либо коллекции. -> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"](ch09-01-unrecoverable-errors-with-panic.html) в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: +> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"] в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: > - Обёртывание во всех режимах с помощью методов `wrapping_*`, таких как `wrapping_add`. > - Возврат значения `None` при переполнении с помощью методов `checked_*`. > - Возврат значения и логический индикатор, указывающий, произошло ли переполнение при использовании методов `overflowing_*`. @@ -98,7 +98,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-08-boolean/src/main.rs}} ``` -Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"](ch03-05-control-flow.html#control-flow). +Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"]. #### Символьный тип данных @@ -162,7 +162,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-13-arrays/src/main.rs}} ``` -Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4](ch04-01-what-is-ownership.html#the-stack-and-the-heap)) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8](ch08-01-vectors.html). +Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4]) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8]. Однако массивы более полезны, когда вы знаете, что количество элементов не нужно будет изменять. Например, если бы вы использовали названия месяцев в программе, вы, вероятно, использовали бы массив, а не вектор, потому что вы знаете, что он всегда будет содержать 12 элементов: @@ -225,3 +225,10 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace Программа столкнулась с ошибкой во *времени выполнения* на этапе применения недопустимого значения в операции индексирования. Программа завершилась с сообщением об ошибке и не выполнила финальный оператор `println!`. При попытке доступа к элементу с помощью индексирования Rust проверяет, что указанный индекс меньше длины массива. Если индекс больше или равен длине, Rust паникует. Эта проверка должна происходить во время выполнения, особенно в данном случае, потому что компилятор не может знать, какое значение введёт пользователь при последующем выполнении кода. Это пример принципов безопасности памяти Rust в действии. Во многих низкоуровневых языках такая проверка не выполняется, и когда вы указываете неправильный индекс, доступ к памяти может быть некорректным. Rust защищает вас от такого рода ошибок, немедленно закрываясь вместо того, чтобы разрешать доступ к памяти и продолжать работу. В главе 9 подробнее обсуждается обработка ошибок в Rust и то, как вы можете написать читаемый, безопасный код, который не вызывает панику и не разрешает некорректный доступ к памяти. + + +[дополнительного кода]: https://en.wikipedia.org/wiki/Two%27s_complement +["Поток управления"]: ch03-05-control-flow.html#control-flow +[Главе 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 \ No newline at end of file From 363afd595baec8a82e824409420ccb8ba33d59bb Mon Sep 17 00:00:00 2001 From: Sergey Astakhov Date: Mon, 16 Oct 2023 11:48:19 +0000 Subject: [PATCH 7/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index 09ecb72c3..fdc798d29 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -35,7 +35,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); 128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` -Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода]. +Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement). Каждый вариант со знаком может хранить числа от -(2 n - 1 ) до 2 n - 1 - 1 включительно, где *n* — количество битов, которые использует этот вариант. Таким образом, `i8` может хранить числа от -(2 7 ) до 2 7 - 1, что равно значениям от -128 до 127. Варианты без знака могут хранить числа от 0 до 2 n - 1, поэтому `u8` может хранить числа от 0 до 2 8 - 1, что равно значениям от 0 до 255. @@ -48,14 +48,14 @@ let guess: u32 = "42".parse().expect("Not a number!"); Числовой литерал | Пример --- | --- Десятичный | `98_222` -Шестнадцатиричный | `0xff` +Шестнадцатеричный | `0xff` Восьмиричный | `0o77` Двоичный | `0b1111_0000` Байт (только `u8`) | `b'A'` Как же узнать, какой тип целого числа использовать? Если вы не уверены, значения по умолчанию в Rust, как правило, подходят для начала: целочисленные типы по умолчанию `i32`. Основной случай, в котором вы должны использовать `isize` или `usize`, — это индексация какой-либо коллекции. -> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"] в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: +> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"](ch09-01-unrecoverable-errors-with-panic.html) в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: > - Обёртывание во всех режимах с помощью методов `wrapping_*`, таких как `wrapping_add`. > - Возврат значения `None` при переполнении с помощью методов `checked_*`. > - Возврат значения и логический индикатор, указывающий, произошло ли переполнение при использовании методов `overflowing_*`. @@ -98,7 +98,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-08-boolean/src/main.rs}} ``` -Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"]. +Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"](ch03-05-control-flow.html#control-flow). #### Символьный тип данных @@ -162,7 +162,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-13-arrays/src/main.rs}} ``` -Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4]) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8]. +Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4](ch04-01-what-is-ownership.html#the-stack-and-the-heap)) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8](ch08-01-vectors.html). Однако массивы более полезны, когда вы знаете, что количество элементов не нужно будет изменять. Например, если бы вы использовали названия месяцев в программе, вы, вероятно, использовали бы массив, а не вектор, потому что вы знаете, что он всегда будет содержать 12 элементов: @@ -225,10 +225,3 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace Программа столкнулась с ошибкой во *времени выполнения* на этапе применения недопустимого значения в операции индексирования. Программа завершилась с сообщением об ошибке и не выполнила финальный оператор `println!`. При попытке доступа к элементу с помощью индексирования Rust проверяет, что указанный индекс меньше длины массива. Если индекс больше или равен длине, Rust паникует. Эта проверка должна происходить во время выполнения, особенно в данном случае, потому что компилятор не может знать, какое значение введёт пользователь при последующем выполнении кода. Это пример принципов безопасности памяти Rust в действии. Во многих низкоуровневых языках такая проверка не выполняется, и когда вы указываете неправильный индекс, доступ к памяти может быть некорректным. Rust защищает вас от такого рода ошибок, немедленно закрываясь вместо того, чтобы разрешать доступ к памяти и продолжать работу. В главе 9 подробнее обсуждается обработка ошибок в Rust и то, как вы можете написать читаемый, безопасный код, который не вызывает панику и не разрешает некорректный доступ к памяти. - - -[дополнительного кода]: https://en.wikipedia.org/wiki/Two%27s_complement -["Поток управления"]: ch03-05-control-flow.html#control-flow -[Главе 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 \ No newline at end of file From 85eeef35feddee97b97e067873fbb321b585e245 Mon Sep 17 00:00:00 2001 From: Alexandr Tedeev Date: Mon, 16 Oct 2023 11:48:19 +0000 Subject: [PATCH 8/8] Translate ch03-02-data-types.md via GitLocalize --- rustbook-ru/src/ch03-02-data-types.md | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/rustbook-ru/src/ch03-02-data-types.md b/rustbook-ru/src/ch03-02-data-types.md index fdc798d29..509127195 100644 --- a/rustbook-ru/src/ch03-02-data-types.md +++ b/rustbook-ru/src/ch03-02-data-types.md @@ -35,7 +35,7 @@ let guess: u32 = "42".parse().expect("Not a number!"); 128 бит | `i128` | `u128` архитектурно-зависимая | `isize` | `usize` -Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода](https://en.wikipedia.org/wiki/Two%27s_complement). +Каждый вариант может быть как со знаком, так и без знака и имеет явный размер. Такая характеристика типа как *знаковый* и *беззнаковый* определяет возможность числа быть отрицательным. Другими словами, должно ли число иметь знак (знаковое) или оно всегда будет только положительным и, следовательно, может быть представлено без знака (беззнаковое). Это похоже на написание чисел на бумаге: когда знак имеет значение, число отображается со знаком плюс или со знаком минус; однако, когда можно с уверенностью предположить, что число положительное, оно отображается без знака. Числа со знаком хранятся с использованием [дополнительного кода]. Каждый вариант со знаком может хранить числа от -(2 n - 1 ) до 2 n - 1 - 1 включительно, где *n* — количество битов, которые использует этот вариант. Таким образом, `i8` может хранить числа от -(2 7 ) до 2 7 - 1, что равно значениям от -128 до 127. Варианты без знака могут хранить числа от 0 до 2 n - 1, поэтому `u8` может хранить числа от 0 до 2 8 - 1, что равно значениям от 0 до 255. @@ -49,13 +49,13 @@ let guess: u32 = "42".parse().expect("Not a number!"); --- | --- Десятичный | `98_222` Шестнадцатеричный | `0xff` -Восьмиричный | `0o77` +восьмеричный | `0o77` Двоичный | `0b1111_0000` Байт (только `u8`) | `b'A'` Как же узнать, какой тип целого числа использовать? Если вы не уверены, значения по умолчанию в Rust, как правило, подходят для начала: целочисленные типы по умолчанию `i32`. Основной случай, в котором вы должны использовать `isize` или `usize`, — это индексация какой-либо коллекции. -> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"](ch09-01-unrecoverable-errors-with-panic.html) в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: +> Целочисленное переполнение Допустим, имеется переменная типа `u8`, которая может хранить значения от 0 до 255. Если попытаться изменить переменную на значение вне этого диапазона, например, 256, произойдёт *целочисленное переполнение*, что может привести к одному из двух вариантов поведения. Если выполняется компиляция в режиме отладки, Rust включает проверку на целочисленное переполнение, приводящую вашу программу к *панике* во время выполнения, когда возникает такое поведение. Rust использует термин *паника(panicking)*, когда программа завершается с ошибкой. Мы обсудим панику более подробно в разделе ["Неустранимые ошибки с `panic!`"] в главе 9. . При компиляции в режиме release с флагом `--release`, Rust *не* включает проверки на целочисленное переполнение, которое вызывает панику. Вместо этого, в случае переполнения, Rust выполняет *обёртывание второго дополнения*. Проще говоря, значения, превышающие максимальное значение, которое может хранить тип, "оборачиваются" к минимальному из значений, которые может хранить тип. В случае `u8` значение 256 становится 0, значение 257 становится 1, и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не будет соответствовать вашим ожиданиям. Полагаться на поведение обёртывания целочисленного переполнения считается ошибкой. Для явной обработки возможности переполнения существует семейство методов, предоставляемых стандартной библиотекой для примитивных числовых типов: > - Обёртывание во всех режимах с помощью методов `wrapping_*`, таких как `wrapping_add`. > - Возврат значения `None` при переполнении с помощью методов `checked_*`. > - Возврат значения и логический индикатор, указывающий, произошло ли переполнение при использовании методов `overflowing_*`. @@ -98,7 +98,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-08-boolean/src/main.rs}} ``` -Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"](ch03-05-control-flow.html#control-flow). +Основной способ использования логических значений - это использование условий, таких как выражение `if`. Мы рассмотрим, как выражения `if` работают в Rust в разделе ["Поток управления"]. #### Символьный тип данных @@ -162,7 +162,7 @@ Rust поддерживает основные математические оп {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-13-arrays/src/main.rs}} ``` -Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4](ch04-01-what-is-ownership.html#the-stack-and-the-heap)) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8](ch08-01-vectors.html). +Массивы удобно использовать, если данные необходимо разместить в стеке, а не в куче (мы подробнее обсудим стек и кучу в [Главе 4]) или если требуется, чтобы количество элементов всегда было фиксированным. Однако массив не так гибок, как вектор. *Вектор* - это аналогичный тип коллекции, предоставляемый стандартной библиотекой, который *может* увеличиваться или уменьшаться в размере. Если вы не уверены, что лучше использовать - массив или вектор, то, скорее всего, вам следует использовать вектор. {Более подробно векторы рассматриваются в [Главе 8]. Однако массивы более полезны, когда вы знаете, что количество элементов не нужно будет изменять. Например, если бы вы использовали названия месяцев в программе, вы, вероятно, использовали бы массив, а не вектор, потому что вы знаете, что он всегда будет содержать 12 элементов: @@ -225,3 +225,10 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace Программа столкнулась с ошибкой во *времени выполнения* на этапе применения недопустимого значения в операции индексирования. Программа завершилась с сообщением об ошибке и не выполнила финальный оператор `println!`. При попытке доступа к элементу с помощью индексирования Rust проверяет, что указанный индекс меньше длины массива. Если индекс больше или равен длине, Rust паникует. Эта проверка должна происходить во время выполнения, особенно в данном случае, потому что компилятор не может знать, какое значение введёт пользователь при последующем выполнении кода. Это пример принципов безопасности памяти Rust в действии. Во многих низкоуровневых языках такая проверка не выполняется, и когда вы указываете неправильный индекс, доступ к памяти может быть некорректным. Rust защищает вас от такого рода ошибок, немедленно закрываясь вместо того, чтобы разрешать доступ к памяти и продолжать работу. В главе 9 подробнее обсуждается обработка ошибок в Rust и то, как вы можете написать читаемый, безопасный код, который не вызывает панику и не разрешает некорректный доступ к памяти. + + +[дополнительного кода]: https://en.wikipedia.org/wiki/Two%27s_complement +["Поток управления"]: ch03-05-control-flow.html#control-flow +[Главе 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 \ No newline at end of file