From 3f7cfee04f236f5e3ecc9ca05691c34672294d6d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Sun, 4 Feb 2024 11:23:01 -0300 Subject: [PATCH] Update pt-br pages * basic types * imports and modules --- basics/basic-types.md | 143 +++++++++++++++++----------------- basics/imports-and-modules.md | 68 +++++++++++----- 2 files changed, 123 insertions(+), 88 deletions(-) diff --git a/basics/basic-types.md b/basics/basic-types.md index 496a1ec..5c374e9 100644 --- a/basics/basic-types.md +++ b/basics/basic-types.md @@ -1,77 +1,76 @@ -# Basic types +# Tipos básicos -D provides a number of basic types which always have the same -size **regardless** of the platform - the only exception -is the `real` type which provides the highest possible floating point -precision. There is no difference -between the size of an integer regardless whether the application -is compiled for 32-bit or 64-bit systems. +O D fornece vários tipos básicos que sempre têm o mesmo +tamanho **independentemente** da plataforma - a única exceção +é o tipo `real` que fornece a maior precisão possível de ponto flutuante +possível. Não há diferença +entre o tamanho de um número inteiro, independentemente de o aplicativo +seja compilado para sistemas de 32 ou 64 bits. - - - - - - -
bool 8-bit
byte, ubyte, char 8-bit
short, ushort, wchar 16-bit
int, uint, dchar 32-bit
long, ulong 64-bit
+| tipo | tamanho +|-------------------------------|------------ +|`bool`, `byte`, `ubyte`, `char`| 8-bit +|`short`, `ushort`, `wchar` | 16-bit +|`int`, `uint`, `dchar` | 32-bit +|`long`, `ulong` | 64-bit -#### Floating point types: +#### Tipos ponto flutuante: - - - - -
float 32-bit
double 64-bit
real depending on platform, 80-bit on Intel x86 32-bit
+| tipo | tamanho +|---------|-------------------------------------------------- +|`float` | 32-bit +|`double` | 64-bit +|`real` | >= 64-bit (geralmente 64-bit, mas 80-bit em Intel x86 32-bit) -The prefix `u` denotes *unsigned* types. `char` translates to -UTF-8 characters, `wchar` is used in UTF-16 strings and `dchar` -in UTF-32 strings. +O prefixo `u` indica tipos *unsigned*. `char` se traduz em caracteres +caracteres UTF-8, `wchar` é usado em strings UTF-16 e `dchar` +em cadeias de caracteres UTF-32. -A conversion between variables of different types is only -allowed by the compiler if no precision is lost. A conversion -between floating point types (e.g `double` to `float`) -is allowed though. +Uma conversão entre variáveis de tipos diferentes só é +permitida pelo compilador se não houver perda de precisão. No entanto, +uma conversão entre tipos de ponto flutuante +(por exemplo, `double` para `float`) é permitida. -A conversion to another type may be forced by using the -`cast(TYPE) myVar` expression. It needs to be used with great care though, -as the `cast` expression is allowed to break the type system. +Uma conversão para outro tipo pode ser forçada com o uso da expressão +`cast(TYPE) myVar`. No entanto, ela precisa ser usada com muito cuidado, +pois a expressão `cast` pode quebrar o sistema de tipos. -The special keyword `auto` creates a variable and infers its -type from the right hand side of the expression. `auto myVar = 7` -will deduce the type `int` for `myVar`. Note that the type is still -set at compile-time and can't be changed - just like with any other -variable with an explicitly given type. +A palavra-chave especial `auto` cria uma variável e infere +seu tipo a partir do lado direito da expressão. `auto myVar = 7` +deduzirá o tipo `int` para `myVar`. Observe que o tipo ainda é +definido em tempo de compilação e não pode ser alterado, como em qualquer outra +variável com um tipo explicitamente fornecido. -### Type properties +### Propriedades de tipos -All data types have a property `.init` to which they are initialized. -For all integers this is `0` and for floating points it is `nan` (*not a number*). +Todos os tipos de dados têm uma propriedade `.init` para a qual são inicializados. +Para todos os números inteiros, essa propriedade é `0` e, para pontos flutuantes, é `nan` (*não é um número*). -Integral and floating point types have a `.max` property for the highest value -they can represent. Integral types also have a `.min` property for the lowest value -they can represent, whereas floating point types have a `.min_normal` property -which is defined to the smallest representable normalized value that's not 0. +Os tipos de ponto flutuante e integral têm uma propriedade `.max` para o valor mais alto que podem representar. +Os tipos integrais também têm uma propriedade `.min` para o valor mais baixo +que podem representar, enquanto os tipos de ponto flutuante têm uma propriedade `.min_normal` +que é definida como o menor valor normalizado representável que não é 0. -Floating point types also have properties `.nan` (NaN-value), `.infinity` -(infinity value), `.dig` (number of decimal digits of precisions), `.mant_dig` -(number of bits in mantissa) and more. +Os tipos de ponto flutuante também têm as propriedades `.nan` (valor NaN), `.infinity` +(valor infinito), `.dig` (número de dígitos decimais das precisões), `.mant_dig` +(número de bits na mantissa) e outras. -Every type also has a `.stringof` property which yields its name as a string. +Cada tipo também tem uma propriedade `.stringof` que produz seu nome como uma string. -### Indexes in D +### Índices em D -In D, indexes usually have the alias type `size_t`, as it is a type that -is large enough to represent an offset into all addressible memory - this is -`uint` for 32-bit and `ulong` for 64-bit architectures. +Em D, os índices geralmente têm o alias do tipo `size_t`, pois é um tipo que +é grande o suficiente para representar um deslocamento em toda a memória endereçável - isto é +`uint` para arquiteturas de 32 bits e `ulong` para arquiteturas de 64 bits. -### Asserts +### Expressão Assert -`assert` is a compiler built-in which verifies conditions in debug mode and aborts -with an `AssertionError` if it fails. +O `assert` é uma expressão que verifica as condições no modo de depuração e aborta com um `AssertionError` se falhar. +O `assert(0)` é, portanto, usado para marcar código inacessível. -### In-depth +### Maiores Detalhes -#### Basic references +#### Referências Básicas - [Assignment](http://ddili.org/ders/d.en/assignment.html) - [Variables](http://ddili.org/ders/d.en/variables.html) @@ -79,43 +78,47 @@ with an `AssertionError` if it fails. - [Floating Point](http://ddili.org/ders/d.en/floating_point.html) - [Fundamental types in _Programming in D_](http://ddili.org/ders/d.en/types.html) -#### Advanced references +#### Referencias Avançadas - [Overview of all basic data types in D](https://dlang.org/spec/type.html) - [`auto` and `typeof` in _Programming in D_](http://ddili.org/ders/d.en/auto_and_typeof.html) - [Type properties](https://dlang.org/spec/property.html) +- [Assert expression](https://dlang.org/spec/expression.html#AssertExpression) ## {SourceCode} ```d -import std.stdio; +import std.stdio : writeln; void main() { - // Big numbers can be separated - // with an underscore "_" - // to enhance readability. + // Números grandes podem ser separados + // utilizando sublinha "_" + // melhorando a legibilidade. int b = 7_000_000; - short c = cast(short) b; // cast needed - uint d = b; // fine + // necessário cast + // para conversão explícita + short c = cast(short) b; + uint d = b; // conversão implícita int g; assert(g == 0); - auto f = 3.1415f; // f denotes a float + // f denota-se ser do tipo float + auto f = 3.1415f; - // typeid(VAR) returns the type information - // of an expression. + // typeid(VAR) retorna a informação + // sobre o tipo da expressão. writeln("type of f is ", typeid(f)); - double pi = f; // fine - // for floating-point types - // implicit down-casting is allowed + double pi = f; // conversão implícita + // para tipos de ponto flutuante + // permitindo a redução implícita float demoted = pi; - // access to type properties + // acessando as propriedades do tipo assert(int.init == 0); assert(int.sizeof == 4); assert(bool.max == 1); writeln(int.min, " ", int.max); writeln(int.stringof); // int } -``` +``` \ No newline at end of file diff --git a/basics/imports-and-modules.md b/basics/imports-and-modules.md index c2cc185..4e85797 100644 --- a/basics/imports-and-modules.md +++ b/basics/imports-and-modules.md @@ -1,24 +1,56 @@ -# Imports and modules +# Imports e modules -For a simple hello world program in D, `import`s are needed. -The `import` statement makes all public functions -and types from the given **module** available. +{{#img-right}}turtle.svg{{/img-right}} -The standard library, called [Phobos](https://dlang.org/phobos/), -is located under the **package** `std` -and its modules are referenced through `import std.MODULE`. +Uma das principais decisões de design do D foi ser consistente e evitar casos isolados +na linguagem. +Isto é conhecido como [_turtles all the way down_](https://en.wikipedia.org/wiki/Turtles_all_the_way_down). [tradução livre: _Tartarugas até lá embaixo._] +Um bom exemplo dessa consistência são os `import`s. -The `import` statement can also be used to selectively -import certain symbols of a module: +## Imports - import std.stdio: writeln, writefln; +Para um simples programa Olá Mundo em D, são necessários `import`s. +A instrução `import` torna disponíveis todas as funções públicas +e tipos públicos do **módulo** fornecido. -Selective imports can be used to improve readability by making -it obvious where a symbol comes from, and also as a way to -prevent clashing of symbols with the same name from different modules. +### As tartarugas começam a cair -An `import` statement does not need to appear at the top of a source file. -It can also be used locally within functions or any other scope. +Uma instrução `import` não precisa aparecer na parte superior de um arquivo de código-fonte. +Ela também pode ser usada localmente em funções ou em qualquer outro escopo. +Nos próximos capítulos, você verá que isso se aplica a quase todos os conceitos em D. A linguagem não impõe restrições arbitrárias a você. + +### Imports seletivos + +A biblioteca pad~rao, chamado [Phobos](https://dlang.org/phobos/), +está localizado no **pacote** `std` +e seus módulos são referenciados por meio do `import std.MODULE`. + +A instrução `import` também pode ser usada para importar seletivamente +determinados símbolos de um módulo: + + import std.stdio : writeln, writefln; + +As importações seletivas podem ser usadas para melhorar a legibilidade, tornando +óbvia a origem de um símbolo e também como uma forma de +evitar o conflito de símbolos com o mesmo nome de módulos diferentes. + +### As importações correspondem a diretórios e arquivos + +O sistema de módulos do D, em contraste com outros sistemas, é totalmente baseado em arquivos. +Por exemplo, `import my.cat` sempre se refere a um arquivo `cat.d` na pasta `my/`. +A pasta `my` precisa estar no diretório de trabalho atual ou +em uma das importações de diretório especificadas explicitamente (`-I`). +Por fim, para facilitar a divisão de módulos grandes em vários arquivos menores, +em vez de `cat.d`, uma pasta `cat/` também poderia ser usada. +O compilador D tentaria então carregar `my/cat/package.d` em vez de `my/cat.d`. + +A convenção (mas não uma regra rígida) para arquivos `package.d` é importar publicamente +todos os outros módulos na mesma pasta. + +### Maiores detalhes + +- [Modules and Libraries in _Programming in D_](http://ddili.org/ders/d.en/modules.html) +- [Modules specification](https://dlang.org/spec/module.html) ## {SourceCode} @@ -26,7 +58,7 @@ It can also be used locally within functions or any other scope. void main() { import std.stdio; - // or import std.stdio: writeln; - writeln("Hello World!"); + // ou import std.stdio : writeln; + writeln("Olá, Mundo!"); } -``` +``` \ No newline at end of file