[d/pt-br] Translate D to pt-br (#3754)

* Translate D to pt-br * Fix in d-pt.html.markdown Correction in the initial table of the documentation.
2024-12-27 09:15:50 +03:00 · 2023-12-14 11:42:02 -03:00 · 2023-12-14 11:42:02 -03:00 · 548117c36b
commit 548117c36b
parent 1d78cfdbc6
1 changed files with 262 additions and 0 deletions
--- a/pt-br/d-pt.html.markdown
+++ b/pt-br/d-pt.html.markdown
@ -0,0 +1,262 @@
 ---
 language: D
 filename: learnd-pt.d
 contributors:
    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 translators:
    - ["Julio Vanzelli", "https://github.com/JulioVanzelli"]
 lang: pt-br
 ---
 ```d
 // Você sabe o que está por vir...
 module hello;
 import std.stdio;
 // args é opcional
 void main(string[] args) {
    writeln("Hello, World!");
 }
 ```
 Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
 sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
 linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
 abstrações expressivas de alto nível.
 D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
 [Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
 [Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
 Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
 ```d
 import std.stdio;
 void main() {
    // Condicionais e loops funcionam como esperado.
    for(int i = 0; i < 10000; i++) {
        writeln(i);
    }
    // 'auto' pode ser usado para inferir tipos.
    auto n = 1;
    // literais numéricos podem usar '_' como um separador de dígitos para maior clareza.
    while(n < 10_000) {
        n += n;
    }
    do {
        n -= (n / 2);
    } while(n > 0);
    // Por e enquanto são bons, mas em D-land preferimos loops 'foreach'.
    // O '..' cria um intervalo contínuo, incluindo o primeiro valor
    // mas excluindo o último.
    foreach(n; 1..1_000_000) {
        if(n % 2 == 0)
            writeln(n);
    }
    // Há também 'foreach_reverse' quando você deseja fazer um loop para trás.
    foreach_reverse(n; 1..int.max) {
        if(n % 2 == 1) {
            writeln(n);
        } else {
            writeln("No!");
        }
    }
 }
 ```
 Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
 são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
 podemos usar modelos para parametrizar tudo isso em tipos e valores!
 ```d
 // Aqui, 'T' é um parâmetro de tipo. Pense '<T>' em C++/C#/Java.
 struct LinkedList(T) {
    T data = null;
    // Usar '!' para instanciar um tipo parametrizado. Mais uma vez, pense '<T>'.
    LinkedList!(T)* next;
 }
 class BinTree(T) {
    T data = null;
    // Se houver apenas um parâmetro de modelo, podemos omitir os parênteses.
    BinTree!T left;
    BinTree!T right;
 }
 enum Day {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
 }
 // Use o alias para criar abreviações para tipos.
 alias IntList = LinkedList!int;
 alias NumTree = BinTree!double;
 // Também podemos criar modelos de funções!
 T max(T)(T a, T b) {
    if(a < b)
        return b;
    return a;
 }
 // Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' 
 // e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
 void swap(T)(ref T a, ref T b) {
    auto temp = a;
    a = b;
    b = temp;
 }
 // Com os modelos, também podemos parametrizar valores, não apenas tipos.
 class Matrix(uint m, uint n, T = int) {
    T[m] rows;
    T[n] columns;
 }
 auto mat = new Matrix!(3, 3); // O tipo 'T' foi padronizado como 'int'.
 ```
 Falando em aulas, vamos falar sobre propriedades por um segundo. Uma propriedade
 é aproximadamente uma função que pode agir como um valor I, para que possamos
 ter a sintaxe das estruturas POD (`structure.x = 7`) com a semântica de
 métodos getter e setter (`object.setX (7)`)!
 ```d
 // Considere uma classe parametrizada nos tipos 'T' e 'U'.
 class MyClass(T, U) {
    T _data;
    U _other;
 }
 // E os métodos "getter" e "setter", assim:
 class MyClass(T, U) {
    T _data;
    U _other;
    // Os construtores sempre são chamados de 'this'.
    this(T t, U u) {
        // This will call the setter methods below.
        data = t;
        other = u;
    }
    // getters
    @property T data() {
        return _data;
    }
    @property U other() {
        return _other;
    }
    // setters
    @property void data(T t) {
        _data = t;
    }
    @property void other(U u) {
        _other = u;
    }
 }
 // E nós os usamos desta maneira:
 void main() {
    auto mc = new MyClass!(int, string)(7, "seven");
    // Importe o módulo 'stdio' da biblioteca padrão para gravar no 
    // console (as importações podem ser locais para um escopo).
    import std.stdio;
    // Ligue para os getters para buscar os valores.
    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
    // Ligue para os setters para atribuir novos valores.
    mc.data = 8;
    mc.other = "eight";
    // Ligue para os getters novamente para buscar os novos valores.
    writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
 Com propriedades, podemos adicionar qualquer quantidade de lógica para
 nossos métodos getter e setter, e mantenha a sintaxe limpa de
 acessando membros diretamente!
 Outras guloseimas orientadas a objetos à nossa disposição,
 incluem interfaces, classes abstratas,
 e métodos de substituição. D faz herança como Java:
 Estenda uma classe, implemente quantas interfaces você desejar.
 Vimos as instalações OOP de D, mas vamos mudar de marcha. D oferece
 programação funcional com funções de primeira classe, `pura`
 funções e dados imutáveis. Além disso, todos os seus favoritos
 algoritmos funcionais (mapear, filtrar, reduzir e amigos) podem ser
 encontrado no maravilhoso módulo `std.algorithm`!
 ```d
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // cria uma gama exclusiva de final
 void main() {
    // Queremos imprimir a soma de uma lista de quadrados de ints pares 
    // de 1 a 100. Fácil!
    // Basta passar expressões lambda como parâmetros de modelo!
    // Você pode passar qualquer função que desejar, mas as lambdas são convenientes aqui.
    auto num = iota(1, 101).filter!(x => x % 2 == 0)
                           .map!(y => y ^^ 2)
                           .reduce!((a, b) => a + b);
    writeln(num);
 }
 ```
 Observe como conseguimos construir um bom pipeline haskelliano para calcular num?
 Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
 Com o UFCS, podemos optar por escrever uma chamada de função como método
 ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
 [aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 Em resumo, você pode chamar funções cujo primeiro parâmetro
 é de algum tipo A em qualquer expressão do tipo A como método.
 Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
 ```d
 // Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos 
 // os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos 
 // fazer isso simultaneamente, aproveitando o número de núcleos que temos 
 // disponível.
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;
 void main() {
    // Crie sua grande variedade
    auto arr = new double[1_000_000];
    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos 
    // mudar cada elemento) e apenas chame paralelo na matriz!
    foreach(i, ref elem; parallel(arr)) {
        elem = sqrt(i + 1.0);
    }
 }
 ```