Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update some pt-br pages #9

Merged
merged 1 commit into from
Feb 5, 2024
Merged

Update some pt-br pages #9

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
143 changes: 73 additions & 70 deletions basics/basic-types.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,121 +1,124 @@
# 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.

<table class="table table-hover">
<tr><td width="250px"><code class="prettyprint">bool</code></td> <td>8-bit</td></tr>
<tr><td><code class="prettyprint">byte, ubyte, char</code></td> <td>8-bit</td></tr>
<tr><td><code class="prettyprint">short, ushort, wchar</code></td> <td>16-bit</td></tr>
<tr><td><code class="prettyprint">int, uint, dchar</code></td> <td>32-bit</td></tr>
<tr><td><code class="prettyprint">long, ulong</code></td> <td>64-bit</td></tr>
</table>
| 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:

<table class="table table-hover">
<tr><td width="250px"><code class="prettyprint">float</code></td> <td>32-bit</td></tr>
<tr><td><code class="prettyprint">double</code></td> <td>64-bit</td></tr>
<tr><td><code class="prettyprint">real</code></td> <td>depending on platform, 80-bit on Intel x86 32-bit</td></tr>
</table>
| 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)
- [Arithmetics](http://ddili.org/ders/d.en/arithmetic.html)
- [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
}
```
```
68 changes: 50 additions & 18 deletions basics/imports-and-modules.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,32 +1,64 @@
# 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}

```d
void main()
{
import std.stdio;
// or import std.stdio: writeln;
writeln("Hello World!");
// ou import std.stdio : writeln;
writeln("Olá, Mundo!");
}
```
```
Loading