summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--hack.html.markdown7
-rw-r--r--pt-br/hack-pt.html.markdown316
2 files changed, 320 insertions, 3 deletions
diff --git a/hack.html.markdown b/hack.html.markdown
index 632fc705..b9730dc0 100644
--- a/hack.html.markdown
+++ b/hack.html.markdown
@@ -2,6 +2,7 @@
language: Hack
contributors:
- ["Stephen Holdaway", "https://github.com/stecman"]
+ - ["David Lima", "https://github.com/davelima"]
filename: learnhack.hh
---
@@ -152,7 +153,7 @@ class ArgumentPromotion
private bool $isAwesome) {}
}
-class WithoutArugmentPromotion
+class WithoutArgumentPromotion
{
public string $name;
@@ -169,9 +170,9 @@ class WithoutArugmentPromotion
}
-// Co-oprerative multi-tasking
+// Co-operative multi-tasking
//
-// Two new keywords "async" and "await" can be used to perform mutli-tasking
+// Two new keywords "async" and "await" can be used to perform multi-tasking
// Note that this does not involve threads - it just allows transfer of control
async function cooperativePrint(int $start, int $end) : Awaitable<void>
{
diff --git a/pt-br/hack-pt.html.markdown b/pt-br/hack-pt.html.markdown
new file mode 100644
index 00000000..7c938149
--- /dev/null
+++ b/pt-br/hack-pt.html.markdown
@@ -0,0 +1,316 @@
+---
+language: Hack
+contributors:
+ - ["Stephen Holdaway", "https://github.com/stecman"]
+ - ["David Lima", "https://github.com/davelima"]
+translators:
+ - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnhack-pt.hh
+---
+
+Hack é uma linguagem baseada no PHP e roda numa máquina virtual chamada HHVM.
+Hack é quase completamente interoperável com códigos PHP existentes e adiciona
+alguns recursos úteis de linguagens estaticamente tipadas.
+
+Somente recursos específicos da linguagem Hack serão abordados aqui. Detalhes
+sobre a sintaxe do PHP estão disponíveis no
+[artigo PHP](http://learnxinyminutes.com/docs/php/) neste site.
+
+```php
+<?hh
+
+// A sintaxe do Hack é ativada apenas em arquivos que comecem com <?hh
+// Marcadores <?hh não podem ser incluídos em páginas HTML, diferente de <?php.
+// Usar o marcador "<?hh //strict" coloca o verificador de tipo no modo estrito.
+
+
+// Indução de tipo de parâmetros escalares
+function repeat(string $palavra, int $contagem)
+{
+ $palavra = trim($palavra);
+ return str_repeat($palavra . ' ', $contagem);
+}
+
+// Indução de tipo para valores de retorno
+function add(...$numeros) : int
+{
+ return array_sum($numeros);
+}
+
+// Funções que não retornam nada são induzidas com "void"
+function truncate(resource $recurso) : void
+{
+ // ...
+}
+
+// Induções de tipo devem permitir nulos de forma explícita
+function identity(?string $stringOuNulo) : ?string
+{
+ return $stringOuNulo;
+}
+
+// Induções de tipo podem ser especificadas em propriedades de classes
+class PropriedadesComTipos
+{
+ public ?string $nome;
+
+ protected int $id;
+
+ private float $pontuacao = 100.0;
+
+ // O verificador de tipos do Hack reforça que propriedades tipadas devem
+ // ter um valor padrão ou devem ser definidos no construtor
+ public function __construct(int $id)
+ {
+ $this->id = $id;
+ }
+}
+
+
+// Funções anônimas (lambdas)
+$multiplicador = 5;
+array_map($y ==> $y * $multiplicador, [1, 2, 3]);
+
+
+// Genéricos
+class Caixa<T>
+{
+ protected T $dados;
+
+ public function __construct(T $dados) {
+ $this->dados = $dados;
+ }
+
+ public function pegaDados(): T {
+ return $this->dados;
+ }
+}
+
+function abreCaixa(Caixa<int> $caixa) : int
+{
+ return $caixa->pegaDados();
+}
+
+
+// Formas
+//
+// Hack adiciona o conceito de formas para definir arrays com uma estrutura
+// e tipos de dados garantidos
+type Point2D = shape('x' => int, 'y' => int);
+
+function distancia(Point2D $a, Point2D $b) : float
+{
+ return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distancia(
+ shape('x' => -1, 'y' => 5),
+ shape('x' => 2, 'y' => 50)
+);
+
+
+// Pseudônimos de tipos
+//
+// Hack adiciona vários recursos para criação de pseudônimos, tornando tipos complexos
+// mais fáceis de entender
+newtype VectorArray = array<int, Vector<int>>;
+
+// Um tuple contendo dois inteiros
+newtype Point = (int, int);
+
+function adicionaPontos(Point $p1, Point $p2) : Point
+{
+ return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+adicionaPontos(
+ tuple(1, 2),
+ tuple(5, 6)
+);
+
+
+// enums em classes
+enum TipoDePista : int
+{
+ Estrada = 0;
+ Rua = 1;
+ Alameda = 2;
+ Avenida = 3;
+}
+
+function getTipoDePista() : TipoDePista
+{
+ return TipoDePista::Alameda;
+}
+
+
+// Especificação de argumentos no construtor (Argument Promotion)
+//
+// Para evitar que propriedades sejam definidas em mais de um lugar, e
+// construtores que só definem propriedades, o Hack adiciona uma sintaxe para
+// definir as propriedades e o construtor ao mesmo tempo.
+class ArgumentPromotion
+{
+ public function __construct(public string $nome,
+ protected int $idade,
+ private bool $legal) {}
+}
+
+class SemArgumentPromotion
+{
+ public string $nome;
+
+ protected int $idade;
+
+ private bool $legal;
+
+ public function __construct(string $nome, int $idade, bool $legal)
+ {
+ $this->nome = $nome;
+ $this->idade = $idade;
+ $this->legal = $legal;
+ }
+}
+
+
+// Multi-tarefas cooperativo
+//
+// Duas novas palavras-chave ("async" e "await") podem ser usadas para
+// trabalhar com multi-tarefas.
+// Obs. Isto não envolve threads - apenas permite a transferência de controle
+async function printCooperativo(int $inicio, int $fim) : Awaitable<void>
+{
+ for ($i = $inicio; $i <= $fim; $i++) {
+ echo "$i ";
+
+ // Permite que outras tarefas façam algo
+ await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+ }
+}
+
+// Imprime "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+ printCooperativo(1, 3),
+ printCooperativo(4, 6),
+ printCooperativo(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributos
+//
+// Atributos são uma forma de definir metadados para funções.
+// Hack tem alguns atributos especiais que possuem comportamentos úteis.
+
+// O atributo especial __Memoize faz com que o resultado da função fique em cache
+<<__Memoize>>
+function tarefaDemorada() : ?string
+{
+ return file_get_contents('http://exemplo.com');
+}
+
+// O corpo da função só é executado uma vez aqui:
+tarefaDemorada();
+tarefaDemorada();
+
+
+// O atributo especial __ConsistentConstruct faz com que o Hack certifique-se
+// de que a assinatura do construtor seja a mesma em todas as subclasses
+<<__ConsistentConstruct>>
+class FooConsistente
+{
+ public function __construct(int $x, float $y)
+ {
+ // ...
+ }
+
+ public function algumMetodo()
+ {
+ // ...
+ }
+}
+
+class BarConsistente extends FooConsistente
+{
+ public function __construct(int $x, float $y)
+ {
+ // O verificador de tipos do Hack exige que os construtores pai
+ // sejam chamados
+ parent::__construct($x, $y);
+
+ // ...
+ }
+
+ // A anotação __Override é uma anotação opcional que faz com que o
+ // verificador de tipos do Hack sobrescreva um método em uma classe pai
+ // ou um trait. Sem __Override, definir este método causará um erro,
+ // pois ele já foi definido na classe pai (FooConsistente):
+ <<__Override>>
+ public function algumMetodo()
+ {
+ // ...
+ }
+}
+
+class SubclasseFooInvalida extends FooConsistente
+{
+ // Caso o construtor não combine com o construtor da classe pai, o
+ // verificador de tipos acusará um erro:
+ //
+ // "Este objeto é incompatível com o objeto FooConsistente porque algum(ns)
+ // dos seus métodos são incompatíveis"
+ //
+ public function __construct(float $x)
+ {
+ // ...
+ }
+
+ // Usar a anotação __Override em um método que não existe na classe pai
+ // causará um erro do verificador de tipos:
+ // "SubclasseFooInvalida::outroMetodo() está marcada para sobrescrever;
+ // nenhuma definição não-privada foi encontrada ou a classe pai foi
+ // definida em código não-<?hh"
+ //
+ <<__Override>>
+ public function outroMetodo()
+ {
+ // ...
+ }
+}
+
+
+// Traits podem implementar interfaces (não suportado pelo PHP)
+interface InterfaceGatinho
+{
+ public function brinca() : void;
+}
+
+trait TraitGato implements InterfaceGatinho
+{
+ public function brinca() : void
+ {
+ // ...
+ }
+}
+
+class Samuel
+{
+ use TraitGato;
+}
+
+
+$gato = new Samuel();
+$gato instanceof InterfaceGatinho === true; // True
+
+```
+
+## Mais informações
+
+Visite a [documentação do Hack](http://docs.hhvm.com/manual/en/hacklangref.php)
+para ver explicações detalhadas dos recursos que Hack adiciona ao PHP, ou o [site oficial do Hack](http://hanlang.org/)
+para outras informações.
+
+Visite o [site oficial do HHVM](http://hhvm.com/) para aprender a instalar o HHVM.
+
+Visite [este artigo](http://docs.hhvm.com/manual/en/hack.unsupported.php) para ver
+os recursos do PHP que o Hack não suporta e ver incompatibilidades entre Hack e PHP.