summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/bf.html.markdown1
-rw-r--r--pt-br/c++-pt.html.markdown2
-rw-r--r--pt-br/c-pt.html.markdown2
-rw-r--r--pt-br/groovy-pt.html.markdown2
-rw-r--r--pt-br/hy-pt.html.markdown2
-rw-r--r--pt-br/javascript-pt.html.markdown1
-rw-r--r--pt-br/kotlin-pt.html.markdown384
-rw-r--r--pt-br/solidity-pt.html.markdown914
-rw-r--r--pt-br/swift-pt.html.markdown3
9 files changed, 1306 insertions, 5 deletions
diff --git a/pt-br/bf.html.markdown b/pt-br/bf.html.markdown
index d6d7c6e9..52a5269e 100644
--- a/pt-br/bf.html.markdown
+++ b/pt-br/bf.html.markdown
@@ -1,5 +1,6 @@
---
language: bf
+filename: learnbf-pt.bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index fd392b9e..c1cfbbb1 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -1,6 +1,6 @@
---
language: c++
-filename: learncpp.cpp
+filename: learncpp-pt.cpp
contributors:
- ["Steven Basart", "http://github.com/xksteven"]
- ["Matt Kline", "https://github.com/mrkline"]
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 0af553c8..6e7aa8c2 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -647,7 +647,7 @@ Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http:/
É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral.
Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja
-[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
Além disso, Google é teu amigo.
[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 2ec7d967..25e123c0 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -1,7 +1,7 @@
---
language: Groovy
category: language
-filename: learngroovy.groovy
+filename: learngroovy-pt.groovy
contributors:
- ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
translators:
diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown
index 5fa4df75..c69ac859 100644
--- a/pt-br/hy-pt.html.markdown
+++ b/pt-br/hy-pt.html.markdown
@@ -1,6 +1,6 @@
---
language: hy
-filename: learnhy.hy
+filename: learnhy-pt.hy
contributors:
- ["Abhishek L", "http://twitter.com/abhishekl"]
translators:
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index e337f4bc..7b6729ef 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -1,5 +1,6 @@
---
language: javascript
+filename: javascript-pt.js
contributors:
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
new file mode 100644
index 00000000..7c3313fc
--- /dev/null
+++ b/pt-br/kotlin-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: kotlin
+filename: LearnKotlin-pt.kt
+contributors:
+ - ["S Webber", "https://github.com/s-webber"]
+translators:
+ - ["Márcio Torres", "https://github.com/marciojrtorres"]
+lang: pt-br
+---
+
+Kotlin é uma linguagem de programação estaticamente tipada para a JVM, Android e navegadores web. Ela é 100% interoperável com Java.
+[Leia mais aqui.](https://kotlinlang.org/)
+
+```kotlin
+// Comentários de uma linha iniciam com //
+/*
+Comentários multilinha se parecem com este.
+*/
+
+// A palavra-chave "package" funciona do mesmo modo que no Java.
+package com.learnxinyminutes.kotlin
+
+/*
+O ponto de entrada para um programa em Kotlin é uma função chamada "main"
+Esta função recebe um vetor contendo quaisquer argumentos da linha de comando
+*/
+fun main(args: Array<String>) {
+ /*
+ A declaração de valores pode ser feita tanto com "var" como "val"
+ Declarações com "val" não podem ser reatribuídas, enquanto com "var" podem.
+ */
+ val umVal = 10 // não se poderá reatribuir qualquer coisa a umVal
+ var umVar = 10
+ umVar = 20 // umVar pode ser reatribuída, mas respeitando o tipo
+
+ /*
+ Na maioria dos casos Kotlin pode inferir o tipo, então não é preciso sempre
+ especificar o tipo explicitamente, mas quando o fazemos é assim:
+ */
+ val umInteiro: Int = 7
+
+ /*
+ Strings podem ser representadas de forma semelhante a Java.
+ A contrabarra realiza o "escape", da mesma forma.
+ */
+ val umaString = "Minha String está aqui!"
+ val outraString = "Imprimir na outra linha?\nSem problema!"
+ val maisString = "Você quer adicionar um tab?\tSem problema!"
+ println(umaString)
+ println(outraString)
+ println(maisString)
+
+ /*
+ Uma string bruta é delimitada com três aspas (""").
+ Strings brutas podem conter novas linhas e outros caracteres.
+ */
+ val umaStringBruta = """
+fun olaMundo(val nome : String) {
+ println("Olá, mundo!")
+}
+"""
+ println(umaStringBruta)
+
+ /*
+ As strings podem conter expressões modelo (template).
+ Uma expressão modelo começa com um cifrão ($).
+ É semelhante à interpolação de Strings em Ruby.
+ */
+ val umaStringModelo = "$umaString tem ${umaString.length} caracteres"
+ println(umaStringModelo)
+
+ /*
+ Para uma variável receber null deve-se explicitamente declara-la
+ como anulável.
+ A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
+ Pode-se acessar uma variável anulável usando o operador "?."
+ Usa-se o operador "?:" (também conhecido como operador Elvis) para
+ atribuir um valor alternativo para quando uma variável é nula.
+ */
+ var umaVariavelAnulavel: String? = "abc"
+ println(umaVariavelAnulavel?.length) // => 3
+ println(umaVariavelAnulavel?.length ?: -1) // => 3
+ umaVariavelAnulavel = null
+ println(umaVariavelAnulavel?.length) // => null
+ println(umaVariavelAnulavel?.length ?: -1) // => -1
+
+ /*
+ Funções podem ser declaradas usando a palavra-chave "fun"
+ Os parâmetros da função são declarados entre parênteses logo
+ após o nome da função.
+ Os parâmetros da função podem ter opcionalmente um valor padrão.
+ O tipo de retorno da função, se necessário, é especificado após os argumentos.
+ */
+ fun ola(nome: String = "mundo"): String {
+ return "Olá, $nome!"
+ }
+ println(ola("você")) // => Olá, você!
+ println(ola(nome = "tu")) // => Olá, tu!
+ println(ola()) // => Olá, mundo!
+
+ /*
+ Um parâmetro pode ser declarado com a palavra-chave "vararg" para
+ permitir que seja passado um número variável de argumentos.
+ */
+ fun exemploVarArg(vararg numeros: Int) {
+ println("Foram recebidos ${numeros.size} argumentos")
+ }
+ exemploVarArg() // => Passando nenhum argumento (0 argumentos)
+ exemploVarArg(1) // => Passando 1 argumento
+ exemploVarArg(1, 2, 3) // => Passando 3 argumentos
+
+ /*
+ Quando uma função consiste numa única expressão as chaves
+ podem ser omitidas e o corpo declarado após o símbolo de "="
+ */
+ fun impar(x: Int): Boolean = x % 2 == 1
+ println(impar(6)) // => false
+ println(impar(7)) // => true
+
+ // O tipo de retorno não precisa ser declarado se pode ser inferido.
+ fun impar(x: Int) = x % 2 == 0
+ println(impar(6)) // => true
+ println(impar(7)) // => false
+
+ // Funções podem receber e retornar outras funções
+ fun nao(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)}
+ }
+ // Funções nomeadas podem ser passadas como argumento usando o operador "::"
+ val naoImpar = nao(::impar)
+ val naoPar = nao(::par)
+ // Expressões Lambda podem ser usadas como argumentos
+ val naoZero = nao {n -> n == 0}
+ /*
+ Se uma lambda têm apenas um parâmetro sua declaração pode ser omitida,
+ incluindo o símbolo "->".
+ Neste caso o nome do único parâmetro deve ser "it".
+ */
+ val naoPositivo = nao {it > 0}
+ for (i in 0..4) {
+ println("${naoImpar(i)} ${naoPar(i)} ${naoZero(i)} ${naoPositivo(i)}")
+ }
+
+ // A palavra-chave "class" é usada para declarar classes
+ class ClasseExemplo(val x: Int) {
+ fun funcaoMembro(y: Int): Int { // ou "método"
+ return x + y
+ }
+
+ infix fun funcaoMembroInfixa(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ Para criar uma nova instância chama-se o construtor.
+ Note que Kotlin não tem a palavra-chave "new".
+ */
+ val umaInstanciaDaClasseExemplo = ClasseExemplo(7)
+ // Funções membro (métodos) podem ser chamados usando a notação ponto "."
+ println(umaInstanciaDaClasseExemplo.funcaoMembro(4)) // => 11
+ /*
+ Se uma função foi declarada com a palavra-chave "infix" então
+ ela pode ser invocada com a notação infixa.
+ */
+ println(umaInstanciaDaClasseExemplo funcaoMembroInfixa 4) // => 28
+
+ /*
+ Classes de dados são um modo sucinto de criar classes que servem apenas
+ para guardas informações.
+ Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
+ */
+ data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
+ val objetoDados = ExemploClasseDados(1, 2, 4)
+ println(objetoDados) // => ExemploClasseDados(x=1, y=2, z=4)
+
+ // Classes de dados têm uma função "copy"
+ val dadosCopia = objetoDados.copy(y = 100)
+ println(dadosCopia) // => ExemploClasseDados(x=1, y=100, z=4)
+
+ // Objetos podem ser desestruturados em múltiplas variáveis.
+ val (a, b, c) = dadosCopia
+ println("$a $b $c") // => 1 100 4
+
+ // desestruturando em um laço "for"
+ for ((a, b, c) in listOf(objetoDados)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapaDados = mapOf("a" to 1, "b" to 2)
+ // Map.Entry também é desestruturável
+ for ((chave, valor) in mapaDados) {
+ println("$chave -> $valor")
+ }
+
+ // A função "with" é semelhante à declaração "with" do JavaScript
+ data class ExemploClasseDadosMutaveis (var x: Int, var y: Int, var z: Int)
+ val objDadosMutaveis = ExemploClasseDadosMutaveis(7, 4, 9)
+ with (objDadosMutaveis) {
+ x -= 2
+ y += 2
+ z--
+ }
+ println(objDadosMutaveis) // => ExemploClasseDadosMutaveis(x=5, y=6, z=8)
+
+ /*
+ Pode-se criar uma lista usando a função "listOf".
+ A lista é imutável, isto é, elementos não podem ser adicionados ou removidos.
+ */
+ val umaLista = listOf("a", "b", "c")
+ println(umaLista.size) // => 3
+ println(umaLista.first()) // => a
+ println(umaLista.last()) // => c
+ // Elementos de uma lista podem ser acessados pelo índice
+ println(umaLista[1]) // => b
+
+ // Uma lista mutável pode ser criada com a função "mutableListOf".
+ val umaListaMutavel = mutableListOf("a", "b", "c")
+ umaListaMutavel.add("d")
+ println(umaListaMutavel.last()) // => d
+ println(umaListaMutavel.size) // => 4
+
+ // Similarmente, pode-se criar um conjunto com a função "setOf".
+ val umConjunto = setOf("a", "b", "c")
+ println(umConjunto.contains("a")) // => true
+ println(umConjunto.contains("z")) // => false
+
+ // Da mesma forma que um mapa com a função "mapOf".
+ val umMapa = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Os valores contidos no mapa podem ser acessados pela sua chave.
+ println(umMapa["a"]) // => 8
+
+ /*
+ Sequências representam coleções avaliadas "preguiçosamente" (sob demanda).
+ Pode-se criar uma sequência usando a função "generateSequence".
+ */
+ val umaSequencia = generateSequence(1, { it + 1 })
+ val x = umaSequencia.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Um exemplo de uma sequência usada para gerar Números de Fibonacci:
+ fun sequenciaFibonacci(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun proximo(): Long {
+ val resultado = a + b
+ a = b
+ b = resultado
+ return a
+ }
+
+ return generateSequence(::proximo)
+ }
+ val y = sequenciaFibonacci().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+ // Kotlin oferece funções de alta-ordem para trabalhar com coleções.
+ val z = (1..9).map {it * 3}
+ .filter {it < 20}
+ .groupBy {it % 2 == 0}
+ .mapKeys {if (it.key) "par" else "impar"}
+ println(z) // => {impar=[3, 9, 15], par=[6, 12, 18]}
+
+ // Um "for" pode ser usado com qualquer coisa que ofereça um "iterator"
+ for (c in "salve") {
+ println(c)
+ }
+
+ // O "while" funciona da mesma forma que em outras linguagens.
+ var contador = 0
+ while (contador < 5) {
+ println(contador)
+ contador++
+ }
+ do {
+ println(contador)
+ contador++
+ } while (contador < 10)
+
+ /*
+ "if" pode ser usado como uma expressão que retorna um valor.
+ Por este motivo o operador ternário "? :" não é necessário em Kotlin.
+ */
+ val numero = 5
+ val mensagem = if (numero % 2 == 0) "par" else "impar"
+ println("$numero é $mensagem") // => 5 é impar
+
+ // "when" pode ser usado como alternativa às correntes de "if-else if".
+ val i = 10
+ when {
+ i < 7 -> println("primeiro block")
+ umaString.startsWith("oi") -> println("segundo block")
+ else -> println("bloco else")
+ }
+
+ // "when" pode ser usado com um argumento.
+ when (i) {
+ 0, 21 -> println("0 ou 21")
+ in 1..20 -> println("entre 1 e 20")
+ else -> println("nenhum dos anteriores")
+ }
+
+ // "when" pode ser usada como uma função que retorna um valor.
+ var resultado = when (i) {
+ 0, 21 -> "0 ou 21"
+ in 1..20 -> "entre 1 e 20"
+ else -> "nenhum dos anteriores"
+ }
+ println(resultado)
+
+ /*
+ Pode-se verificar se um objeto é de um certo tipo usando o operador "is".
+ Se o objeto passar pela verificação então ele pode ser usado como
+ este tipo, sem a necessidade de uma coerção (cast) explícita (SmartCast).
+ */
+ fun exemploSmartCast(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x é automaticamente coagido para Boolean
+ return x
+ } else if (x is Int) {
+ // x é automaticamente coagido para Int
+ return x > 0
+ } else if (x is String) {
+ // x é automaticamente coagido para String
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(exemploSmartCast("Olá, mundo!")) // => true
+ println(exemploSmartCast("")) // => false
+ println(exemploSmartCast(5)) // => true
+ println(exemploSmartCast(0)) // => false
+ println(exemploSmartCast(true)) // => true
+
+ // O Smartcast também funciona com blocos "when"
+ fun exemploSmartCastComWhen(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ As extensões são uma maneira nova de adicionar funcionalidades a classes.
+ Elas são similares aos "extension methods" da linguagem C#.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("olá, mundo!".remove('o')) // => lá, mund!
+
+ println(ExemploEnum.A) // => A
+ println(ExemploObjeto.ola()) // => olá
+}
+
+// Classes Enum são similares aos "enum types" do Java.
+enum class ExemploEnum {
+ A, B, C
+}
+
+/*
+A palavra-chave "object" pode ser usar para criar Singletons.
+Eles não são instanciados, mas podem referenciar sua instância única pelo nome.
+É semelhante aos "singleton objects" da linguagem Scala.
+*/
+object ExemploObjeto {
+ fun ola(): String {
+ return "olá"
+ }
+}
+
+fun usaObjeto() {
+ ExemploObjeto.ola()
+ val algumaReferencia: Any = ExemploObjeto // usa-se o nome diretamente
+}
+
+```
+
+### Leitura Adicional
+
+* [Tutoriais de Kotlin](https://kotlinlang.org/docs/tutorials/)(EN)
+* [Experimente Kotlin no seu navegador](http://try.kotlinlang.org/)(EN)
+* [Uma lista de material sobre Kotlin](http://kotlin.link/)(EN)
diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
new file mode 100644
index 00000000..37d15bf2
--- /dev/null
+++ b/pt-br/solidity-pt.html.markdown
@@ -0,0 +1,914 @@
+---
+language: Solidity
+filename: learnSolidity.sol
+contributors:
+ - ["Nemil Dalal", "https://www.nemil.com"]
+ - ["Joseph Chow", ""]
+translators:
+ - ["João Farias", "http://thatsabug.com/"]
+lang: pt-br
+---
+
+Solidity permite você programar para a [Ethereum]
+(https://www.ethereum.org/), uma máquina virtual baseada na tecnologia blockhain
+para criação e execução de contratos inteligentes, sem necessidade de partes
+centralizadas ou de confiança.
+
+Solidity é uma linguagem de contratos estaticamente tipaada com similaridade com
+Javascript e C. Como objetos em programação orientada a objetos, cada contrato
+possue variáveis de estado, funções e tipos de dados comuns. Funcionalidades
+particulares de contratados incluem cláusuras modificadoras (guarda), notifica
+dores de eventos para listerners e variáveis globais customizadas.
+
+
+Exemplos de contratos Ethereum incluem crowdfunding, votações e audições cegas.
+
+Erros em código Solidity causam grandes riscos e custos; portanto, você
+deve ser muito cuidado com teste e divulgação. DEVIDO ÀS CONSTANTES MUDANÇAS
+NO ETHEREUM, ESTE DOCUMENTOS PROVAVELMENTE NÃO ESTARÁ ATUALIZADO, VOCÊ DEVE
+ACOMPANHAR A CHATROOM DO SOLIDITY E O BLOG DO ETHEREUM PARA NOTÍCIAS ATUALIZADAS.
+TODO CÓDIGO AQUI É ENTREGUE COMO ESTÁ, COM SUBSTANCIAL RISCO DE ERRROS E PADRÕES
+DE CÓDIGO DEPRECADOS.
+
+Diferentemente de outros tipo de código, você também deve adicionar padrões
+como pausa, deprecação e retração para reduzir riscos. Este documento discute
+sintaxe, então, muito padrões populares são excluídos.
+
+Como Solidity e Ethereum ainda estão sob desenvolvimento, funcionalidades beta
+e experimentais são tipicamente marcadas e sujeitas à mudanças. Pull requests
+são bem-vindos.
+
+```javascript
+// Primeiramente, um contrato de um Banco simples
+// Permite depósitos, retiradas e checagens de saldo
+
+// banco_simples.sol (note a extensão .sol)
+
+/* **** INCICIO DO EXEMPLO **** */
+
+// Declare a versão do compilador.
+pragma solidity ^0.4.2;
+
+// Inicie com comentários Natspec (as três barras)
+// usados para documentação - e como dados descritivos para elementos/ação de UI
+
+/// @title BancoSimples
+/// @author nemild
+
+/* 'contrato' tem similadirades com 'classes' em outras linguagens (variáveis de
+class, herança, etc.) */
+
+contract BancoSimples { // CamelCase
+ // Declare variáveis de estado fora da função, para persistí-la durante a
+ // duração do contrato
+
+ // dicionário que mapeia endereços para saldos
+ // tenha cuidado sobre ataques de overflow com números
+
+ mapping (address => uint) private saldos;
+
+ // "private" significa que outros contratos não podem acessar saldos
+ // diretamente, mas o dado ainda é visível para outras partes da blockchain
+
+ address public dono;
+
+ // ´public´ é legível (mas sem acesso de escrita) por usuários e contratos
+
+ // Eventos - ações públicas para ouvintes externo
+ event LogRealizacaoDeDeposito(address numeroDaConta, uint quantidade);
+
+ // Construtor, pode receber uma ou várias variáveis; apenas uma opção é
+ // permitidas
+
+ function BancoSimples() {
+ // msg dá detalhes sobre a mensagem mandada pelo contrato
+ // msg.sender é um chamador do contrato (endereço do criador do
+ // contrato)
+
+ dono = msg.sender;
+ }
+
+ /// @notice Deposita ether no banco
+ /// @return O saldo do usuário após o depósito
+
+ function deposito() public returns (uint) {
+ saldos[msg.sender] += msg.value;
+
+ // Sem necessidade de "this." ou "self." para variáveis de estado
+ // todos as variáveis são inciadas com seu valor default
+
+ LogRealizacaoDeDeposito(msg.sender, msg.value); // dispara evento
+
+ return saldos[msg.sender];
+ }
+
+ /// @notice Retira ether do banco
+ /// @dev Isto não retorna nenhum ether excendente
+ /// @param quantidadeDeRetirada quantidade que você quer retirar
+ /// @return O saldo restante do usuário
+ function retirada(uint quantidadeDeRetirada) public returns (uint saldoRestate) {
+ if(saldos[msg.sender] >= quantidadeDeRetirada) {
+
+ // Observe como deduzimos o saldo imediatamente, antes de enviar -
+ // devido ao risco de uma chamada recursiva que permite o chamador
+ // pedir um valor maior que seu saldo
+
+ saldos[msg.sender] -= quantidadeDeRetirada;
+
+ if (!msg.sender.send(quantidadeDeRetirada)) {
+ // incremente de volta só se falhar, como pode estar enviando
+ // para o contrato que substituiu 'enviar' no final
+ // do recebimento
+ saldos[msg.sender] += quantidadeDeRetirada;
+ }
+ }
+
+ return saldos[msg.sender];
+ }
+
+ /// @notice Retorna o saldo
+ /// @return O saldo do usuário
+ // 'constant' evita que a função edite variáveis de estado
+ // permite a função executar localmente/fora da blockchain
+ function saldo() constant returns (uint) {
+ return saldos[msg.sender];
+ }
+
+ // Função de fallback - Chamada se outras funções não forem chamadas ou
+ // se ether sem dados forem enviados
+ // Tipicamente chamada quando dados inválidos são enviados
+ // Adicionada para que ether enviado neste contrato seja revertido se o
+ // contrato falhar. Se não existisse, o dinheiro do enviante é transferido
+ // para o contrato
+ function () {
+ throw; // 'throw' reverte o estao para antes da chamada
+ }
+}
+// ** FIM DO EXEMPLO **
+
+// Agora, o básico de Solidity
+
+
+//1 TIPO DE DADOS E MÉTODOS ASSOCIADOS
+// uint é usado para quantidade de moeda (não existem doubles ou floats)
+// e para datas (no sistema de tempo Unix)
+
+uint x;
+
+// int de 256 bits, não pode ser mudado após sua instanciação
+int constant a = 8;
+int256 constant a = 8; // mesmo efeito, mas aqui os 256 bits são explícitos
+uint constant VERSÃO_ID = 0x123A1; // uma constante hexadecimal
+
+// com 'constant', o compilador substitui cada ocorrência com o valor
+
+// Para int e uint, é possível determinar o espaço explicitamente, em intervalos
+// de 8 a 256, e.g., int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// Cuidado contra overflows, e proteja-se contra esse tipo de ataque
+
+// Não há funções randômicas padrão, use outros contratos para este objetivo
+
+// Casting de tipo
+int x = int(b);
+
+bool b = true; // ou então 'var b = true;' para inferição de tipo
+
+// Endereços - comportam 20 bytes/160 bits endereços Ethereum
+// Não permite operações aritiméticas
+address public dono;
+
+// Tipos de contas:
+// Conta de contrato: endereço criado ao criar (função do endereço do criador,
+// número da transação)
+// Conta externa: (pessoa/entidade externa): endereç criado a partir de chave
+// pública
+
+// Adicione o campo 'public' para indicar visibilidade pública/externa
+// um getter é automaticamente criado, mas NÃO um setter
+
+// Todos os endereços podem enviar ether
+dono.send(ALGUM_SALDO); // returna falso caso falhe
+if (dono.send) {} // LEMBRE-SE: encapsule num 'if', dado que endereços de
+// contrato tem funções executadas no envio e estas podem falhar
+//Também certifique-se que os saldos deduzidos ANTES de tentar enviar, dado que
+// há um risco de chamada recursiva que pode drenar um contrato
+
+// pode sobrescrever seu próprio
+
+// Pode verificar o saldo
+dona.balance; // o saldo do dono (usuário ou contrato)
+
+// Bytes permitidos de 1 a 32
+byte a; // byte é o mesmo que bytes1
+bytes2 b;
+bytes32 c;
+
+// Bytes dinamicamente criados
+
+bytes m; // Um array especial, mesmo que byte[] (mas mais comprimido)
+
+// Mais custoso que byte1-byte32, então, prefira estes quando possível
+
+// mesmo que bytes, mas não permite verificar tamanho ou acesso por indíce (por
+// enquanto)
+
+string n = "oi"; // guardado em UTF8, note as aspas duplas, não simples
+
+// funções de string serão adicionadas no futuro
+// prefira bytes32/bytes, dado que UTF8 usa mais espaço
+
+// Inferência de tipo
+// var não infere tipos baseados na primeira atribuição,
+// não pode ser usado em paramêtros de funções
+
+var a = true;
+
+// use com cuidado, inferência pode resultar em tipos errados
+// e.g., um int8, quando um contador precisa de int16
+
+// var pode ser usado para assinalar uma função a uma variável
+function a(uint x) returns (uint) {
+ return x * 2;
+}
+var f = a;
+f(22); // chamada
+
+// por padrão, todos os valores são inicializados com 0
+
+// Delete pode ser chamada na maioria dos tipos
+// (NÃO destroi o valor, mas retorna para o valor 0, o incial)
+
+uint x = 5;
+
+// Desestruturação/Tuplas
+(x, y) = (2, 7); // assinada/troca múltiplos valores
+
+// 2. ESTRUTURAS DE DADOS
+// Arrays
+
+bytes32[5] apelidos; // array estático
+bytes32[] nomes; // array dinâmico
+uint novoTamanho = nomes.push("João"); // adicionando retorna o novo tamanho do
+
+// Tamanho
+nomes.length; // pega o tamanho
+nomes.length = 1; // tamanhos pode ser alterados (para arrays dinâmicos)
+
+// arrays multidimensionais
+uint x[][5]; // array com 5 arrays dinâmicos como elementos (ordem da maioria
+// das linguagens)
+
+// Dicionários (qualquer tipo para qualquer tipo)
+mapping (string => uint) public saldos;
+saldos["charles"] = 1;
+console.log(saldos["ada"]); // é 0, toda chave não assinalada retorna zero
+// 'public' permite o seguinte contrato
+nomeDoContrato.saldos("charles"); // retorna 1
+// 'public' cria um getter (mas não um setter) como o seguinte
+function saldos(string _conta) returns (uint saldo) {
+ return saldos[_conta];
+}
+
+// Mapeamentos aninhados
+mapping (endereco => mapping (endereco => uint)) public guardioes;
+
+// Para deletar
+delete saldos["John"];
+delete saldos; // assinala zero para todas as chaves
+
+// Diferentemente de outras linguages, NÃO É POSSÍVEL iterar sobre todos os
+// elementos de um mapeamento, sem saber previamente as chaves - é possível
+// construir estruturas de dados personalizadas para fazer isso
+
+// Structs e enums
+struct Banco {
+ address dono;
+ uint saldo;
+}
+Banco b = Banco({
+ dono: msg.sender,
+ saldo: 5
+});
+// ou
+Banco c = Banco(msg.sender, 5);
+
+c.quantidade = 5; // cria novo valor
+delete b;
+// assinala todos os valores do enum para zero, exceto mapeamentos
+
+// Enums
+enum Estado { Criado, Travado, Inativo }; // geralmente usado para máquina de
+// estados
+Estado public estado; // Declara variável para enum
+estado = Estado.Criado;
+// enums podem ser explicitamente convertidas em ints
+uint estadoCriado = uint(Estado.Criado); // 0
+
+// Localização de dados: Memória vs. disco vs. pilha - todos os tipos complexos
+// (arrays, structs) tem uma localização de dados
+// 'memória' não é persistida, 'disco' é
+// Padrão é 'disco' para variáveis locais e de estado; 'memória' para paramêtros
+// de função. Pilha guarda pequena variáveis locais
+
+// a maioria dos tipos podem ter sua localização de dados explicitamente assinalos
+
+// 3. Operações simples
+// Comparações, operadores binários e aritimétricos são providos
+// exponenciação: **
+// ou exclusivo: ^
+// negação binária: ~
+
+// 4. Variáveis Globais de nota
+// ** this **
+this; // endereço do contrato
+// geralmente usado no final do contrato para enviar o saldo restante às partes
+this.balance;
+this.algumFuncao(); // chamada de função externa via call, não via jump interno
+
+// ** msg - Mensagem corrente recebida pelo contrato ** **
+msg.sender; // endereço do enviador
+msg.value; // quantidade de ether provida para este contrato em wei
+msg.data; // bytes, todos os dados da chamada
+msg.gas; // gas restante
+
+// ** tx - Esta transação **
+tx.origin; // endereço do enviador da transação
+tx.gasprice; // valor do gas da transação
+
+// ** block - Informação do bloco corrente **
+now; // tempo corrente (aproxiamdo), substituto para block.timestamp
+//(usa tempo do Unix)
+block.number; // número do bloco corrente
+block.difficulty; // dificuldade do bloco corrente
+block.blockhash(1); // retorna bytes32, só funciona para os 256 blocos mais
+//recentes
+block.gasLimit();
+
+// ** storage - Hash de disco persistente **
+storage['abc'] = 'def'; // mapea palavras de 256 bits em palavras de 256 bits
+
+
+// 4. FUNÇÕES E MAIS
+// A. Funções
+// Funções simples
+function incremento(uint x) returns (uint) {
+ x += 1;
+ return x;
+}
+
+// Funções podem retornar muito argumentos, e podem especificar argumentos
+// retornados sem necessidade de explicitamente usar return
+function incremento(uint x, uint y) returns (uint x, uint y) {
+ x += 1;
+ y += 1;
+}
+// Chamando a função anterior
+uint (a,b) = incremento(1,1);
+
+// 'constant' indica que uam função não altera variáveis persistidas
+// Funções constantes são executadas localmente, não na blockchain
+uint y;
+
+function incremento(uint x) constant returns (uint x) {
+ x += 1;
+ y += 1; // Esta linha deve falhar
+ // y é uma variável de estado e não pode ser alterada por uma função local
+}
+
+// 'Especificadores de visibilidade de funções'
+// Estes podem substituitir 'constante', incluíndo:
+// public - visbilidade externa e interna (padrão)
+// private - apenas visível no contrato corrente
+// internal - apenas visível no contrato corrente e seus derivados
+
+// Functions hosteada - e pode ser assinalada para variável
+function a() {
+ var z = b;
+ b();
+}
+
+function b() {
+
+}
+
+// Prefira loops sobre recursões (pilha de chamada é no máximo 1024)
+
+// B. Eventos
+// Eventos podem notificar partes externas; facilmente buscáveis e acessáveis
+// de fora da blockchain (com clientes leves)
+// tipicamente declarados após os parâmetros do contrato
+
+// Tipicamente, com letra maiúscula - e adicione Log na frente para
+// ser explicito e previnir confusão na chamada da função
+
+// Declaração
+event LogEnvio(address indexed de, address indexed para, uint quantidade);
+// Observe a letra maíscula no início do nome
+
+// Chamada
+Envio(de, para, quantidade);
+
+// Para partes externas (um contrato ou entidade externo), observe:
+Coin.Envio().watch({}, '', function(erro, resultado) {
+ if (!erro) {
+ console.log("Moeda transferida: " + resultado.args.quantidade +
+ " moedas enviadas de " + resultado.args.de +
+ " para " + resultado.args.para + ".");
+ console.log("Saldo atual:\n" +
+ "Enviador: " + Coin.balances.call(resultado.args.de) +
+ "Recebedor: " + Coin.balances.call(resultado.args.para));
+ }
+}
+// Paradigma comum para um contrato depender de outro (e.g., um contrato que
+// depende da taxa de troca provida por outro)
+
+// C. ModifiCadores
+// MOdificadores validam entradas de funções, como saldo mínimo e autorização
+// do usuário; semelhantes a guardas em outras linguagens
+
+// '_' (subtraço) geralmente incluído como última linha do corpo, indica que a
+// função sendo chamada deve ser colocada ali
+modifier apenasDepois(uint _tempo) { if (agora <= _tempo) throw; _ }
+modifier apenasDono { if (msg.sender == dono) _ }
+// geralmente usado para máquina de estado
+modifier apenasSeEmEstado (Estado estadoCorrente)
+{ if (estadoCorrente != Estado.A) _ }
+
+// Concatenado logo após a chamada da função
+function mudeDona(novoDono)
+apenasDepois(algumTempo)
+apenasDono()
+apenasSeEmEstado(Estado.A)
+{
+ dono = novoDono;
+}
+
+// subtração pode ser incluído antes do final do corpo, mas retorno explícitos
+// pode ser ignorado, então, tome cuidado
+modifier chequeValor(uint quantidade) {
+ _
+ if (msg.value > quantidade) {
+ uint quantidadeASerDevolvida = quantidade - msg.value;
+ if (!msg.sender.send(quantidadeASerDevolvida)) {
+ throw;
+ }
+ }
+}
+
+// 6. BRANCHES E LOOPS
+
+// Todas as lógicas básicas de bloco funcionam - incluindo if/else,
+// while, break, continue, return - mas não há switch
+
+// A sintaxe é semelhante a Javascript, mas sem conversão de tipos
+// de não-booleanos para booleanos (operadores de comparação precisam
+// utilizar valores booleanos)
+
+// Loops que dependem o comportamento do usuário exigem cuidado - dado
+// que contratos tem uma quantidade máxima de gas para cada bloco de
+// de código - falhas acontecerão caso ele seja excedido
+// Por exemplo:
+for(uint x = 0; x < listaDeEnderecoDeRefundo.length; x++) {
+ if (!listaDeEnderecoDeRefundo[x].send(ALGUMA_QUANTIDADE)) {
+ throw;
+ }
+}
+
+// Dois erros acima:
+// 1. Uma falha no enviar para o loop completamente, travando dinheiro
+// 2. Este loop pode ser abitrariamente longo (basado na quando que
+// o usuário precisa de refundo), portanto, pode falhar quando exceder
+// a quantidade máxima de gas do bloco
+// Ao invés disso, você deve deixar as pessoas retirarem
+// individualmente de suas subcontas e marcarem a retirada
+
+
+// 7. OBJETOS/CONTRATOS
+
+// A. Chamando um contrato externo
+contract FonteDeInformacoes {
+ function info() returns (uint ret) { return 42; }
+}
+
+contract Consumidor {
+ FonteDeInformacoes fonte; // aponta para um contrato na blockchain
+
+ // Assinala variável para uma instância do contrato
+ function setFonte(address endereco) {
+ // Cast automático, cuidado; construtor não é chamado
+ fonte = FonteDeInformacoes(endereco);
+ }
+
+ // Assinala variável para uma nova instância do contrato
+ function createNewFeed() {
+ fonte = new FonteDeInformacoes(); // nova instância criada
+ // construtor é chamado
+ }
+
+ function chameFonte() {
+ // último parenteses chama o contrato, podendo adicionar
+ // opcionalmente valores ou gas
+ fonte.info.value(10).gas(800)();
+ }
+}
+
+// B. Herança
+
+// Ordem importa, último contrato herdado (i.e., 'def') pode
+// sobrescrever partes de contratos previamente herdados
+contract MeuContratdo is abc, def("um argumento personalizado def") {
+
+// sobrescrevendo função
+ function z() {
+ if (msg.sender == dono) {
+ def.z(); // chama função sobrescrita de def
+ super.z(); // chama função do pai imeadiato
+ }
+ }
+}
+
+// função abstrata
+function umaFuncaoAbstrata(uint x);
+// não pode ser compilada, usada em contratos base/abstratos que
+// então, a implementam
+
+// C. Import
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+// 'Import' está sobre desenvolvimento
+// Atualmente não pode ser usada na linha de comando
+
+
+// 8.OUTRAS PALAVRAS-CHAVE
+
+// A. Throwing
+// Throwing
+throw; // reverte estado e dinheiro NÃO-USADO é devolvido ao usuários
+// Atualmente não pode ser capturado
+
+// Um padrão de design comum é:
+if (!endereco.send(123)) {
+ throw;
+}
+
+// B. Selfdestruct
+// auto-destroe o contrato corrente, enviando fundos para o endereço
+// (geralmente o criador)
+selfdestruct(ALGUM_ENDERECO);
+
+// remove disco/código dos blocos corrente e futuros
+// ajuda clientes leves, mas dados persistidos continuam no blockchain
+
+// Padrão comum, permite ao dono finalizar o contrato e receber fundos
+// restantes
+function remover() {
+ if(msg.sender == criador) { // Apenas o criador do contrato pode
+ // fazer isso
+ selfdestruct(criador); // Inativa o contrato e retorna os fundos
+ }
+}
+
+// Talvez queria desativar o contrato manualmente, ao invés de usar
+// selfdestruct (ether enviado para contratos selfdestructed é perdido)
+
+
+// 9. NOTAS SOBRE DESIGN DE CONTRATOS
+
+// A. Obfuscação
+// Todas as variáveis são publicamente visíveis na blockchain, então
+// qualquer coisa privada precisa ser obfuscada (e.g., hash com segredo)
+
+// Passo-a-pass: 1. Comprometa-se com algo, 2. Revele compromisso
+sha3("quantidade_de_lance", "algum segredo"); // compromisso
+
+// chame a função reveal (revelar) do contrato no futuros
+// mostrando o lance mais o segredo para foi hasheado com SHA3
+reveal(100, "meuSegredo");
+
+// B. Otimização de disco
+// Escrever na blockchain pode ser caro, dado que os dados são guardados
+// para sempre. É encorajado que contratos inteligentes usem memória (
+// enventualmente, compilação será melhor, mas por enquanto é benéfico
+// usar estruturas de dados simples - armazenando minimamente na
+// blockchain)
+
+// Custo pode ser alto para item como arrays multidimensionais
+// (custo para guardar os dados - não declarar variáveis)
+
+// C. Acesso de dados da blockchain
+
+// Não pode restringir humanos ou computadores de ler os conteúdos
+// de transações ou estado de transações
+
+// Enquanto 'private' previne outros *contratos* de ler dados ]
+// diretamente - qualquer outra parte ainda pode ler dados da blockchain
+
+// Todos os dados são armazedos na blockchain, para que qualquer um
+// possa observar dados antigos e mudanças
+
+// D. Jobs Cron
+// Contratos deve ser manualmente chamados para lidar com agendamentos
+// baseados em tempo; podendo criar código externo para pingar
+// regularmente ou prover incentivos (ether) para outros fazê-lo
+
+// E. Padrão Observador
+// O Padrão Observador permite que você registre um inscritor e
+// registre uma função a ser chamada pelo Oráculo (nota, Oráculos pagam
+// pela ação executada). Similarmente à subscrição em Pub/sub
+
+// Este é um contrato abstrato, tanto as classes cliente como a
+// servidor importam o cliente que deve ser implementado
+contract AlgumOraculoCallback {
+ function OraculoCallback(int _valor, uint _tempo, bytes32 info) external;
+}
+
+contract AlgumOráculo {
+ AlgumOraculoCallback[] callbacks; // array com todos os inscritos
+
+ // Registra inscrito
+ function addInscrito(AlgumOraculoCallback a) {
+ callbacks.push(a);
+ }
+
+ function notificar(valor, tempo, info) private {
+ for(uint i = 0;i < callbacks.length; i++) {
+ // todos os inscritos precisam implementar AlgumOraculoCallback
+ callbacks[i].OraculoCallback(valor, tempo, info);
+ }
+ }
+
+ function facaAlgo() public {
+ // Código para fazer algo
+
+ // Notifica todos os inscrito
+ notificar(_valor, _tempo, _info);
+ }
+}
+
+// Agora, seu contrato cliente pode addInscrito importando
+// AlgumOraculoCallback e registrando algum Oráculo
+
+// F. Máquinas de estado
+// veja o exemplo abaixo para o enum Estado e o modificador noEstado
+
+// *** EXEMPLO: Um exemplo de crowdfunding example (similar ao
+// Kickstarter) ***
+// ** INCIO DO EXEMPLO **
+
+// FundadorDoCrowdFunding.sol
+
+/// @title FundadorDoCrowdFunding
+/// @author nemild
+contract FundadorDoCrowdFunding {
+ // Variáveis assinaladas na crição pelo criador
+ address public criador;
+ address public recipiente; // criador pode ser diferente do Recipiente
+ uint public minALevantar; // requisito para pagar, pelo contrário
+ // os doadores recebem o dinheiro de volta
+ string urlDaCampanha;
+ byte constant versao = 1;
+
+ // Estruturas de dados
+ enum Estado {
+ LevantandoFundos,
+ RefundoExpirado,
+ Sucesso
+ }
+ struct Contribuicao {
+ uint quantidade;
+ address contribuidor;
+ }
+
+ // Variáveis de Estado
+ State public estado = Estado.LevantandoFundos; // incializado na criação
+ uint public totalLevantado;
+ uint public levantadoPor;
+ uint public completadoEm;
+ Contribution[] contribuidores;
+
+ event LogRecebimentoDeFundos(address endereco,
+ uint quantidade,
+ uint totalAtual);
+ event LogFundosPagos(address enderecoDoRecebedor);
+
+ modifier noEstado(Estado _estado) {
+ if (estado != _estado) throw;
+ _
+ }
+
+ modifier eOCriador() {
+ if (msg.sender != criador) throw;
+ _
+ }
+
+ // Aguarda 6 meses após o final do contrato para destruí-lo
+ modifier noFimDoContrato() {
+ if(!((estado == Estado.RefundoExpirado || estado == Estado.Sucesso) &&
+ completadoEm + 6 months < now)) {
+ throw;
+ }
+ _
+ }
+
+ function FundadorDoCrowdFunding(
+ uint tempoEmHorasParaFundraising,
+ string _urlDaCampanha,
+ address _recipiente,
+ uint _minALevantar)
+ {
+ criador = msg.sender;
+ recipiente = _recipiente;
+ urlDaCampanha = _urlDaCampanha;
+ minALevantar = _minALevantar;
+ levantadoPor = now + (tempoEmHorasParaFundraising * 1 hours);
+ }
+
+ function contribuir()
+ public
+ noEstado(Estado.LevantandoFundos)
+ {
+ contribuidores.push(
+ Contribuicao({
+ quantidade: msg.value,
+ contribuidor: msg.sender
+ }) // use array, para podermos iterar
+ );
+ totalLevantado += msg.value;
+
+ LogRecebimentoDeFundos(msg.sender, msg.value, totalRaised);
+
+ verifiqueSeLevantamentoFoiCompletadoOuExpirado();
+ return contribuicoes.length - 1; // retorna id
+ }
+
+ function verifiqueSeLevantamentoFoiCompletadoOuExpirado() {
+ if (totalLevantado > minALevantar) {
+ estado = Estado.Sucesso;
+ pagar();
+
+ // pode incentivar enviador que iniciou a mudanção de estado
+ } else if ( now > levantadoPor ) {
+ estado = Estado.RefundoExpirado; // backers podem coletar
+ // o fundo chamando receberRefundo(id)
+ }
+ completadoEm = now;
+ }
+
+ function pagar()
+ public
+ emEstado(Estado.Sucesso)
+ {
+ if(!recipiente.send(this.balance)) {
+ throw;
+ }
+
+
+ LogFundosPagos(fundRecipient);
+ }
+
+ function receberRefundo(id)
+ public
+ emEstado(Estado.RefundoExpirado)
+ {
+ if (contribuicoes.length <= id || id < 0 || contribuicoes[id].amount == 0 ) {
+ throw;
+ }
+
+ uint quantidadeDeRefundo = contribuicoes[id].amount;
+ contribuicoes[id].amount = 0;
+
+ if(!contribuicoes[id].contribuidor.send(quantidadeParaEnviar)) {
+ contribuicoes[id].amount = quantidadeParaEnviar;
+ return false;
+ }
+
+ return true;
+ }
+
+ function removerContrato()
+ public
+ eOCriador()
+ noFimDoContrato()
+ {
+ selfdestruct(msg.sender);
+ // criador recebe todo o dinheiro restante{
+
+ }
+
+ function () { throw; }
+}
+// ** FIM DO EXEMPLO **
+
+// 10. OUTRAS FUNÇÕES NATIVAS
+
+// Unidades monetárias
+// Moeda é definida usando wei, menor quantidade de ether
+uint quantidadeMin = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// Para outras unidades, veja: http://ether.fund/tool/converter
+
+// Unidades temporais
+1 == 1 second // segundos
+1 minutes == 60 seconds // Minutos
+
+// Pode multiplicar uma variável de tempo, dado que unidades não são guardadas
+// na variável
+uint x = 5;
+(x * 1 days); // 5 dias
+
+// Cuidado com o salto de segundos / anos com declarações de igualdade para o tempo
+// (em vez disso, prefira maior que / menor que)
+
+// Criptografia
+// Todas as string passadas são concatenadas antes de realizar hashing
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+// 11. Segurança
+
+// Bugs são desastrosos para contratos Ethereum - até padrões Solidity populares
+// podem ser considerados anti-padrões
+
+// Veja links para segurança no final deste documento
+
+// 12. FUNÇÕES DE BAIXO NÍVELS
+// call - baixo nível, geralmente não usada, não tem segurança de tipos
+booleanSucesso = algumEnderecoDeContrato.call('nome_da_funcao', 'arg1', 'arg2');
+
+// callcode - Código no endereço alvo executado no *contexto* do contrato
+// de chamada. Fornece funcionalidade de biblioteca
+algumEnderecoDeContrato.callcode('nome_da_funcao');
+
+
+// 13. NOTAS DE ESTILO
+// Baseado no guia de estilo PEP8 do Python
+
+// Resumo rápido:
+// 4 espaços para identação
+// Duas linhas separam declaração de contratos (e outras declarações de alto nível)
+// Evite espaços estranhos entre parênteses
+// Pode omitir chaves curly para uma declaração de linha(if, for, etc)
+// else deve ser colocado na própria linha
+
+
+// 14. COMENTÁRIOS NATSPEC
+// usado para documentação, comentários e UIs externos
+
+// Contrato natspec - sempre acima da definição do contrato
+/// @title Título do Contrato
+/// @author Nome do autor
+
+// Função natspec
+/// @notice informações sobre o que funciona; mostrado quando a função é executada
+/// @dev Documentação de função para desenvolvedor
+
+// Parâmetro de função / valor de retorno natspec
+/// @param algumParametro Alguma descrição do que o parametro faz
+/// @return Descrição do valor de retorno
+```
+
+## Recursos adicionais
+- [Documetanção Solidity](https://solidity.readthedocs.org/en/latest/)
+- [Guia de Estilo do Solidity](https://ethereum.github.io/solidity//docs/style-guide/):
+ O guia de estilo Ethereum é derivado do guia de estilo do Python [pep8](https://www.python.org/dev/peps/pep-0008/).
+- [Editor de Browser Solidity](http://chriseth.github.io/browser-solidity/)
+- [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity)
+- [Estratégias de projeto modular para contratos Ethereum](https://docs.erisindustries.com/tutorials/solidity/)
+
+## Contratos de Exemplo
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Solidity Baby Step Contracts](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [ConsenSys Contracts](https://github.com/ConsenSys/dapp-store-contracts)
+- [State of Dapps](http://dapps.ethercasts.com/)
+
+## Segurança
+- [Thinking About Smart Contract Security](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Smart Contract Security](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Hacking Distributed Blog](http://hackingdistributed.com/)
+
+## Informação excluída intencionalmente
+- Libraries
+
+## Estilo
+- [PEP8](https://www.python.org/dev/peps/pep-0008/) é usado como guia de estilo,
+ incluindo sua filosofia geral
+
+## Editores
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Snippets de Editores ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Trabalhos Futuros
+- Novas palavras-chave: protected, inheritable
+- Lista de padrões de design comuns (throttling, RNG, atualização de versão)
+- Padrões anti-segurança comuns
+
+
+Sinta-se a vontade para enviar um pull request com quaisquer edições - ou email
+para nemild - / at- / gmail
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index 4ad67a06..ebf74b6f 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -1,12 +1,13 @@
---
language: swift
+filename: learnswift-pt.swift
contributors:
- ["Grant Timmerman", "http://github.com/grant"]
- ["Christopher Bess", "http://github.com/cbess"]
translators:
- ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
lang: pt-br
-filename: learnswift.swift
+
---
Swift é uma linguagem de programação para desenvolvimento de aplicações no iOS e OS X criada pela Apple. Criada para