From e9622c01f4a22106546c58c6e3fc8d1f6ef42cb6 Mon Sep 17 00:00:00 2001 From: David Lima Date: Tue, 30 Oct 2018 20:16:06 -0300 Subject: Translate Haxe documentation to pt-br --- pt-br/haxe-pt.html.markdown | 795 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 795 insertions(+) create mode 100644 pt-br/haxe-pt.html.markdown (limited to 'pt-br') 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(); // 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(); // um Array de Ints + var a3 = new Array>(); // 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(); // 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 + 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). -- cgit v1.2.3