diff options
Diffstat (limited to 'pt-br')
| -rw-r--r-- | pt-br/csharp-pt.html.markdown | 36 | ||||
| -rw-r--r-- | pt-br/dynamic-programming-pt.html.markdown | 6 | ||||
| -rw-r--r-- | pt-br/haxe-pt.html.markdown | 795 | ||||
| -rw-r--r-- | pt-br/paren-pt.html.markdown | 8 | ||||
| -rw-r--r-- | pt-br/python3-pt.html.markdown | 6 | ||||
| -rw-r--r-- | pt-br/ruby-pt.html.markdown | 2 | ||||
| -rw-r--r-- | pt-br/typescript-pt.html.markdown | 7 | ||||
| -rw-r--r-- | pt-br/whip-pt.html.markdown | 10 | ||||
| -rw-r--r-- | pt-br/xml-pt.html.markdown | 3 | ||||
| -rw-r--r-- | pt-br/yaml-pt.html.markdown | 4 |
10 files changed, 831 insertions, 46 deletions
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..1f4e3bd5 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -294,9 +294,9 @@ on a new line! ""Wow!"", the masses cried"; case 3: monthString = "March"; break; - // You can assign more than one case to an action - // But you can't add an action without a break before another case - // (if you want to do this, you would have to explicitly add a goto case x + // Você pode declarar mais de um "case" para uma ação + // Mas você não pode adicionar uma ação sem um "break" antes de outro "case" + // (se você quiser fazer isso, você tem que explicitamente adicionar um "goto case x") case 6: case 7: case 8: @@ -336,28 +336,28 @@ on a new line! ""Wow!"", the masses cried"; } /////////////////////////////////////// - // CLASSES - see definitions at end of file + // CLASSES - Veja definições no fim do arquivo /////////////////////////////////////// public static void Classes() { - // See Declaration of objects at end of file + // Veja Declaração de objetos no fim do arquivo - // Use new to instantiate a class + // Use new para instanciar uma classe Bicycle trek = new Bicycle(); - // Call object methods - trek.SpeedUp(3); // You should always use setter and getter methods + // Chame métodos do objeto + trek.SpeedUp(3); // Você deve sempre usar métodos setter e getter trek.Cadence = 100; - // ToString is a convention to display the value of this Object. + // ToString é uma convenção para exibir o valor desse Objeto. Console.WriteLine("trek info: " + trek.Info()); - // Instantiate a new Penny Farthing + // Instancie um novo Penny Farthing PennyFarthing funbike = new PennyFarthing(1, 10); Console.WriteLine("funbike info: " + funbike.Info()); Console.Read(); - } // End main method + } // Fim do método principal // CONSOLE ENTRY A console application must have a main method as an entry point public static void Main(string[] args) @@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried"; foreach (var key in responses.Keys) Console.WriteLine("{0}:{1}", key, responses[key]); - // DYNAMIC OBJECTS (great for working with other languages) + // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas) dynamic student = new ExpandoObject(); student.FirstName = "First Name"; // No need to define class first! @@ -730,10 +730,10 @@ on a new line! ""Wow!"", the masses cried"; set { _hasTassles = value; } } - // You can also define an automatic property in one line - // this syntax will create a backing field automatically. - // You can set an access modifier on either the getter or the setter (or both) - // to restrict its access: + // Você também pode definir uma propriedade automática em uma linha + // Esta sintaxe criará um campo de apoio automaticamente. + // Você pode definir um modificador de acesso no getter ou no setter (ou ambos) + // para restringir seu acesso: public bool IsBroken { get; private set; } // Properties can be auto-implemented @@ -854,8 +854,8 @@ on a new line! ""Wow!"", the masses cried"; } /// <summary> - /// Used to connect to DB for LinqToSql example. - /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional) + /// Exemplo de como conectar-se ao DB via LinqToSql. + /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional) /// http://msdn.microsoft.com/en-us/data/jj193542.aspx /// </summary> public class BikeRepository : DbContext diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 518660a3..93171955 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -64,9 +64,9 @@ grafo acíclico dirigido. ## Alguns Problemas Famosos de Programação Dinâmica -- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]() -- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]() -- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]() +- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code) +- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem) +- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence) ## Recursos Online (EN) diff --git a/pt-br/haxe-pt.html.markdown b/pt-br/haxe-pt.html.markdown new file mode 100644 index 00000000..13264dec --- /dev/null +++ b/pt-br/haxe-pt.html.markdown @@ -0,0 +1,795 @@ +--- +language: haxe +filename: LearnHaxe3-br.hx +contributors: + - ["Justin Donaldson", "https://github.com/jdonaldson/"] + - ["Dan Korostelev", "https://github.com/nadako/"] +translators: + - ["David Lima", "https://github.com/davelima/"] +lang: pt-br +--- + +Haxe é uma linguagem baseada na web que provê suporte a C++, C#, SWF/ActionScript, +Java e Neko byte code (também desenvolvida pelo autor de Haxe). Observe que +este guia é para a versão 3 de Haxe. Alguns pontos do guia são aplicáveis +para versões anteriores, mas é recomendado que você busque outras referências +para essas versões. + + +```csharp +/* + Bem vindo ao Aprenda Haxe 3 em 15 minutos. http://www.haxe.org + Este é um tutorial executável. Você pode compilar e rodar este tutorial + usando o compilador haxe, estando no mesmo diretório de LearnHaxe.hx: + $> haxe -main LearnHaxe3 -x out + + Olhe para os sinais de /* e */ em volta desses parágrafos. Nós estamos + dentro de um "Comentário multilinha". Nós podemos colocar observações aqui + e elas serão ignoradas pelo compilador. + + Comentários multilinha também são utilizados para gerar documentação haxedoc, + seguindo o estilo javadoc. Eles serão usados pelo haxedoc se precerem imediatamente + uma classe, uma função de uma classe ou uma variável de uma classe. + + */ + +// Duas barras, como as dessa linha, farão um comentário de linha única. + + +/* + Este será o primeiro código haxe de verdade, e está declarando um pacote vazio. + Não é necessário usar um pacote, mas ele será útil se você quiser criar + um namespace para o seu código (exemplo: org.seuapp.SuaClasse). + + Omitir a declaração de pacote é a mesma coisa que declarar um pacote vazio. + */ +package; // pacote vazio, sem namespace. + +/* + Pacotes são diretórios que contém módulos. Cada módulo é um arquivo .hx que + contém tipos definidos em um pacote. Nomes de pacotes (ex. org.seuapp) + devem estar em letras minúsculas, enquanto nomes de módulos devem começar + com uma letra maiúscula. Um módulo contem um ou mais tipos, cujo os nomes + também devem começar com uma letra maiúscula. + + Exemplo: a classe "org.seuapp.Foo" deve ter a estrutura de diretório org/module/Foo.hx, + sendo acessível do diretório do compilador ou caminho da classe. + + Se você importar código de outros arquivos, isso deve ser declarado antes + do restante do código. Haxe disponibiliza várias classes padrões para você + começar: + */ +import haxe.ds.ArraySort; + +// você pode importar várias classes/módulos de uma vez usando "*" +import haxe.ds.*; + +// você pode importar campos estáticos +import Lambda.array; + +// você também pode usar "*" para importar todos os campos estáticos +import Math.*; + +/* + Você também pode importar classes de uma forma diferente, habilitando-as para + extender a funcionalidade de outras classes, como um "mixin". Falaremos sobre + "using" em breve. + */ +using StringTools; + +/* + Typedefs são como variáveis... para tipos. Eles devem ser declarados antes + de qualquer código. Veremos isso em breve. + */ +typedef FooString = String; + +// Typedefs também podem referenciar tipos "estruturais". Também veremos isso em breve. +typedef FooObject = { foo: String }; + +/* + Esta é a definição da classe. É a classe principal do arquivo, visto que + possui o mesmo nome (LearnHaxe3) + */ +class LearnHaxe3{ + /* + Se você quiser que um determinado código rode automaticamente, você + precisa colocá-lo em uma função estática "main", e especificar a classe + nos argumentos do compilador. + Nesse caso, nós especificamos a classe "LearnHaxe3" no nos argumentos + do compilador acima. + */ + static function main(){ + + /* + Trace é o método padrão para imprimir expressões haxe na tela. + Temos diferentes métodos para conseguir isso em diferentes destinos. + Por exemplo: Java, C++, C#, etc. irão imprimir para stdout. + Javascript irá imprimir no console.log, e Flash irá imprimir para um + TextField anexado. Todos os "traces" imprimem também uma linha em branco + por padrão. Por fim, é possível prevenir um trace de ser exibido usando + o argumento "--no-traces" no compilador. + */ + trace("Olá mundo, com trace()!"); + + /* + Trace pode tratar qualquer tipo de valor ou objeto. O método tentará + imprimir a representação de uma expressão da melhor forma. Você também + pode concatenar strings usando o operador "+": + */ + trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true); + + /* + Em Haxe, é obrigatório separar expressões no mesmo bloco com ';'. Mas + é possível colocar duas expressões na mesma linha, dessa forma: + */ + trace('duas expressões..'); trace('uma linha'); + + + ////////////////////////////////////////////////////////////////// + // Tipos & Variáveis + ////////////////////////////////////////////////////////////////// + trace("***Tipos & Variáveis***"); + + /* + Vcoê pode atrelar valores e referências à estruturas usando a + palavra-chave "var": + */ + var um_inteiro:Int = 1; + trace(um_inteiro + " é o valor de um_inteiro"); + + + /* + Haxe é tipada estaticamente, então "um_inteiro" temos que declarar + um valor do tipo "Int", e o restante da expressão atrela o valor "1" + a esta variável. Em muitos casos, não é necessário declarar o tipo. + Aqui, o compilador haxe assume que o tipo de "outro_inteiro" deve + ser "Int" + */ + var outro_inteiro = 2; + trace(outro_inteiro + " é o valor de outro_inteiro"); + + // O método $type() imprime o tipo que o compilador assume: + $type(outro_inteiro); + + // Você também pode representar inteiros em hexadecimal: + var hex_inteiro = 0xffffff; + + /* + Haxe usa precisão de pltaforma para os tamanhos de Int e Float. + Ele também usa o comportamento de plataforma para sobrecarga. + (É possível ter outros tipos numéricos e comportamentos usando + bibliotecas especiais) + */ + + /* + Em adição a valores simples como Integers, Floats e Booleans, + Haxe disponibiliza implementações padrões de bibliotecas para + dados comuns de estrutura como strings, arrays, lists e maps: + */ + + var uma_string = "alguma" + 'string'; // strings podem estar entre aspas simples ou duplas + trace(uma_string + " é o valor de uma_string"); + + /* + Strings podem ser "interpoladas" se inserirmos variáveis em + posições específicas. A string deve estar entre aspas simples, e as + variáveis devem ser precedidas por "$". Expressões podem estar entre + ${...}. + */ + var x = 1; + var uma_string_interpolada = 'o valor de x é $x'; + var outra_string_interpolada = 'o valor de x + 1 é ${x + 1}'; + + /* + Strings são imutáveis, métodos retornarão uma cópia de partes + ou de toda a string. (Veja também a classe StringBuf) + */ + var uma_sub_string = a_string.substr(0,4); + trace(uma_sub_string + " é o valor de a_sub_string"); + + /* + Regex também são suportadas, mas não temos espaço suficiente para + entrar em muitos detalhes. + */ + var re = ~/foobar/; + trace(re.match('foo') + " é o valor de (~/foobar/.match('foo')))"); + + /* + Arrays são indexadas a partir de zero, dinâmicas e mutáveis. Valores + faltando são definidos como null. + */ + var a = new Array<String>(); // um array que contém Strings + a[0] = 'foo'; + trace(a.length + " é o valor de a.length"); + a[9] = 'bar'; + trace(a.length + " é o valor de a.length (depois da modificação)"); + trace(a[3] + " é o valor de a[3]"); // null + + /* + Arrays são *genéricas*, então você pode indicar quais valores elas + contém usando um parâmetro de tipo: + */ + var a2 = new Array<Int>(); // um Array de Ints + var a3 = new Array<Array<String>>(); // um Array de Arrays (de Strings). + + /* + Mapas são estruturas simples de chave/valor. A chave e o valor podem + ser de qualquer tipo. + */ + var m = new Map<String, Int>(); // As chaves são strings, os valores são Ints. + m.set('foo', 4); + // Você também pode usar a notação de array; + m['bar'] = 5; + trace(m.exists('bar') + " é o valor de m.exists('bar')"); + trace(m.get('bar') + " é o valor de m.get('bar')"); + trace(m['bar'] + " é o valor de m['bar']"); + + var m2 = ['foo' => 4, 'baz' => 6]; // Syntaxe alternativa de map + trace(m2 + " é o valor de m2"); + + /* + Lembre-se, você pode usar descoberta de tipo. O compilador + Haxe irá decidir o tipo da variável assim que você passar um + argumento que define um parâmetro de tipo. + */ + var m3 = new Map(); + m3.set(6, 'baz'); // m3 agora é Map<Int,String> + trace(m3 + " é o valor de m3"); + + /* + Haxe possui mais algumas estruturas de dados padrões no módulo haxe.ds, + tais como List, Stack e BalancedTree + */ + + + ////////////////////////////////////////////////////////////////// + // Operadores + ////////////////////////////////////////////////////////////////// + trace("***OPERADORES***"); + + // aritmética básica + trace((4 + 3) + " é o valor de (4 + 3)"); + trace((5 - 1) + " é o valor de (5 - 1)"); + trace((2 * 4) + " é o valor de (2 * 4)"); + trace((8 / 3) + " é o valor de (8 / 3) (divisão sempre produz Floats)"); + trace((12 % 4) + " é o valor de (12 % 4)"); + + + // comparação básica + trace((3 == 2) + " é o valor de 3 == 2"); + trace((3 != 2) + " é o valor de 3 != 2"); + trace((3 > 2) + " é o valor de 3 > 2"); + trace((3 < 2) + " é o valor de 3 < 2"); + trace((3 >= 2) + " é o valor de 3 >= 2"); + trace((3 <= 2) + " é o valor de 3 <= 2"); + + // operadores bit-a-bit padrões + /* + ~ Complemento bit-a-bit unário + << Deslocamento a esquerda + >> Deslocamento a direita + >>> Deslocamento a direita com preenchimento de 0 + & Bit-a-bit AND + ^ Bit-a-bit OR exclusivo + | Bit-a-bit OR inclusivo + */ + + // incrementos + var i = 0; + trace("Incrementos e decrementos"); + trace(i++); //i = 1. Pós-incremento + trace(++i); //i = 2. Pré-incremento + trace(i--); //i = 1. Pós-decremento + trace(--i); //i = 0. Pré-decremento + + ////////////////////////////////////////////////////////////////// + // Estruturas de controle + ////////////////////////////////////////////////////////////////// + trace("***ESTRUTURAS DE CONTROLE***"); + + // operadores if + var j = 10; + if (j == 10){ + trace("isto é impresso"); + } else if (j > 10){ + trace("não é maior que 10, então não é impresso"); + } else { + trace("também não é impresso."); + } + + // temos também um if "ternário": + (j == 10) ? trace("igual a 10") : trace("diferente de 10"); + + /* + Por fim, temos uma outra forma de estrutura de controle que opera + e na hora da compilação: compilação condicional. + */ +#if neko + trace('olá de neko'); +#elseif js + trace('olá de js'); +#else + trace('olá de outra plataforma!'); +#end + /* + O código compilado irá mudar de acordo com o alvo de plataforma. + Se estivermos compilando para neko (-x ou -neko), só teremos a + saudação de neko. + */ + + + trace("Loops e Interações"); + + // loop while + var k = 0; + while(k < 100){ + // trace(counter); // irá iprimir números de 0 a 99 + k++; + } + + // loop do-while + var l = 0; + do{ + trace("do sempre rodará pelo menos uma vez"); + } while (l > 0); + + // loop for + /* + Não há loop for no estilo C para Haxe, pois é propenso + a erros e não é necessário. Ao invés disso, Haxe possui + uma versão muito mais simples e segura que usa Iterators + (veremos isso logo mais). + */ + var m = [1,2,3]; + for (val in m){ + trace(val + " é o valor de val no array m"); + } + + // Perceba que você pode iterar em um índice usando uma lista limitada + // (veremos isso em breve também) + var n = ['foo', 'bar', 'baz']; + for (val in 0...n.length){ + trace(val + " é o valor de val (um índice de n)"); + } + + + trace("Compreensões de array"); + + // Compreensões de array servem para que você posse iterar um array + // enquanto cria filtros e modificações + var n_filtrado = [for (val in n) if (val != "foo") val]; + trace(n_filtrado + " é o valor de n_filtrado"); + + var n_modificado = [for (val in n) val += '!']; + trace(n_modificado + " é o valor de n_modificado"); + + var n_filtrado_e_modificado = [for (val in n) if (val != "foo") val += "!"]; + trace(n_filtrado_e_modificado + " é o valor de n_filtrado_e_modificado"); + + ////////////////////////////////////////////////////////////////// + // Blocos Switch (Tipos de valor) + ////////////////////////////////////////////////////////////////// + trace("***BLOCOS SWITCH (Tipos de valor)***"); + + /* + Blocos Switch no Haxe são muito poderosos. Além de funcionar com + valores básicos como strings e ints, também funcionam com tipos + algébricos em enums (falaremos sobre enums depois). + Veja alguns exemplos de valor básico por enquanto: + */ + var meu_cachorro = "fido"; + var coisa_favorita = ""; + switch(meu_cachorro){ + case "fido" : favorite_thing = "osso"; + case "rex" : favorite_thing = "sapato"; + case "spot" : favorite_thing = "bola de tênis"; + default : favorite_thing = "algum brinquedo desconhecido"; + // case _ : favorite_thing = "algum brinquedo desconhecido"; // mesma coisa que default + } + // O case "_" acima é um valor "coringa" que + // que funcionará para qualquer coisa. + + trace("O nome do meu cachorro é " + meu_cachorro + + ", e sua coisa favorita é: " + + coisa_favorita); + + ////////////////////////////////////////////////////////////////// + // Declarações de expressão + ////////////////////////////////////////////////////////////////// + trace("***DECLARAÇÕES DE EXPRESSÃO***"); + + /* + As declarações de controle em Haxe são muito poderosas pois + toda declaração também é uma expressão, considere o seguinte: + */ + + // declarações if + var k = if (true) 10 else 20; + + trace("k igual a ", k); // retorna 10 + + var outra_coisa_favorita = switch(meu_cachorro) { + case "fido" : "ursinho"; + case "rex" : "graveto"; + case "spot" : "bola de futebol"; + default : "algum brinquedo desconhecido"; + } + + trace("O nome do meu cachorro é " + meu cachorro + + ", e sua outra coisa favorita é: " + + outra_coisa_favorita); + + ////////////////////////////////////////////////////////////////// + // Convertendo tipos de valores + ////////////////////////////////////////////////////////////////// + trace("***CONVERTENDO TIPOS DE VALORES***"); + + // Você pode converter strings em ints de forma bem fácil. + + // string para int + Std.parseInt("0"); // retorna 0 + Std.parseFloat("0.4"); // retorna 0.4; + + // int para string + Std.string(0); // retorna "0"; + // concatenar com strings irá converter automaticamente em string. + 0 + ""; // retorna "0"; + true + ""; // retorna "true"; + // Veja a documentação de parseamento em Std para mais detalhes. + + + ////////////////////////////////////////////////////////////////// + // Lidando com Tipos + ////////////////////////////////////////////////////////////////// + + /* + Como mencionamos anteriormente, Haxe é uma linguagem tipada + estaticamente. Tipagem estática é uma coisa maravilhosa. Isto + permite autocompletar mais preciso, e pode ser usado para checar + completamente o funcionamento de um programa. Além disso, o compilador + Haxe é super rápido. + + *ENTRETANTO*, há momentos em que você espera que o compilador apenas + deixe algo passar, e não lance um "type error" em um determinado caso. + + Para fazer isso, Haxe tem duas palavras-chave separadas. A primeira + é o tipo "Dynamic": + */ + var din: Dynamic = "qualquer tipo de variável, assim como essa string"; + + /* + Tudo o que você sabe sobre uma variável Dynamic é que o compilador + não irá mais se preocupar com o tipo dela. É como uma variável + "coringa": você pode usar isso ao invés de qualquer tipo de variável, + e você pode atrelar qualquer valor a essa variável. + + A outra (e mais extrema) opção é a palavra-chave "untyped": + */ + + untyped { + var x:Int = 'foo'; // não faz sentido! + var y:String = 4; // loucura! + } + + /* + A palavra-chave "untyped" opera em *blocos* inteiros de código, + ignorando qualquer verificação de tipo que seria obrigatória em + outros casos. Essa palavra-chave deve ser usada com muita cautela, + como em situações limitadas de compilação condicional onde a + verificação de tipo pode ser um obstáculo. + + No geral, ignorar verificações de tipo *não* é recomendado. Use + os modelos de enum, herança ou estrutural para garantir o correto + funcionamento do seu programa. Só quando você tiver certeza de que + nenhum desses modelos funcionam no seu caso, você deve usar "Dynamic" + ou "untyped". + */ + + ////////////////////////////////////////////////////////////////// + // Programação básica orientada a objetos + ////////////////////////////////////////////////////////////////// + trace("***PROGRAMAÇÃO BÁSICA ORIENTADA A OBJETOS***"); + + + /* + Cria uma instância da FooClass. As definicções dessas classes + estão no final do arquivo. + */ + var instancia_foo = new FooClass(3); + + // lê a variável pública normalmente + trace(instancia_foo.variavel_publica + " é o valor de instancia_foo.variavel_publica"); + + // nós podemos ler essa variável + trace(instancia_foo.publica_leitura + " é o valor de instancia_foo.publica_leitura"); + // mas não podemos escrever nela + // instancia_foo.publica_leitura = 4; // isso irá causar um erro se descomentado: + // trace(instancia_foo.public_escrita); // e isso também. + + // chama o método toString: + trace(instancia_foo + " é o valor de instancia_foo"); + // mesma coisa: + trace(instancia_foo.toString() + " é o valor de instancia_foo.toString()"); + + + /* + A instancia_foo é do tipo "FooClass", enquanto acceptBarInstance + é do tipo BarClass. Entretanto, como FooClass extende BarClass, + ela é aceita. + */ + BarClass.acceptBarInstance(instancia_foo); + + /* + As classes abaixo têm mais alguns exemplos avançados, o método + "example()" executará esses exemplos aqui: + */ + SimpleEnumTest.example(); + ComplexEnumTest.example(); + TypedefsAndStructuralTypes.example(); + UsingExample.example(); + + } + +} + +/* + Essa é a "classe filha" do classe principal LearnHaxe3 + */ +class FooClass extends BarClass implements BarInterface{ + public var variavel_publica:Int; // variáveis públicas são acessíveis de qualquer lugar + public var publica_leitura (default, null): Int; // somente leitura pública habilitada + public var publica_escrita (null, default): Int; // somente escrita pública habilitada + public var property (get, set): Int; // use este estilo para habilitar getters e setters + + // variáveis privadas não estão disponíveis fora da classe. + // veja @:allow para formas de fazer isso. + var _private:Int; // variáveis são privadas se não forem marcadas como públicas + + // um construtor público + public function new(arg:Int){ + // chama o construtor do objeto pai, já que nós extendemos a BarClass: + super(); + + this.variavel_publica = 0; + this._private = arg; + + } + + // getter para _private + function get_property() : Int { + return _private; + } + + // setter para _private + function set_property(val:Int) : Int { + _private = val; + return val; + } + + // função especial que é chamada sempre que uma instância é convertida em string. + public function toString(){ + return _private + " com o método toString()!"; + } + + // essa classe precisa ter essa função definida, pois ela implementa + // a interface BarInterface + public function baseFunction(x: Int) : String{ + // converte o int em string automaticamente + return x + " foi passado pela baseFunction!"; + } +} + +/* + Uma classe simples para extendermos +*/ +class BarClass { + var base_variable:Int; + public function new(){ + base_variable = 4; + } + public static function acceptBarInstance(b:BarClass){ + } +} + +/* + Uma interface simples para implementarmos +*/ +interface BarInterface{ + public function baseFunction(x:Int):String; +} + +////////////////////////////////////////////////////////////////// +// Declarações Enum e Switch +////////////////////////////////////////////////////////////////// + +/* + Enums no Haxe são muito poderosos. Resumidamente, enums são + um tipo com um número limitado de estados: + */ + +enum SimpleEnum { + Foo; + Bar; + Baz; +} + +// Uma classe que faz uso desse enum: + +class SimpleEnumTest{ + public static function example(){ + var e_explicit:SimpleEnum = SimpleEnum.Foo; // você pode especificar o nome "completo" + var e = Foo; // bas descoberta de tipo também funciona. + switch(e){ + case Foo: trace("e era Foo"); + case Bar: trace("e era Bar"); + case Baz: trace("e era Baz"); // comente esta linha e teremos um erro. + } + + /* + Isso não parece tão diferente de uma alteração simples de valor em strings. + Entretanto, se nós não incluirmos *todos* os estados, o compilador + reclamará. Você pode testar isso comentando a linha mencionada acima. + + Você também pode especificar um valor padrão (default) para enums: + */ + switch(e){ + case Foo: trace("e é Foo outra vez"); + default : trace("default funciona aqui também"); + } + } +} + +/* + Enums vão muito mais além que estados simples, nós também + podemos enumerar *construtores*, mas nós precisaremos de um + exemplo mais complexo de enum: + */ +enum ComplexEnum{ + IntEnum(i:Int); + MultiEnum(i:Int, j:String, k:Float); + SimpleEnumEnum(s:SimpleEnum); + ComplexEnumEnum(c:ComplexEnum); +} +// Observação: O enum acima pode incluir *outros* enums também, incluindo ele mesmo! +// Observação: Isto é o que chamamos de *Tipos de dado algébricos* em algumas outras linguagens. + +class ComplexEnumTest{ + public static function example(){ + var e1:ComplexEnum = IntEnum(4); // especificando o parâmetro enum + /* + Agora nós podemos usar switch no enum, assim como extrair qualquer + parâmetros que ele possa ter. + */ + switch(e1){ + case IntEnum(x) : trace('$x foi o parâmetro passado para e1'); + default: trace("Isso não deve ser impresso"); + } + + // outro parâmetro aqui que também é um enum... um enum enum? + var e2 = SimpleEnumEnum(Foo); + switch(e2){ + case SimpleEnumEnum(s): trace('$s foi o parâmetro passado para e2'); + default: trace("Isso não deve ser impresso"); + } + + // enum dentro de enum dentro de enum + var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3))); + switch(e3){ + // Você pode buscar por certos enums aninhados especificando-os + // explicitamente: + case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : { + trace('$i, $j, e $k foram passados dentro desse monstro aninhado.'); + } + default: trace("Isso não deve ser impresso"); + } + /* + Veja outros "tipos de dado algébricos" (GADT, do inglês) para mais + detalhes sobre o porque eles são tão úteis. + */ + } +} + +class TypedefsAndStructuralTypes { + public static function example(){ + /* + Aqui nós usaremos tipos typedef, ao invés de tipos base. + Lá no começo, nós definimos que o tipo "FooString" é um tipo "String". + */ + var t1:FooString = "alguma string"; + + /* + Aqui nós usamos typedefs para "tipos estruturais" também. Esses tipos + são definidos pela sua estrutura de campos, não por herança de classe. + Aqui temos um objeto anônimo com um campo String chamado "foo": + */ + + var anon_obj = { foo: 'hi' }; + + /* + A variável anon_obj não tem um tipo declarado, e é um objeto anônimo + de acordo com o compilador. Entretanto, lembra que lá no início nós + declaramos a typedef FooObj? Visto que o anon_obj tem a mesma estrutura, + nós podemos usar ele em qualquer lugar que um "FooObject" é esperado. + */ + + var f = function(fo:FooObject){ + trace('$fo foi passado para esta função'); + } + f(anon_obj); // chama a assinatura de FooObject com anon_obj. + + /* + Note que typedefs podem ter campos opcionais também, marcados com "?" + + typedef OptionalFooObj = { + ?optionalString: String, + requiredInt: Int + } + */ + + /* + Typedefs também funcionam com compilação condicional. Por exemplo, + nós poderíamos ter incluído isso no topo deste arquivo: + +#if( js ) + typedef Surface = js.html.CanvasRenderingContext2D; +#elseif( nme ) + typedef Surface = nme.display.Graphics; +#elseif( !flash9 ) + typedef Surface = flash8.MovieClip; +#elseif( java ) + typedef Surface = java.awt.geom.GeneralPath; +#end + + E teríamos apenas um tipo "Surface" para funcionar em todas + essas plataformas. + */ + } +} + +class UsingExample { + public static function example() { + + /* + A palavra-chave "using" é um tipo especial de import de classe que + altera o comportamento de qualquer método estático na classe. + + Neste arquivo, nós aplicamos "using" em "StringTools", que contém + alguns métodos estáticos para tratar tipos String. + */ + trace(StringTools.endsWith("foobar", "bar") + " deve ser verdadeiro!"); + + /* + Com um import "using", o primeiro argumento é extendido com o método. + O que isso significa? Bem, como "endsWith" tem um primeiro argumento + de tipo "String", isso significa que todos os tipos "String" agora + possuem o método "endsWith": + */ + trace("foobar".endsWith("bar") + " deve ser verdadeiro!"); + + /* + Essa técnica habilita uma grande quantidade de expressões para certos + tipos, e limita o escopo de modificações para um único arquivo. + + Note que a instância String *não* é modificada em tempo de execução. + O novo método adicionado não é uma parte da instância anexada, e o + compilador ainda irá gerar o código equivalente ao método estático. + */ + } + +} + +``` +Isso foi apenas o começo do que Haxe pode fazer. Para uma documentação de todos +os recursos de Haxe, veja o [manual](https://haxe.org/manual) e a +[documentação de API](https://api.haxe.org/). Para um diretório de bibliotecas de terceiros +disponíveis, veja a [Haxelib](https://lib.haxe.org/) + +Para tópicos mais avançados, dê uma olhada em: + +* [Tipos abstratos](https://haxe.org/manual/types-abstract.html) +* [Macros](https://haxe.org/manual/macro.html) +* [Recursos do compilador](https://haxe.org/manual/cr-features.html) + +Por fim, participe do [forum Haxe](https://community.haxe.org/), +ou no IRC [#haxe onfreenode](http://webchat.freenode.net/), ou no +[Chat Gitter](https://gitter.im/HaxeFoundation/haxe). diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown index 464a69d2..92414ba3 100644 --- a/pt-br/paren-pt.html.markdown +++ b/pt-br/paren-pt.html.markdown @@ -182,8 +182,8 @@ a ; => (3 2) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Macros lhe permitem estender a sintaxe da linguagem. -;; Os macros no Paren são fáceis. -;; Na verdade, (defn) é um macro. +;; As macros no Paren são fáceis. +;; Na verdade, (defn) é uma macro. (defmacro setfn (nome ...) (set nome (fn ...))) (defmacro defn (nome ...) (def nome (fn ...))) @@ -191,6 +191,6 @@ a ; => (3 2) (defmacro infix (a op ...) (op a ...)) (infix 1 + 2 (infix 3 * 4)) ; => 15 -;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes! -;; Eles são transformações de códigos. +;; Macros não são higiênicas, você pode sobrescrever as variáveis já existentes! +;; Elas são transformações de códigos. ``` diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown index 9b6bd1b6..ea0617f4 100644 --- a/pt-br/python3-pt.html.markdown +++ b/pt-br/python3-pt.html.markdown @@ -105,9 +105,9 @@ False or True # => True 1 < 2 < 3 # => True 2 < 3 < 2 # => False -# (operador 'is' e operador '==') is verifica se duas referenciam um -# mesmo objeto, mas == verifica se as variáveis apontam para o -# mesmo valor. +# (operador 'is' e operador '==') is verifica se duas variáveis +# referenciam um mesmo objeto, mas == verifica se as variáveis +# apontam para o mesmo valor. a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4] b = a # b referencia o que está referenciado por a b is a # => True, a e b referenciam o mesmo objeto diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown index 1078f6c5..7ae28ac2 100644 --- a/pt-br/ruby-pt.html.markdown +++ b/pt-br/ruby-pt.html.markdown @@ -71,7 +71,7 @@ false.class #=> FalseClass 2 <= 2 #=> true 2 >= 2 #=> true -# Strings são objects +# Strings são objetos 'Eu sou uma string'.class #=> String "Eu também sou uma string".class #=> String diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown index f072b257..077aa2cc 100644 --- a/pt-br/typescript-pt.html.markdown +++ b/pt-br/typescript-pt.html.markdown @@ -8,13 +8,6 @@ translators: lang: pt-br --- -TypeScript is a language that aims at easing development of large scale applications written in JavaScript. -TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript. -It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript. - -This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/). - - Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript. Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript. É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript. diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown index 989bae05..7bdeec25 100644 --- a/pt-br/whip-pt.html.markdown +++ b/pt-br/whip-pt.html.markdown @@ -15,13 +15,13 @@ Whip é um dialeto de Lisp feito para construir scripts e trabalhar com conceitos mais simples. Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata) -Esse documento foi escrito pelo próprio autor da linguagem. Então é isso. +Esse documento foi escrito pelo próprio autor da linguagem. Então é isso. ```scheme ; Comentário são como em Lisp. Pontos-e-vírgulas... ; A maioria das declarações de primeiro nível estão dentro de "listas" -; que nada mais são que coisas entre parêntesis separadas por espaços em branco +; que nada mais são que coisas entre parênteses separadas por espaços em branco nao_é_uma_lista (uma lista) @@ -64,7 +64,7 @@ false (not false) ; => true ; Mas a maioria das funções não-haskell tem atalhos -; o não atalho é um '!'. +; o atalho para "não" é um '!'. (! (! true)) ; => true ; Igualdade é `equal` ou `=`. @@ -114,7 +114,7 @@ undefined ; usada para indicar que um valor não foi informado (1 2 3) ; => [1, 2, 3] (sintaxe JavaScript) ; Dicionários em Whip são o equivalente a 'object' em JavaScript ou -; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada +; 'dict' em python ou 'hash' em Ruby: eles são uma coleção desordenada de pares chave-valor. {"key1" "value1" "key2" 2 3 3} @@ -222,7 +222,7 @@ linguagens imperativas. (take 1 (1 2 3 4)) ; (1 2) ; Contrário de `take` (drop 1 (1 2 3 4)) ; (3 4) -; Menos valor em uma lista +; Menor valor em uma lista (min (1 2 3 4)) ; 1 ; Maior valor em uma lista (max (1 2 3 4)) ; 4 diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown index f347f8ef..6710b387 100644 --- a/pt-br/xml-pt.html.markdown +++ b/pt-br/xml-pt.html.markdown @@ -10,8 +10,7 @@ lang: pt-br XML é uma linguagem de marcação projetada para armazenar e transportar dados. -Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, -basta carregá-lo. +Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, apenas o transporta. * Sintaxe XML diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown index 341ae675..0b71877e 100644 --- a/pt-br/yaml-pt.html.markdown +++ b/pt-br/yaml-pt.html.markdown @@ -11,9 +11,7 @@ lang: pt-br YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e legível por seres humanos. -É um estrito subconjunto de JSON, com a adição de sintaticamente -novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto, -YAML não permite caracteres de tabulação literais em tudo. +É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação. ```yaml # Commentários em YAML são como este. |