diff options
Diffstat (limited to 'pt-br')
50 files changed, 11933 insertions, 207 deletions
diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown new file mode 100644 index 00000000..40c7cd09 --- /dev/null +++ b/pt-br/amd-pt.html.markdown @@ -0,0 +1,218 @@ +--- +category: tool +tool: amd +contributors: + - ["Frederik Ring", "https://github.com/m90"] +translators: + - ["Felipe Tarijon", "http://nanoincub.com/"] +lang: pt-br +filename: learnamd-pt.js +--- + +## Começando com AMD + +A API de Definição de Módulos Assíncrona **Asynchronous Module Definition** +especifica um mecanismo para definição de módulos em JavaScript para os quais o +módulo e suas dependências podem ser carregados de forma assíncrona. Isso é +particularmente bem adequado para o ambiente do browser onde o carregamento de +módulos de forma síncrona fica sujeito a problemas de performance, usabilidade, +debugging e problemas de acesso em requisições cross-domain. + +### Conceito básico +```javascript +// O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require` +// e isso é tudo sobre a definição de módulo e consumo: +// `define(id?, dependências?, factory)` define um módulo +// `require(dependências, callback)` importa uma série de dependências e +// consome elas no callback passado como parâmetro. + +// Vamos começar usando o define para definir um novo módulo +// que não tem dependências. Nós vamos fazer isso passando um nome +// e uma função factory para definir: +define('awesomeAMD', function(){ + var isAMDAwesome = function(){ + return true; + }; + // O valor retornado da função de factory do módulo é + // o que os outros módulos ou chamadas de require irão + // receber quando requisitarem nosso módulo `awesomeAMD`. + // O valor exportado pode ser qualquer coisa, (construtor) funções, + // objetos, primitives, até mesmo undefined (apesar de que não irão ajudar muito). + return isAMDAwesome; +}); + +// Agora, vamos definir outro módulo que depende do nosso módulo `awesomeAMD`. +// Perceba que existe um argumento adicional definindo nossas dependências do +// módulo agora: +define('loudmouth', ['awesomeAMD'], function(awesomeAMD){ + // dependências serão passadas como argumentos da factory + // na ordem que elas forem especificadas + var tellEveryone = function(){ + if (awesomeAMD()){ + alert('Isso é tãaaao loko!'); + } else { + alert('Bem estúpido, né não?'); + } + }; + return tellEveryone; +}); + +// Agora que nós sabemos como usar o define, vamos usar o `require` para +// começar nosso programa. A assinatura do `require` é `(arrayDedependências, callback)`. +require(['loudmouth'], function(loudmouth){ + loudmouth(); +}); + +// Para fazer esse tutorial executável, vamos implementar uma versão muito básica +// (não-assíncrona) de AMD bem aqui nesse lugar: +function define(nome, deps, factory){ + // perceba como os módulos sem dependências são manipulados + define[nome] = require(factory ? deps : [], factory || deps); +} + +function require(deps, callback){ + var args = []; + // primeiro vamos recuperar todas as dependências necessárias + // pela chamada requerida + for (var i = 0; i < deps.length; i++){ + args[i] = define[deps[i]]; + } + // corresponder todas as dependências da função de callback + return callback.apply(null, args); +} +// você pode ver esse código em ação aqui: http://jsfiddle.net/qap949pd/ +``` + +### Uso na vida real com require.js + +Em contraste com o exemplo introdutório, `require.js` (a biblioteca mais popular de AMD) na verdade implementa o **A** do **AMD**, permitindo que você carregue os módulos e suas +dependências via XHR: + +```javascript +/* file: app/main.js */ +require(['modules/algumaClasse'], function(AlgumaClasse){ + // o callback é deferido até que a dependencia seja carregada + var coisa = new AlgumaClasse(); +}); +console.log('Então aqui estamos nós, esperando!'); // isso vai rodar primeiro +``` + +Por convenção, você geralmente guarda um módulo em um arquivo. `require.js` pode resolver nome de módulos baseado no caminho das pastas, então você não precisa nomear os seus módulos, mas sim simplesmente referenciar eles usando sua origem. No exemplo `algumaClasse` é adotado a pasta `modules`, relativa a configuração da sua `baseUrl`: + +* app/ + * main.js + * modules/ + * algumaClasse.js + * algunsHelpers.js + * ... + * daos/ + * coisas.js + * ... + +Isso significa que nós podemos definir `algumaClasse` sem especificar o id de um módulo: + +```javascript +/* arquivo: app/modules/algumaClasse.js */ +define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){ + // definição de módulo, claro, irá acontecer também de forma assíncrona + function AlgumaClasse(){ + this.metodo = function(){/**/}; + // ... + } + return AlgumaClasse; +}); +``` +Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize +`requirejs.config(configObj)` em seu `main.js`: + +```javascript +/* arquivo: main.js */ +requirejs.config({ + baseUrl : 'app', + paths : { + // você pode também carregar módulos de outros locais + jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min', + coolLibFromBower : '../bower_components/cool-lib/coollib' + } +}); +require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coolLib, helpers){ + // um arquivo `main` precisa chamar o require pelo menos uma vez, + // caso contrário, o código jamais rodará + coolLib.facaAlgoDoidoCom(helpers.transform($('#foo'))); +}); +``` +Apps baseados em `require.js` geralmente terão um único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página: + +```html +<!DOCTYPE html> +<html> +<head> + <title>Umas 100 tags de script? Nunca mais!</title> +</head> +<body> + <script src="require.js" data-main="app/main"></script> +</body> +</html> +``` + +### Otimizando um projeto inteiro utilizando r.js + +Muitas pessoas preferem usar AMD para sanar a organização do código durante o desenvolvimento, mas continuam querendo colocar um único arquivo de script em produção ao invés de realizarem centenas de requisições XHRs no carregamento da página. + +`require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos. + +Instale-o utilizando `npm`: +```shell +$ npm install requirejs -g +``` + +Agora você pode alimentá-lo com um arquivo de configuração: +```shell +$ r.js -o app.build.js +``` + +Para o nosso exemplo acima a configuração pode ser essa: +```javascript +/* file : app.build.js */ +({ + name : 'main', // nome do ponto de acesso + out : 'main-built.js', // nome o arquivo para gravar a saída + baseUrl : 'app', + paths : { + // `empty:` fala para o r.js que isso ainda deve ser baixado da CDN, usando + // o local especificado no `main.js` + jquery : 'empty:', + coolLibFromBower : '../bower_components/cool-lib/coollib' + } +}) +``` + +Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`: +```html +<script src="require.js" data-main="app/main-built"></script> +``` + +Uma incrível e detalhada visão geral [de build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponível no repositório do GitHub. + +### Tópicos não abordados nesse tutorial +* [Plugins de carregamento / transforms](http://requirejs.org/docs/plugins.html) +* [CommonJS style carregamento e exportação](http://requirejs.org/docs/commonjs.html) +* [Configuração avançada](http://requirejs.org/docs/api.html#config) +* [Shim configuration (carregando módulos sem AMD)](http://requirejs.org/docs/api.html#config-shim) +* [Carregando e otimizando CSS com require.js](http://requirejs.org/docs/optimization.html#onecss) +* [Usando almond.js para builds](https://github.com/jrburke/almond) + +### Outras leituras: + +* [Especificação oficial](https://github.com/amdjs/amdjs-api/wiki/AMD) +* [Por quê AMD?](http://requirejs.org/docs/whyamd.html) +* [Universal Module Definition](https://github.com/umdjs/umd) + +### Implementações: + +* [require.js](http://requirejs.org) +* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/) +* [cujo.js](http://cujojs.com/) +* [curl.js](https://github.com/cujojs/curl) +* [lsjs](https://github.com/zazl/lsjs) +* [mmd](https://github.com/alexlawrence/mmd) diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown new file mode 100644 index 00000000..b12c0693 --- /dev/null +++ b/pt-br/asciidoc-pt.html.markdown @@ -0,0 +1,125 @@ +--- +language: asciidoc +contributors: + - ["Ryan Mavilia", "http://unoriginality.rocks/"] +translators: + - ["David Lima", "https://github.com/davelima"] +lang: pt-br +filename: asciidoc-pt.md +--- + +AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser +usada para qualquer coisa, de livros até blogs. Criada em 2002 por +Stuart Rackham, a linguagem é simples mas facilita muito a customização. + +Cabeçalho do documento + +Cabeçalhos são opcionais e não podem conter linhas em branco. +Devem estar separados do conteúdo com pelo menos uma linha em branco. + +Apenas Título + +``` += Título do documento + +Primeira sentência do documento. +``` + +Título e Autor + +``` += Título do Documento +Nome Sobrenome <nome.sobrenome@learnxinyminutes.com> + +Início do documento. +``` + +Múltiplos Autores + +``` += Título do Documento +John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com> + +Início do documento com múltiplos autores. +``` + +Linhas de revisão (requer uma linha de autor) + +``` += Documento V1 +Potato Man <chip@crunchy.com> +v1.0, 2016-01-13 + +Este artigo sobre batatas será divertido. +``` + +Parágrafos + +``` +Você não precisa fazer nada especial para criar um parágrafo. + +Adicione uma linha em branco entre os parágrafos para separá-los. + +Para criar uma linha em branco adicione um + +e você terá uma quebra de linha! +``` + +Formatando texto + +``` +_underscore é itálico_ +*asterisco é negrito* +*_você pode combinar efeitos_* +`use crase para fonte monoespaçada` +`*fonte monoespaçada em negrito*` +``` + +Título de seções + +``` += Nível 0 (Use apenas no cabeçalho do documento) + +== Nível 1 <h2> + +=== Nível 2 <h3> + +==== Nível 3 <h4> + +===== Nível 4 <h5> + +``` + +Listas + +Para criar uma lista com marcadores use asteriscos. + +``` +* foo +* bar +* baz +``` + +Para criar uma lista numerada use pontos. + +``` +. item 1 +. item 2 +. item 3 +``` + +Você pode criar listas dentro de listas adicionando +asteriscos ou pontos extras em até 5 níveis. + +``` +* foo 1 +** foo 2 +*** foo 3 +**** foo 4 +***** foo 5 + +. foo 1 +.. foo 2 +... foo 3 +.... foo 4 +..... foo 5 +``` diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown new file mode 100644 index 00000000..aecc2194 --- /dev/null +++ b/pt-br/asymptotic-notation-pt.html.markdown @@ -0,0 +1,159 @@ +--- +category: Algorithms & Data Structures +name: Asymptotic Notation +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] +translators: + - ["João Farias", "https://github.com/JoaoGFarias"] +lang: pt-br +--- + +# Notação Assintótica + +## O que é? + +Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução + de um algoritmo através da indentificação de seu comportamento com o + crescimento da entrada oferecida. Isso também é conhecido como taxa de + crescimento do algoritmo. O algoritmo de repente torna-se lento quando o + tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução + rápido mesmo com aumento da entrada? Notação Assintótica nos dá a habilidade de + responder estas questões. + +## Quais são as alternativas para responder a estas questões? + +Um modo seria contar o número de operações primitivas com diferentes tamanhos de + entrada. Apesar desta ser uma solução válida, o trabalho que ela requer, mesmo para algoritmos simples, não a justifica. + + Outro modo é fisicamente medir a quantidade de tempo que um algoritmo requer + para terminar com diferentes tamanhos de entrada. Entretanto, a precisão e + relatividade (tempo obtido seria relativo apenas à máquina onde ocorreu a + execução) deste método está limitado a variáveis de ambiente, como hardware, + poder de processamento, etc. + +## Tipos de Notação Assintótica + +Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo + a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função + *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então, + para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução + *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução +, a coordernada X representa o tamanho da entrada e os pontos representam o tempo +de execução para dado tamanho de entrada. + +Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias +maneiras. Você pode representar um algoritmo nas formas de Melhor Caso, Pior Caso +ou Caso Médio. +A maneira mais comum de analisar um algoritmo é pelo Pior Caso. Você tipicamente +não avalia o melhor caso, porque essas condições não são atingidas com frequência. +Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição +de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas +uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá +que percorrer a árvore de forma apropriada, o que pode causar a analise de um +ramo inteiro. +Este é o pior caso, e isto é o que você está se preparando. + +### Tipos de funções, limites e simplificação + +``` +Função Logarítmica - log n +Função Linear - an + b +Função Quadrática - an^2 + bn + c +Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma constante +Função Exponencial - a^n, onde a é alguma constante +``` +Estas são as funções básicas de crescimento usadas em várias notações. A lista + começa com a de crescimento mais lento (logarítima, a de execução mais rápida) +e segue para a de crescimento mais rápido (exponencial, de execução mais lenta). +Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais +rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear. + +Uma nota extremamente importante para notações é tentar usar os termos mais simples. +Isto significa descartar constantes e termos de ordem mais baixa, pois quando o +tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem +mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma +constante muito grande, 2^9001, a simplificação não afeterá sua notação. + +Já que queremos as formas mais simples, mudemos nossa tabela um pouco... + +``` +Função Logarítmica - log n +Função Linear - n +Função Quadrática - n^2 +Função Polinomial - n^z, onde *z* é uma constante +Função Exponencial - a^n, onde *a* é uma constante +``` + +### Big-O + +Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos +*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade +arbritário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para +quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada +n (n > 0). + + +*Exemplo 1* + +``` +f(n) = 3log n + 100 +g(n) = log n +``` + +`f(n)` é O(g(n))? + +`3 log n + 100` é O(log n)? + +Vejamos a definição de Big-O: + +``` +3log n + 100 <= c * log n +``` + +Há alguma constante c que satisfaça a definição para todo n? + +``` +3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1) +``` + +Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`. + +*Exemplo 2* + +``` +f(n) = 3*n^2 +g(n) = n +``` + +`f(n)` é O(g(n))? + +`3 * n^2` é O(n)? +Vejamos a definição de Big-O: + +``` +3 * n^2 <= c * n +``` + +Há alguma constante c que satisfaça a definição para todo n? + +Não, não há. `f(n)` não é O(g(n)). + +### Big-Omega +Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor caso. + +`f(n)`é Ω(g(n)), se para qualquer constante real c (c > 0), `f(n)` é >= `c g(n)` para todo tamanho de entrada n (n > 0). + +Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos. + +### Notas Finais +É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve. + +## Livros + +* [Algorithms](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X) +* [Algorithm Design](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651) + +## Artigos Online + +* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf) +* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation) diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown new file mode 100644 index 00000000..75b73abe --- /dev/null +++ b/pt-br/awk-pt.html.markdown @@ -0,0 +1,376 @@ +--- +language: awk +filename: learnawk-pt.awk +contributors: + - ["Marshall Mason", "http://github.com/marshallmason"] +translators: + - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"] +lang: pt-br + +--- + +AWK é uma ferramenta padrão em todos os sistemas UNIX compatíveis com POSIX. É +como um Perl despojado, perfeito para tarefas de processamento de texto e +outras tarefas de script. Possui uma sintaxe C-like, mas sem ponto e vírgula, +gerenciamento manual de memória, ou tipagem estática. Destaca-se no +processamento de texto. Você pode chamá-lo a partir de um shell-script, ou você +pode usá-lo como uma linguagem de script autônomo. + +Por que usar AWK ao invés de Perl? Principalmente porque AWK faz parte do UNIX. +Você pode sempre contar com ele, enquanto o futuro do Perl é indefinido. AWK é +também mais fácil de ler que Perl. Para scripts simples de processamento de +texto, particularmente aqueles que leem arquivos linha por linha e fatiam texto +por delimitadores, AWK é provavelmente a ferramenta certa para a tarefa. + +```awk +#!/usr/bin/awk -f + +# Comentários são assim + +# Programas AWK consistem de uma coleção de padrões e ações. O mais +# importante padrão é chamado BEGIN. Ações estão dentro de blocos +# entre chaves. + +BEGIN { + + # O bloco BEGIN será executado no começo do programa. É onde você coloca + # todo código que prepara a execução, antes que você processe qualquer + # arquivo de texto. Se você não tem arquivos de texto, então pense no + # BEGIN como o ponto principal de entrada. + + # Variáveis são globais. Simplesmente atribua valores ou as use, sem + # necessidade de declarar. + + # Operadores são como em C e similares + a = count + 1 + b = count - 1 + c = count * 1 + d = count / 1 # divisão inteira + e = count % 1 # módulo + f = count ^ 1 # exponenciação + + a += 1 + b -= 1 + c *= 1 + d /= 1 + e %= 1 + f ^= 1 + + # Incrementando e decrementando por um + a++ + b-- + + # Como um operador pré-fixado, retorna o valor incrementado + ++a + --b + + # Perceba, não há pontuação, como ponto-e-vírgula, ao final das declarações + + # Declarações de controle + if (count == 0) + print "Começando com count em 0" + else + print "Como é que é?" + + # Ou você pode usar o operador ternário + print (count == 0) ? "Começando com count em 0" : "Como é que é?" + + # Blocos multilinhas devem usar chaves + while (a < 10) { + print "Concatenação de texto é feita" " com uma série" " de" + " textos separados por espaço" + print a + + a++ + } + + for (i = 0; i < 10; i++) + print "Uma boa opção para um loop de uma linha" + + # Quanto a comparações, eis os padrões: + a < b # Menor que + a <= b # Menor ou igual a + a != b # Não igual + a == b # Igual + a > b # Maior que + a >= b # Maior ou igual a + + # Bem como operadores lógicos + a && b # E + a || b # OU (inclusivo) + + # Em adição, há o utilíssimo operador para expressões regulares + if ("foo" ~ "^fo+$") + print "Fooey!" + if ("boo" !~ "^fo+$") + print "Boo!" + + # Matrizes + arr[0] = "foo" + arr[1] = "bar" + # Infelizmente, não há outra forma para inicializar uma matriz. Apenas + # coloque cada valor em uma linha, como mostrado acima. + + # Você também pode ter matrizes associativas + assoc["foo"] = "bar" + assoc["bar"] = "baz" + + # E matrizes multidimensionais, com algumas limitações que não mencionarei + multidim[0,0] = "foo" + multidim[0,1] = "bar" + multidim[1,0] = "baz" + multidim[1,1] = "boo" + + # Você pode testar a pertinência de um elemento em uma matriz + if ("foo" in assoc) + print "Fooey!" + + # Você pode também usar o operador 'in' para percorrer as chaves de uma + # matriz associativa + for (key in assoc) + print assoc[key] + + # Os argumentos da linha de comando estão em uma matriz especial ARGV + for (argnum in ARGV) + print ARGV[argnum] + + # Você pode remover elementos de uma matriz + # Isso é muito útil para prevenir que o AWK assuma que os argumentos são + # arquivo para ele processar + delete ARGV[1] + + # A quantidade de argumentos passados está na variável ARGC + print ARGC + + # O AWK tem várias funções nativas. Elas estão separadas em três categorias. + # Demonstrarei cada uma delas logo mais abaixo. + + return_value = arithmetic_functions(a, b, c) + string_functions() + io_functions() +} + +# Eis como você deve definir uma função +function arithmetic_functions(a, b, c, d) { + + # Provavelmente a parte mais irritante do AWK é ele não possuir variáveis + # locais. Tudo é global. Para pequenos scripts, isso não é problema, e + # pode até mesmo ser considerado útil, mas para grandes scripts, isso pode + # ser um problema. + + # Mas há como contornar isso (um hack). Os argumentos de função são locais + # para a função e o AWK permite que você defina mais argumentos de função + # do que ele precise. Então, coloque a variável local na declaração de + # função, como eu fiz acima. Como uma convenção, adicione alguns espaços + # extras para distinguir entre parâmetros de função reais e variáveis + # locais. Neste exemplo, a, b e c são parâmetros reais, enquanto d é + # meramente uma variável local. + + # Agora, serão demonstradas as funções aritméticas + + # Muitas implementações AWK possuem algumas funções trigonométricas padrão + localvar = sin(a) + localvar = cos(a) + localvar = atan2(a, b) # arco-tangente de b / a + + # E conteúdo logarítmico + localvar = exp(a) + localvar = log(a) + + # Raiz quadrada + localvar = sqrt(a) + + # Descartando a parte não inteira de um número em ponto flutuante. + localvar = int(5.34) # localvar => 5 + + # Números aleatórios + srand() # Forneça uma semente como argumento. Por padrão, ele usa a hora atual + localvar = rand() # Número aleatório entre 0 e 1. + + # Aqui mostramos como retornar um valor + return localvar +} + +function string_functions( localvar, arr) { + + # Sendo o AWK uma linguagem para processamento de texto, ele possui + # várias funções para manipulação de texto, muitas das quais + # fortemente dependentes de expressões regulares. + + # Procurar e substituir, primeira instância (sub), ou todas (gsub) + # Ambas retornam o número de instâncias substituídas + localvar = "fooooobar" + sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar" + gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar" + + # Localiza um texto que casa com uma expressão regular + # index() faz a mesma coisa, mas não permite uma expressão regular + match(localvar, "t") # => 4, pois 't' é o quarto carácter + + # Separa por delimitador + split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"] + + # Outras coisas úteis + sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3" + substr("foobar", 2, 3) # => "oob" + substr("foobar", 4) # => "bar" + length("foo") # => 3 + tolower("FOO") # => "foo" + toupper("foo") # => "FOO" +} + +function io_functions( localvar) { + + # Você já viu como imprimir + print "Hello world" + + # Também há o printf + printf("%s %d %d %d\n", "Testing", 1, 2, 3) + + # O AWK não disponibiliza manipuladores de arquivo. Ele irá automaticamente + # manipular um arquivo quando você fizer algo que precise disso. O texto + # que você usou para isso pode ser usado como um manipulador de arquivo, + # para propósitos de E/S. Isso faz ele parecer com um shell script: + + print "foobar" >"/tmp/foobar.txt" + + # Agora a string "/tmp/foobar.txt" é um manipulador de arquivos. Você pode + # fechá-lo: + close("/tmp/foobar.txt") + + # Aqui está como você pode executar alguma coisa no shell + system("echo foobar") # => prints foobar + + # Lê uma linha da entrada padrão e armazena em localvar + getline localvar + + # Lê uma linha de um pipe + "echo foobar" | getline localvar # localvar => "foobar" + close("echo foobar") + + # Lê uma linha de um arquivo e armazena em localvar + getline localvar <"/tmp/foobar.txt" + close("/tmp/foobar.txt") +} + +# Como dito no início, os programas AWK consistem de uma coleção de padrões +# e ações. Você já viu o padrão BEGIN, o mais importante. Outros padrões são +# usados apenas se você estiver processando linhas de arquivos ou a entrada +# padrão. + +# Quando você passa argumentos para o AWK, eles são tratados como nomes de +# arquivos para processar. Todos serão processados, em ordem. Pense nisso como +# um implícito para loop, iterando sobre as linhas nesses arquivos. Esses +# padrões e ações são como instruções de mudança dentro do loop. + +/^fo+bar$/ { + + # Esta ação será executada para cada linha que corresponda à expressão + # regular, / ^ fo + bar $ /, e será ignorada para qualquer linha que não + # corresponda. Vamos apenas imprimir a linha: + + print + + # Opa, sem argumento! Isso ocorre pois print tem um argumento padrão: $0. + # $0 é o nome da linha atual que está sendo processada. Essa variável é + # criada automaticamente para você. + + # Você provavelmente pode adivinhar que existem outras variáveis $. Toda + # linha é implicitamente dividida antes de cada ação ser chamada, como + # o shell faz. E, como o shell, cada campo pode ser acessado com um sinal + # de cifrão + + # Isso irá imprimir o segundo e quarto campos da linha + print $2, $4 + + # O AWK automaticamente define muitas outras variáveis para ajudar você + # a inspecionar processar cada linha. A mais importante delas é NF. + + # Imprime o número de campos da linha atual + print NF + + # Imprime o último campo da linha atual + print $NF +} + +# Todo padrão é na verdade um teste verdadeiro/falso. A expressão regular no +# último padrão também é um teste verdadeiro/falso, mas parte dele estava +# escondido. Se você não informar um texto para testar, AWK assumirá $0, +# a linha que está atualmente sendo processada. Assim, a versão completa +# é a seguinte: + +$0 ~ /^fo+bar$/ { + print "Equivalente ao último padrão" +} + +a > 0 { + # Isso será executado uma vez para cada linha, quando a for positivo +} + +# Você entendeu. Processar arquivos de texto, ler uma linha de cada vez, e +# fazer algo com ela, particularmente dividir com base em um delimitador, é +# tão comum no UNIX que AWK é uma linguagem de script que faz tudo por você, +# sem você precisa perguntar. Tudo o que você precisa fazer é escrever os +# padrões e ações com base no que você espera da entrada, e o que você quer +# fazer com isso. + +# Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK +# é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois +imprimirá a média de idade de todos com esse primeiro nome. Digamos que você +forneça como argumento o nome de um arquivo com esses dados: + +# Bob Jones 32 +# Jane Doe 22 +# Steve Stevens 83 +# Bob Smith 29 +# Bob Barker 72 +# +# Eis o script: + +BEGIN { + + # Primeiro, pergunte o nome do usuário + print "Para qual nome você quer calcular a média de idade?" + + # Pega uma linha da entrada padrão, não dos arquivos indicados na + # linha de comando + getline name <"/dev/stdin" +} + +# Agora, processa cada linha em que o primeiro nome é o nome informado +$1 == name { + + # Dentro desse bloco, nós temos acesso a algumas variáveis uteis, que + # foram pré-carregadas para nós: + # $0 é a linha corrente completa + # $3 é o terceiro campo, que é o que nos interessa aqui + # NF é a quantidade de campos, que deve ser 3 + # NR é o número de registros (linhas) lidas até agora + # FILENAME é o nome do arquivo sendo processado + # FS é o delimitador em uso, que é " " aqui + # ...etc. Há muito mais, documentadas no manual. + + # Mantenha um registro do total e da quantidade de linhas encontradas + sum += $3 + nlines++ +} + +# Outro padrão especial é chamado END. Ele será executado após o processamento +# de todos os arquivos de texto. Ao contrário de BEGIN, ele só será executado +# se você tiver dado a ele dados para processar. Ele será executado depois de +# todos os arquivos terem sido lidos e processados de acordo com as regras e +# ações que você forneceu. O objetivo disso em geral é produzir algum tipo de +# relatório final, ou fazer algo com o agregado dos dados acumulados ao longo +# do script. + +END { + if (nlines) + print "A média da idade para " name " é " sum / nlines +} + +``` +Leituras adicionais (em inglês): + +* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) +* [Awk man page](https://linux.die.net/man/1/awk) +* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU AWK é encontrado na maioria dos sistemas GNU/Linux. diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown new file mode 100644 index 00000000..ae18435a --- /dev/null +++ b/pt-br/bash-pt.html.markdown @@ -0,0 +1,282 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] +translators: + - ["Davidson Mizael", "https://github.com/davidsonmizael"] +filename: LearnBash-pt_br.sh +lang: pt-br +--- + +Tutorial de shell em português + +Bash é o nome do shell do Unix, que também é distribuido como shell do sistema +operacional GNU e como shell padrão para Linux e Mac OS X. Praticamente todos +os exemplos abaixo podem fazer parte de um shell script e pode ser executados +diretamente no shell. + +[Leia mais sobre](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# A primeira linha do script é o shebang, que conta para o sistema como executar +# o script: http://en.wikipedia.org/wiki/Shebang_(Unix) +# Como você já deve ter percebido, comentários começam com #. +# Shebang também é um comentário. + +# Exemplo simples de hello world: +echo Hello World! + +# Cada comando começa com uma nova linha, ou após um ponto virgula: +echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha' + +# A declaração de variáveis é mais ou menos assim +Variavel="Alguma string" + +# Mas não assim: +Variavel = "Alguma string" +# Bash interpretará Variavel como um comando e tentará executar e lhe retornar +# um erro porque o comando não pode ser encontrado. + +# Ou assim: +Variavel= 'Alguma string' +# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar +# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel=' +# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string'). + +# Usando a variável: +echo $Variavel +echo "$Variavel" +echo '$Variavel' +# Quando você usa a variável em si — declarando valor, exportando, etc — você escreve +# seu nome sem o $. Se você quer usar o valor da variável você deve usar o $. +# Note que ' (aspas simples) não expandirão as variáveis! + +# Substituição de strings em variáveis +echo ${Variavel/Alguma/Uma} +# Isso substituirá a primeira ocorrência de "Alguma" por "Uma" + +# Substring de uma variável +Tamanho=7 +echo ${Variavel:0:Tamanho} +# Isso retornará apenas os 7 primeiros caractéres da variável + +# Valor padrão de uma variável +echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"} +# Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0. +# Note que isso apenas retornar o valor padrão e não mudar o valor da variável. + +# Variáveis internas +# Tem algumas variáveis internas bem uteis, como +echo "O ultimo retorno do programa: $?" +echo "PID do script: $$" +echo "Numero de argumentos passados para o script $#" +echo "Todos os argumentos passados para o script $@" +echo "Os argumentos do script em variáveis diferentes: $1, $2..." + +# Lendo o valor do input: +echo "Qual o seu nome?" +read Nome # Note que nós não precisamos declarar a variável +echo Ola, $Nome + +# Nós temos a estrutura if normal: +# use 'man test' para mais infomações para as condicionais +if [ $Nome -ne $USER ] +then + echo "Seu nome não é o seu username" +else + echo "Seu nome é seu username" +fi + +# Tem também execução condicional +echo "Sempre executado" || echo "Somente executado se o primeiro falhar" +echo "Sempre executado" && "Só executado se o primeiro NÃO falhar" + +# Para usar && e || com o if, você precisa multiplicar os pares de colchetes +if [ $Nome == "Estevao"] && [ $Idade -eq 15] +then + echo "Isso vai rodar se $Nome é igual Estevao E $Idade é 15." +fi + +fi [ $Nome == "Daniela" ] || [ $Nome = "Jose" ] +then + echo "Isso vai rodar se $Nome é Daniela ou Jose." +fi + +# Expressões são denotadas com o seguinte formato +echo $(( 10 + 5)) + +# Diferentemente das outras linguagens de programação, bash é um shell, então ele +# funciona no diretório atual. Você pode listar os arquivos e diretórios no diretório +# atual com o comando ls: +ls + +#Esse comando tem opções que controlam sua execução +ls -l # Lista todo arquivo e diretorio em linhas separadas + +# Os resultados do comando anterior pode ser passado para outro comando como input. +# O comando grep filtra o input com o padrão passado. É assim que listamos apenas +# os arquivos .txt no diretório atual: +ls -l | grep "\.txt" + +# Você pode redirecionar o comando de input e output (stdin, stdout e stderr). +# Lê o stdin até ^EOF$ e sobrescreve hello.py com as linhas entre "EOF": +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ imprt print_function +import sys +print("#stdout", file=sys.stdout) +print("stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Rode hello.py com várias instruções stdin, stdout e stderr: +python hello.py < "input.in" +python hello.py > "ouput.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# O erro no output sobrescreverá o arquivo se existir, +# se ao invés disso você quiser complementar, use ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Sobrescreve output.out, complemente para error.err e conta as linhas +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +#Roda um comando e imprime o desencriptador (e.g. /dev/fd/123) +# veja: man fd +echo <(echo "#helloworld") + +# Sobrescreve ouput.out com "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out > /dev/null + +# Limpa os arquivos temporários detalhando quais foram deletados (use '-i' para confirmar exclusão) +rm -v output.out error.err output-and-error.log + +# Comando podem ser substituídos por outros comandos usando $( ): +# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual +echo "Existem $(ls | wc -l) itens aqui." + +# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se +# preferência ao uso do $( ) +echo "Existem `ls | wc -l` itens aqui." + +# Bash usa o comando case que funciona de uma maneira similar ao switch de Java e C++: +case "$Variavel" in + # Lista de parametros para condições que você quer encontrar + 0) echo "Isso é um Zero.";; + 1) echo "Isso é um Um.";; + *) echo "Isso não é null.";; +esac + +# loops for iteragem para quantos argumentos passados: +# O conteudo de $Variavel é exibido três vezes. +for Variavel in {1..3} +do + echo "$Variavel" +done + +# Ou use o loop da "maneira tradicional": +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Eles também podem ser usados em arquivos... +# Isso irá rodar o comando 'cat' em arquivo1 e arquivo2 +for Variavel in arquivo1 arquivo2 +do + cat "$Variavel" +done + +# ...ou o output de um comando +# Isso irá usar cat no output do ls. +for Output in $(ls) +do + cat "$Output" +done + +# loop while: +while [ true ] +do + echo "corpo do loop aqui..." + break +done + +# Você também pode usar funções +# Definição: +function foo() { + echo "Argumentos funcionam bem assim como os dos scripts: $@" + echo "E: $1 $2..." + echo "Isso é uma função" + return 0 +} + +# ou simplesmente +bar () { + echo "Outro jeito de declarar funções!" + return 0 +} + +# Chamando sua função +foo "Meu nome é" $Nome + +# Existe um monte de comandos úteis que você deveria aprender: +# exibe as 10 ultimas linhas de arquivo.txt +tail -n 10 arquivo.txt +# exibe as primeiras 10 linhas de arquivo.txt +head -n 10 arquivo.txt +# ordena as linhas de arquivo.txt +sort arquivo.txt +# reporta ou omite as linhas repetidas, com -d você as reporta +uniq -d arquivo.txt +# exibe apenas a primeira coluna após o caráctere ',' +cut -d ',' -f 1 arquivo.txt +# substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex) +sed -i 's/okay/legal/g' file.txt +# exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex +# O exemplo exibe linhas que começam com "foo" e terminam com "bar" +grep "^foo.*bar$" arquivo.txt +# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex +grep -c "^foo.*bar$" arquivo.txt +# se você quer literalmente procurar por uma string, +# e não pelo regex, use fgrep (ou grep -F) +fgrep "^foo.*bar$" arquivo.txt + + +# Leia a documentação interna do shell Bash com o comando interno 'help': +help +help help +help for +help return +help source +help . + +# Leia a página principal da documentação com man +apropos bash +man 1 bash +man bash + +# Leia a documentação de informação com info (? para ajuda) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +#Leia a documentação informativa do Bash: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/bf-pt.html.markdown index c7ce55ee..52a5269e 100644 --- a/pt-br/brainfuck-pt.html.markdown +++ b/pt-br/bf-pt.html.markdown @@ -1,14 +1,16 @@ --- -language: brainfuck +language: bf +filename: learnbf-pt.bf contributors: - ["Prajit Ramachandran", "http://prajitr.github.io/"] - ["Mathias Bynens", "http://mathiasbynens.be/"] translators: - ["Suzane Sant Ana", "http://github.com/suuuzi"] + - ["Rodrigo Muniz", "http://github.com/muniz95"] lang: pt-br --- -Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de +Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de programação Turing-completa extremamente simples com apenas 8 comandos. ``` @@ -18,7 +20,7 @@ Brainfuck é representado por um vetor com 30 000 células inicializadas em zero e um ponteiro de dados que aponta para a célula atual. Existem 8 comandos: -+ : Incrementa o vaor da célula atual em 1. ++ : Incrementa o valor da célula atual em 1. - : Decrementa o valor da célula atual em 1. > : Move o ponteiro de dados para a célula seguinte (célula à direita). < : Move o ponteiro de dados para a célula anterior (célula à esquerda). diff --git a/pt-br/binary-search-pt.html.markdown b/pt-br/binary-search-pt.html.markdown new file mode 100644 index 00000000..d3060506 --- /dev/null +++ b/pt-br/binary-search-pt.html.markdown @@ -0,0 +1,77 @@ +--- +category: Algorithms & Data Structures +name: Binary Search +contributors: + - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +--- + +# Busca Binária + +## Por Que Busca Binária? + +Operações de busca são um dos principais problemas na Ciência da Computação. +Atualmente existem mais de 1 trilhão de buscas por ano, e nós precisamos de +algoritmos que possam realizá-las rapidamente. Busca binária é um dos algoritmos +fundamentais em ciência da computação. A fim de explorá-la, iremos primeiro +construir um conhecimento teórico, e então utilizá-lo para implementar o +algoritmo apropriadamente. + +## Introdução + +Uma abordagem simples para implementar uma busca é realizar uma busca linear, +mas algoritmos nessa abordagem levam muito tempo, o qual cresce linearmente de +acordo com a quantidade ou número de dados. Por exemplo, iniciando do elemento +mais a esquerda de arr[] e um a um comparar x com cada elemento de arr[], se x +coincide com um elemento, retornar seu índice. Se x não coincide com nenhum dos +elementos, retornar -1. + +``` +Busca Linear: O (n) Tempo Linear + +Busca Binária: O ( log(n) ) Tempo Logarítmico + +``` +``` +def busca(arr, x): + + for i in range(len(arr)): + + if arr[i] == x: + return i + + return -1 + +``` +## Algoritmo de Busca Binária + +O pré-requisito básico para que uma busca binária funcione é que os dados que se +desejam buscar devem estar ordenados (em qualquer ordem). + +### Pseudocódigo + +``` +A ideia da busca binária é usar a informação de que o array está ordenado e +reduzir a complexidade de tempo para O(Log n). Nós basicamente ignoramos metade +dos elementos após uma comparação. + +1) Compare x com o elemento do meio. +2) Se x coincide com o elemento do meio, retorne o índice do meio. +3) Senão Se x é maior que o elemento do meio, então x só pode estar no lado +direito do elemento do meio. Portanto nós pulamos para a metade direita. +4) Senão (x é menor) pulamos para a metade esquerda. + +Essa é a ideia da implementação recursiva da busca binária. + +``` + +### Considerações Finais + +Existem outras formas de busca binária que são muito úteis. + +## Recursos Online + +* [GeeksforGeeks](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/) +* [Topcoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/) diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 243627cb..cd4adde7 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"] @@ -9,8 +9,7 @@ translators: lang: pt-br --- -C++ é uma linguagem de programação de sistemas que, -C++ is a systems programming language that, +C++ é uma linguagem de programação de sistemas que, [de acordo com seu inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), foi concebida para @@ -19,10 +18,10 @@ foi concebida para - suportar programação orientada a objetos - suportar programação genérica -Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais -recentes, C++ é amplamente utilizado porque compila para instruções nativas que -podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os -genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade +Embora sua sintaxe possa ser mais difícil ou complexa do que as linguagens mais +recentes, C++ é amplamente utilizada porque compila para instruções nativas que +podem ser executadas diretamente pelo processador e oferece um controle rígido sobre o hardware (como C), enquanto oferece recursos de alto nível, como os +genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade faz C++ uma das linguagens de programação mais utilizadas. ```c++ @@ -34,17 +33,17 @@ faz C++ uma das linguagens de programação mais utilizadas. // declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia // em algumas das seguintes maneiras: -// A função main() em C++ deve retornar um int, embora void main() é aceita +// A função main() em C++ deve retornar um int, embora void main() é aceita // pela maioria dos compiladores (gcc, bumbum, etc.) // Este valor serve como o status de saída do programa. // Veja http://en.wikipedia.org/wiki/Exit_status para mais informações. int main(int argc, char** argv) { - // Argumentos de linha de comando são passados em pelo argc e argv da mesma + // Argumentos de linha de comando são passados para argc e argv da mesma // forma que eles estão em C. // argc indica o número de argumentos, - // e argv é um array de strings, feito C (char*) representado os argumentos + // e argv é um array de strings, feito C (char*) representando os argumentos // O primeiro argumento é o nome pelo qual o programa foi chamado. // argc e argv pode ser omitido se você não se importa com argumentos, // dando a assinatura da função de int main() @@ -106,7 +105,7 @@ int main() // Parâmetros padrão de função ///////////////////////////// -// Você pode fornecer argumentos padrões para uma função se eles não são +// Você pode fornecer argumentos padrões para uma função se eles não são // fornecidos pelo chamador. void doSomethingWithInts(int a = 1, int b = 4) @@ -158,7 +157,7 @@ void foo() int main() { - // Assuma que tudo é do namespace "Second" a menos que especificado de + // Assuma que tudo é do namespace "Second" a menos que especificado de // outra forma. using namespace Second; @@ -223,7 +222,7 @@ cout << myString; // "Hello Dog" // Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de // ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo. -// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário +// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário // para _dereferencing_ e & (endereço de) não é usado para atribuição. using namespace std; @@ -259,7 +258,7 @@ class Dog { std::string name; int weight; -// Todos os membros a seguir este são públicos até que "private:" ou +// Todos os membros a seguir este são públicos até que "private:" ou // "protected:" é encontrado. public: @@ -275,13 +274,13 @@ public: void setWeight(int dogsWeight); - // Funções que não modificam o estado do objecto devem ser marcadas como + // Funções que não modificam o estado do objeto devem ser marcadas como // const. Isso permite que você chamá-los se for dada uma referência const // para o objeto. Além disso, observe as funções devem ser explicitamente - // declarados como _virtual_, a fim de ser substituídas em classes - // derivadas. As funções não são virtuais por padrão por razões de + // declarados como _virtual_, a fim de ser substituídas em classes + // derivadas. As funções não são virtuais por padrão por razões de // performance. - + virtual void print() const; // As funções também podem ser definidas no interior do corpo da classe. @@ -292,7 +291,7 @@ public: // Estes são chamados quando um objeto é excluído ou fica fora do escopo. // Isto permite paradigmas poderosos, como RAII // (veja abaixo) - // Destruidores devem ser virtual para permitir que as classes de ser + // Destruidores devem ser virtual para permitir que as classes de ser // derivada desta. virtual ~Dog(); @@ -305,7 +304,7 @@ void Dog::Dog() } // Objetos (como strings) devem ser passados por referência -// se você está modificando-os ou referência const se você não é. +// se você pretende modificá-los, ou com const caso contrário. void Dog::setName(const std::string& dogsName) { name = dogsName; @@ -324,7 +323,7 @@ void Dog::print() const void Dog::~Dog() { - cout << "Goodbye " << name << "\n"; + std::cout << "Goodbye " << name << "\n"; } int main() { @@ -344,8 +343,8 @@ class OwnedDog : public Dog { // Substituir o comportamento da função de impressão de todas OwnedDogs. // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping - // Para uma introdução mais geral, se você não estiver familiarizado com o - // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se + // Para uma introdução mais geral, se você não estiver familiarizado com o + // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se // na verdade você está substituindo o método em uma classe base. void print() const override; @@ -372,8 +371,8 @@ void OwnedDog::print() const // Inicialização e Sobrecarga de Operadores ////////////////////////////////////////// -// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como -// +, -, *, /, etc. Isto é feito através da definição de uma função que é +// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como +// +, -, *, /, etc. Isto é feito através da definição de uma função que é // chamado sempre que o operador é usado. #include <iostream> @@ -439,7 +438,7 @@ int main () { // mas qualquer tipo pode ser jogado como uma exceção #include <exception> -// Todas as exceções lançadas dentro do bloco try pode ser capturado por +// Todas as exceções lançadas dentro do bloco try pode ser capturado por // manipuladores de captura subseqüentes try { // Não aloca exceções no heap usando _new_. @@ -461,7 +460,7 @@ catch (const std::exception& ex) /////// // RAII significa alocação de recursos é de inicialização. -// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o +// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o // conceito simples que um construtor para um objeto adquire recursos daquele // objeto e o destruidor liberá-los. @@ -480,18 +479,18 @@ void doSomethingWithAFile(const char* filename) } // Infelizmente, as coisas são levemente complicadas para tratamento de erros. -// Suponha que fopen pode falhar, e que doSomethingWithTheFile e -// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As -// exceções são a forma preferida de lidar com o fracasso, mas alguns -// programadores, especialmente aqueles com um conhecimento em C, discordam -// sobre a utilidade de exceções). Agora temos que verificar cada chamada para +// Suponha que fopen pode falhar, e que doSomethingWithTheFile e +// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As +// exceções são a forma preferida de lidar com o fracasso, mas alguns +// programadores, especialmente aqueles com um conhecimento em C, discordam +// sobre a utilidade de exceções). Agora temos que verificar cada chamada para // o fracasso e fechar o identificador de arquivo se ocorreu um problema. bool doSomethingWithAFile(const char* filename) { FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha. - reuturn false; // Relate o fracasso para o chamador. + return false; // Relate o fracasso para o chamador. // Suponha cada função retorne false, se falhar if (!doSomethingWithTheFile(fh)) { @@ -512,7 +511,7 @@ bool doSomethingWithAFile(const char* filename) { FILE* fh = fopen(filename, "r"); if (fh == nullptr) - reuturn false; + return false; if (!doSomethingWithTheFile(fh)) goto failure; @@ -582,10 +581,35 @@ void doSomethingWithAFile(const std::string& filename) // vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante // tudo é automaticamente destruído quando eles saem de escopo // - Mutex usa lock_guard e unique_lock + + +///////////////////// +// Templates +///////////////////// + +// Templates em C++ são utilizados para programação genérica, ou seja, +// utilizar um tipo de dado genérico onde possa suportar qualquer entrada. +// Por exemplo, invés de criar uma função que apenas some inteiros, você +// poderá fazer uma função que soma double, float e inteiros em uma única +// definição para reutilizar código. + +// Definimos um função que utiliza um "typename" +template<class T> +T soma(T a, T b) { + return A + B; +} + +// E agora para executá-la +int i=5, j=6, k; +double f=2.0, g=0.5, h; +k=sum<int>(i,j); +h=sum<double>(f,g); + +// Deste modo, não precisamos fazer overload nas funções! (: ``` Leitura Adicional: -Uma referência atualizada da linguagem pode ser encontrada em +Uma referência atualizada da linguagem pode ser encontrada em <http://cppreference.com/w/cpp> -Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
\ No newline at end of file +Uma fonte adicional pode ser encontrada em <http://cplusplus.com> diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index 451df4f3..0dca7ab0 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -6,29 +6,31 @@ contributors: - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] translators: - ["João Farias", "https://github.com/JoaoGFarias"] + - ["Elton Viana", "https://github.com/eltonvs"] + - ["Cássio Böck", "https://github.com/cassiobsilva"] lang: pt-br filename: c-pt.el --- Ah, C. Ainda é **a** linguagem de computação de alta performance. -C é a liguangem de mais baixo nível que a maioria dos programadores -irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique -antento que este manual de gerenciamento de memória e C vai levanter-te -tão longe quanto você precisa. +C é a linguagem de mais baixo nível que a maioria dos programadores +utilizarão, e isso dá a ela uma grande velocidade bruta. Apenas fique +atento se este manual de gerenciamento de memória e C vai te levar +tão longe quanto precisa. ```c // Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99 /* -Comentários de multiplas linhas se parecem com este. +Comentários de múltiplas linhas se parecem com este. Funcionam no C89 também. */ // Constantes: #define <palavra-chave> -#definie DAY_IN_YEAR 365 +#define DAY_IN_YEAR 365 -//enumarações também são modos de definir constantes. +//enumerações também são modos de definir constantes. enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB}; // SEG recebe 2 automaticamente, TER recebe 3, etc. @@ -53,13 +55,13 @@ int soma_dois_ints(int x1, int x2); // protótipo de função // O ponto de entrada do teu programa é uma função // chamada main, com tipo de retorno inteiro int main() { - // Usa-se printf para escrever na tela, + // Usa-se printf para escrever na tela, // para "saída formatada" // %d é um inteiro, \n é uma nova linha printf("%d\n", 0); // => Imprime 0 // Todos as declarações devem acabar com // ponto e vírgula - + /////////////////////////////////////// // Tipos /////////////////////////////////////// @@ -77,7 +79,7 @@ int main() { // longs tem entre 4 e 8 bytes; longs long tem garantia // de ter pelo menos 64 bits long x_long = 0; - long long x_long_long = 0; + long long x_long_long = 0; // floats são normalmente números de ponto flutuante // com 32 bits @@ -92,7 +94,7 @@ int main() { unsigned int ux_int; unsigned long long ux_long_long; - // caracteres dentro de aspas simples são inteiros + // caracteres dentro de aspas simples são inteiros // no conjunto de caracteres da máquina. '0' // => 48 na tabela ASCII. 'A' // => 65 na tabela ASCII. @@ -103,7 +105,7 @@ int main() { // Se o argumento do operador `sizeof` é uma expressão, então seus argumentos // não são avaliados (exceto em VLAs (veja abaixo)). - // O valor devolve, neste caso, é uma constante de tempo de compilação. + // O valor devolve, neste caso, é uma constante de tempo de compilação. int a = 1; // size_t é um inteiro sem sinal com pelo menos 2 bytes que representa // o tamanho de um objeto. @@ -119,7 +121,7 @@ int main() { // Você pode inicializar um array com 0 desta forma: char meu_array[20] = {0}; - // Indexar um array é semelhante a outras linguages + // Indexar um array é semelhante a outras linguagens // Melhor dizendo, outras linguagens são semelhantes a C meu_array[0]; // => 0 @@ -128,7 +130,7 @@ int main() { printf("%d\n", meu_array[1]); // => 2 // No C99 (e como uma features opcional em C11), arrays de tamanho variável - // VLA (do inglês), podem ser declarados também. O tamanho destes arrays + // VLA (do inglês), podem ser declarados também. O tamanho destes arrays // não precisam ser uma constante de tempo de compilação: printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho char buf[0x100]; @@ -139,22 +141,22 @@ int main() { int var_length_array[size]; // declara o VLA printf("sizeof array = %zu\n", sizeof var_length_array); - //Uma possível saída para esse programa seria: - // > Entre o tamanho do array:: 10 + // Uma possível saída para esse programa seria: + // > Entre o tamanho do array: 10 // > sizeof array = 40 - // String são apenas arrays de caracteres terminados por um - // byte NUL (0x00), representado em string pelo caracter especial '\0'. - // (Não precisamos incluir o byte NUL em literais de string; o compilador + // String são apenas arrays de caracteres terminados por um + // byte nulo (0x00), representado em string pelo caracter especial '\0'. + // (Não precisamos incluir o byte nulo em literais de string; o compilador // o insere ao final do array para nós.) - char uma_string[20] = "Isto é uma string"; + char uma_string[20] = "Isto é uma string"; // Observe que 'é' não está na tabela ASCII // A string vai ser salva, mas a saída vai ser estranha - // Porém, comentários podem conter acentos + // Porém, comentários podem conter acentos printf("%s\n", uma_string); // %s formata a string - printf("%d\n", uma_string[16]); // => 0 - // i.e., byte #17 é 0 (assim como 18, 19, e 20) + printf("%d\n", uma_string[17]); // => 0 + // i.e., byte #18 é 0 (assim como o 19°, 20°, 21°...) // Se temos caracteres entre aspas simples, temos um caracter literal. // Seu tipo é `int`, *não* `char` (por razões históricas). @@ -174,13 +176,13 @@ int main() { /////////////////////////////////////// // Atalho para multiplas declarações: - int i1 = 1, i2 = 2; + int i1 = 1, i2 = 2; float f1 = 1.0, f2 = 2.0; int a, b, c; a = b = c = 0; - // Aritimética é óbvia + // Aritmética é óbvia i1 + i2; // => 3 i2 - i1; // => 1 i2 * i1; // => 2 @@ -189,7 +191,7 @@ int main() { f1 / f2; // => 0.5, mais ou menos epsilon // Números e cálculos de ponto flutuante não são exatos - // Modulo também existe + // Módulo também existe 11 % 3; // => 2 // Operadores de comparação provavelmente são familiares, @@ -205,7 +207,7 @@ int main() { 2 <= 2; // => 1 2 >= 2; // => 1 - // C não é Python - comparações não se encadeam. + // C não é Python - comparações não se encadeiam. int a = 1; // Errado: int entre_0_e_2 = 0 < a < 2; @@ -220,17 +222,17 @@ int main() { 0 || 1; // => 1 (Ou lógico) 0 || 0; // => 0 - //Expressão condicional ( ? : ) + //Expressão condicional ternária ( ? : ) int a = 5; int b = 10; int z; - z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." + z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." //Operadores de incremento e decremento: char *s = "iLoveC"; int j = 0; s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j. - j = 0; + j = 0; s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s. // o mesmo com j-- e --j @@ -290,6 +292,8 @@ int main() { for (i = 0; i <= 5; i++) { ; // Use ponto e vírgula para agir como um corpo (declaração nula) } + // Ou + for (i = 0; i <= 5; i++); // Criando branchs com escolhas múltiplas: switch() switch (alguma_expressao_integral) { @@ -305,7 +309,7 @@ int main() { exit(-1); break; } - + /////////////////////////////////////// // Cast de tipos @@ -324,8 +328,8 @@ int main() { // Tipos irão ter overflow sem aviso printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits) - // Para determinar o valor máximo de um `char`, de um `signed char` e de - // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX + // Para determinar o valor máximo de um `char`, de um `signed char` e de + // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX // e UCHAR_MAX de <limits.h> // Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa. @@ -338,7 +342,7 @@ int main() { /////////////////////////////////////// // Um ponteiro é uma variável declarada para armazenar um endereço de memória. - // Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você + // Sua declaração irá também dizer o tipo de dados para o qual ela aponta. Você // Pode usar o endereço de memória de suas variáveis, então, brincar com eles. int x = 0; @@ -360,13 +364,13 @@ int main() { printf("%d\n", *px); // => Imprime 0, o valor de x // Você também pode mudar o valor que o ponteiro está apontando. - // Teremo que cercar a de-referência entre parenteses, pois + // Temos que cercar a de-referência entre parênteses, pois // ++ tem uma precedência maior que *. (*px)++; // Incrementa o valor que px está apontando por 1 printf("%d\n", *px); // => Imprime 1 printf("%d\n", x); // => Imprime 1 - // Arrays são um boa maneira de alocar um bloco contínuo de memória + // Arrays são uma boa maneira de alocar um bloco contínuo de memória int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho int xx; for (xx = 0; xx < 20; xx++) { @@ -376,7 +380,7 @@ int main() { // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array int* x_ptr = x_array; // x_ptr agora aponta para o primeiro elemento do array (o inteiro 20). - // Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos. + // Isto funciona porque arrays são apenas ponteiros para seus primeiros elementos. // Por exemplo, quando um array é passado para uma função ou é atribuído a um // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro. // Exceções: quando o array é o argumento de um operador `&` (endereço-de): @@ -392,7 +396,7 @@ int main() { printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8" // Ponteiros podem ser incrementados ou decrementados baseado no seu tipo - // (isto é chamado aritimética de ponteiros + // (isto é chamado aritmética de ponteiros printf("%d\n", *(x_ptr + 1)); // => Imprime 19 printf("%d\n", x_array[1]); // => Imprime 19 @@ -410,9 +414,9 @@ int main() { // "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido" printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa. - // Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo, + // Quando se termina de usar um bloco de memória alocado, você pode liberá-lo, // ou ninguém mais será capaz de usá-lo até o fim da execução - // (Isto cham-se "memory leak"): + // (Isto chama-se "memory leak"): free(my_ptr); // Strings são arrays de char, mas elas geralmente são representadas @@ -534,7 +538,7 @@ int area(retan r) return r.largura * r.altura; } -// Se você tiver structus grande, você pode passá-las "por ponteiro" +// Se você tiver structus grande, você pode passá-las "por ponteiro" // para evitar cópia de toda a struct: int area(const retan *r) { @@ -551,8 +555,8 @@ conhecidos. Ponteiros para funções são como qualquer outro ponteiro diretamente e passá-las para por toda parte. Entretanto, a sintaxe de definição por ser um pouco confusa. -Exemplo: use str_reverso através de um ponteiro -*/ +Exemplo: use str_reverso através de um ponteiro +*/ void str_reverso_através_ponteiro(char *str_entrada) { // Define uma variável de ponteiro para função, nomeada f. void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo. @@ -572,7 +576,7 @@ typedef void (*minha_função_type)(char *); // Declarando o ponteiro: // ... -// minha_função_type f; +// minha_função_type f; //Caracteres especiais: '\a' // Alerta (sino) @@ -583,7 +587,7 @@ typedef void (*minha_função_type)(char *); '\r' // Retorno de carroça '\b' // Backspace '\0' // Caracter nulo. Geralmente colocado ao final de string em C. - // oi\n\0. \0 é usado por convenção para marcar o fim da string. + // oi\n\0. \0 é usado por convenção para marcar o fim da string. '\\' // Barra invertida '\?' // Interrogação '\'' // Aspas simples @@ -603,7 +607,7 @@ typedef void (*minha_função_type)(char *); "%p" // ponteiro "%x" // hexadecimal "%o" // octal -"%%" // imprime % +"%%" // imprime % /////////////////////////////////////// // Ordem de avaliação @@ -643,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/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown new file mode 100644 index 00000000..d56840e0 --- /dev/null +++ b/pt-br/clojure-macros-pt.html.markdown @@ -0,0 +1,156 @@ +--- +language: clojure +filename: learnclojure-pt.clj +contributors: + - ["Adam Bard", "http://adambard.com/"] +translators: + - ["Raphael Bezerra do Nascimento"] +lang: pt-br +--- + +Como todas as Lisps, a inerente [homoiconicity](https://en.wikipedia.org/wiki/Homoiconic) +do Clojure lhe dá acesso a toda a extensão da linguagem +para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem +às suas necessidades. + +Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas +quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado. + +Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em +[Clojure em Y Minutos](/docs/clojure/). + +```clojure +;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa +;; ser avaliada como codigo Clojure. +;; +;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World") +(defmacro my-first-macro [] + (list reverse "Hello World")) + +;; Inspecione o resultado de uma macro utilizando macroexpand or macroexpand-1. +;; +;; Note que a chamada deve utilizar aspas simples. +(macroexpand '(my-first-macro)) +;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World") + +;; Você pode avaliar o resultad de macroexpand diretamente: +(eval (macroexpand '(my-first-macro))) +; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; mas você deve usar esse mais suscinto, sintax como de função: +(my-first-macro) ; -> (\d \l \o \r \W \space \o \l \l \e \H) + +;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta +;; para criar listas nas suas macros: +(defmacro my-first-quoted-macro [] + '(reverse "Hello World")) + +(macroexpand '(my-first-quoted-macro)) +;; -> (reverse "Hello World") +;; Note que reverse não é mais uma função objeto, mas um simbolo. + +;; Macros podem ter argumentos. +(defmacro inc2 [arg] + (list + 2 arg)) + +(inc2 2) ; -> 4 + +;; Mas se você tentar fazer isso com uma lista entre aspas simples, você vai receber um erro, por que o +;; argumento irá entra aspas simples também. Para contornar isso, Clojure prover uma maneira de utilizar aspas simples +;; em macros: `. Dentro `, você pode usar ~ para chegar ao escopo externo. +(defmacro inc2-quoted [arg] + `(+ 2 ~arg)) + +(inc2-quoted 2) + +;; Você pode usar os argumentos de destruturação habituais. Expandir lista de variaveis usando ~@ +(defmacro unless [arg & body] + `(if (not ~arg) + (do ~@body))) ; Lembrar o do! + +(macroexpand '(unless true (reverse "Hello World"))) +;; -> +;; (if (clojure.core/not true) (do (reverse "Hello World"))) + +;; (unless) avalia e retorna seu corpo, se o primeiro argumento é falso. +;; caso contrario, retorna nil + +(unless true "Hello") ; -> nil +(unless false "Hello") ; -> "Hello" + +;; Usado sem cuidados, macros podem fazer muito mal por sobreporem suas variaveis +(defmacro define-x [] + '(do + (def x 2) + (list x))) + +(def x 4) +(define-x) ; -> (2) +(list x) ; -> (2) + +;;s Para evitar isso, use gensym para receber um identificador unico +(gensym 'x) ; -> x1281 (ou outra coisa) + +(defmacro define-x-safely [] + (let [sym (gensym 'x)] + `(do + (def ~sym 2) + (list ~sym)))) + +(def x 4) +(define-x-safely) ; -> (2) +(list x) ; -> (4) + +;; Você pode usar # dentro de ` para produzir uma gensym para cada simbolo automaticamente +(defmacro define-x-hygenically [] + `(do + (def x# 2) + (list x#))) + +(def x 4) +(define-x-hygenically) ; -> (2) +(list x) ; -> (4) + +;; É típico o uso de funções de auxilio com macros. Vamos criar um pouco +;; Vamos criar um pouco para nos ajudar a suportar uma sintaxe aritmética inline (estupida) +(declare inline-2-helper) +(defn clean-arg [arg] + (if (seq? arg) + (inline-2-helper arg) + arg)) + +(defn apply-arg + "Given args [x (+ y)], return (+ x y)" + [val [op arg]] + (list op val (clean-arg arg))) + +(defn inline-2-helper + [[arg1 & ops-and-args]] + (let [ops (partition 2 ops-and-args)] + (reduce apply-arg (clean-arg arg1) ops))) + +;; Podemos testar isso imediatamente, sem criar uma macro +(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5)) + +; Entretanto, temos que tornar isso uma macro caso quisermos que isso seja rodado em tempo de compilação +(defmacro inline-2 [form] + (inline-2-helper form))) + +(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1))) +; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1) + +(inline-2 (1 + (3 / 2) - (1 / 2) + 1)) +; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com / + +``` + +### Leitura adicional + +Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/) +[http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/) + +Documentos oficiais +[http://clojure.org/macros](http://clojure.org/macros) + +Quando utilizar macros? +[http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html) diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown new file mode 100644 index 00000000..b6e95d36 --- /dev/null +++ b/pt-br/csharp-pt.html.markdown @@ -0,0 +1,896 @@ +--- +language: c# +filename: csharp-pt.cs +contributors: + - ["Robson Alves", "http://robsonalves.net/"] +lang: pt-br +--- + +C# é uma linguagem elegante, altamente tipada e orientada a objetos que permite aos desenvolvedores criar uma variedade de aplicações seguras e robustas que são executadas no .NET Framework. + +[Leia mais aqui.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx) + +```c# +// Comentários de linha única começam com // +/* +Comentários de múltiplas linhas são desta forma +*/ +/// <summary> +/// Este é um comentário de documentação XML que pode ser usado para gerar documentação +/// externa ou para fornecer ajuda de contexto dentro de uma IDE +/// </summary> +//public void MethodOrClassOrOtherWithParsableHelp() {} + +// Especifica os namespaces que o código irá usar +// Os namespaces a seguir são padrões da biblioteca de classes do .NET Framework +using System; +using System.Collections.Generic; +using System.Dynamic; +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using System.IO; + +// Mas este aqui não é : +using System.Data.Entity; +// Para que consiga utilizá-lo, você precisa adicionar novas referências +// Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework` + +// Namespaces são escopos definidos para organizar o código em "pacotes" ou "módulos" +// Usando este código a partir de outro arquivo de origem: using Learning.CSharp; +namespace Learning.CSharp +{ + // Cada .cs deve conter uma classe com o mesmo nome do arquivo + // você está autorizado a contrariar isto, mas evite por sua sanidade. + public class AprenderCsharp + { + // Sintaxe Básica - Pule para as CARACTERÍSTICAS INTERESSANTES se você ja usou Java ou C++ antes. + public static void Syntax() + { + // Use Console.WriteLine para apresentar uma linha + Console.WriteLine("Hello World"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Para apresentar sem incluir uma nova linha, use Console.Write + Console.Write("Hello "); + Console.Write("World"); + + /////////////////////////////////////////////////// + // Tpos e Variáveis + // + // Declare uma variável usando <tipo> <nome> + /////////////////////////////////////////////////// + + // Sbyte - Signed 8-bit integer + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Unsigned 8-bit integer + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - 16-bit integer + // Signed - (-32,768 <= short <= 32,767) + // Unsigned - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Integer - 32-bit integer + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - 64-bit integer + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // Numbers default to being int or uint depending on size. + // L is used to denote that this variable value is of type long or ulong + + // Double - Double-precision 64-bit IEEE 754 Floating Point + double fooDouble = 123.4; // Precision: 15-16 digits + + // Float - Single-precision 32-bit IEEE 754 Floating Point + float fooFloat = 234.5f; // Precision: 7 digits + // f is used to denote that this variable value is of type float + + // Decimal - a 128-bits data type, with more precision than other floating-point types, + // suited for financial and monetary calculations + decimal fooDecimal = 150.3m; + + // Boolean - true & false + bool fooBoolean = true; // or false + + // Char - A single 16-bit Unicode character + char fooChar = 'A'; + + // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor, + // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo + string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; + Console.WriteLine(fooString); + + // Você pode acessar todos os caracteres de string com um indexador: + char charFromString = fooString[1]; // => 'e' + // Strings são imutáveis: você não pode fazer fooString[1] = 'X'; + + // Compare strings com sua atual cultura, ignorando maiúsculas e minúsculas + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // Formatando, baseado no sprintf + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // Datas e formatações + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // Você pode juntar um string em mais de duas linhas com o símbolo @. Para escapar do " use "" + string bazString = @"Here's some stuff +on a new line! ""Wow!"", the masses cried"; + + // Use const ou read-only para fazer uma variável imutável + // os valores da const são calculados durante o tempo de compilação + const int HoursWorkPerWeek = 9001; + + /////////////////////////////////////////////////// + // Estrutura de Dados + /////////////////////////////////////////////////// + + // Matrizes - zero indexado + // O tamanho do array pode ser decidido ainda na declaração + // O formato para declarar uma matriz é o seguinte: + // <tipodado>[] <var nome> = new <tipodado>[<array tamanho>]; + int[] intArray = new int[10]; + + // Outra forma de declarar & inicializar uma matriz + int[] y = { 9000, 1000, 1337 }; + + // Indexando uma matriz - Acessando um elemento + Console.WriteLine("intArray @ 0: " + intArray[0]); + // Matriz são alteráveis + intArray[1] = 1; + + // Listas + // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis + // O formato de declarar uma lista é o seguinte: + // List<tipodado> <var nome> = new List<tipodado>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // inicializar + // O <> são para genéricos - Confira está interessante seção do material + + // Lista não possuem valores padrão. + // Um valor deve ser adicionado antes e depois acessado pelo indexador + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + // Outras estruturas de dados para conferir: + // Pilha/Fila + // Dicionário (uma implementação de map de hash) + // HashSet + // Read-only Coleção + // Tuple (.Net 4+) + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // Forma curta para declarar diversas variáveis + + // Aritmética é clara + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // Modulo + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Comparações de operadores + Console.WriteLine("3 == 2? " + (3 == 2)); // => falso + Console.WriteLine("3 != 2? " + (3 != 2)); // => verdadeiro + Console.WriteLine("3 > 2? " + (3 > 2)); // => verdadeiro + Console.WriteLine("3 < 2? " + (3 < 2)); // => falso + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => verdadeiro + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => verdadeiro + + // Operadores bit a bit (bitwise) + /* + ~ Unário bitwise complemento + << Signed left shift + >> Signed right shift + & Bitwise AND + ^ Bitwise exclusivo OR + | Bitwise inclusivo OR + */ + + // Incrementações + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. Post-Incrementation + Console.WriteLine(++i); //i = 2. Pre-Incrementation + Console.WriteLine(i--); //i = 1. Post-Decrementation + Console.WriteLine(--i); //i = 0. Pre-Decrementation + + /////////////////////////////////////// + // Estrutura de Controle + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // Declaração if é como a linguagem C + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // Operador Ternário + // Um simples if/else pode ser escrito da seguinte forma + // <condição> ? <verdadeiro> : <falso> + int toCompare = 17; + string isTrue = toCompare == 17 ? "True" : "False"; + + // While loop + int fooWhile = 0; + while (fooWhile < 100) + { + //Iterated 100 times, fooWhile 0->99 + fooWhile++; + } + + // Do While Loop + int fooDoWhile = 0; + do + { + // Inicia a interação 100 vezes, fooDoWhile 0->99 + if (false) + continue; // pule a intereção atual para apróxima + + fooDoWhile++; + + if (fooDoWhile == 50) + break; // Interrompe o laço inteiro + + } while (fooDoWhile < 100); + + //estrutura de loop for => for(<declaração para começar>; <condicional>; <passos>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + //Iterado 10 vezes, fooFor 0->9 + } + + // For Each Loop + // Estrutura do foreach => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>) + // O laço foreach percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T> + // Toda a coleção de tipos (Array, List, Dictionary...) no .Net framework + // implementa uma ou mais destas interfaces. + // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable) + foreach (char character in "Hello World".ToCharArray()) + { + //Iterated over all the characters in the string + } + + // Switch Case + // Um switch funciona com os tipos de dados byte, short, char, e int. + // Isto também funcional com tipos enumeradors (discutidos em Tipos Enum), + // A classe String, and a few special classes that wrap + // tipos primitívos: Character, Byte, Short, and Integer. + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + 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 + case 6: + case 7: + case 8: + monthString = "Summer time!!"; + break; + default: + monthString = "Some other month"; + break; + } + + /////////////////////////////////////// + // Converting Data Types And Typecasting + /////////////////////////////////////// + + // Converting data + + // Convert String To Integer + // this will throw a FormatException on failure + int.Parse("123");//returns an integer version of "123" + + // try parse will default to type default on failure + // in this case: 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // Function is boolean + Console.WriteLine(tryInt); // 123 + + // Convert Integer To String + // Convert class has a number of methods to facilitate conversions + Convert.ToString(123); + // or + tryInt.ToString(); + + // Casting + // Cast decimal 15 to a int + // and then implicitly cast to long + long x = (int) 15M; + } + + /////////////////////////////////////// + // CLASSES - see definitions at end of file + /////////////////////////////////////// + public static void Classes() + { + // See Declaration of objects at end of file + + // Use new to instantiate a class + Bicycle trek = new Bicycle(); + + // Call object methods + trek.SpeedUp(3); // You should always use setter and getter methods + trek.Cadence = 100; + + // ToString is a convention to display the value of this Object. + Console.WriteLine("trek info: " + trek.Info()); + + // Instantiate a new Penny Farthing + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } // End main method + + // CONSOLE ENTRY A console application must have a main method as an entry point + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // INTERESTING FEATURES + // + + // DEFAULT METHOD SIGNATURES + + public // Visibility + static // Allows for direct call on class without object + int // Return Type, + MethodSignatures( + int maxCount, // First variable, expects an int + int count = 0, // will default the value to 0 if not passed in + int another = 3, + params string[] otherParams // captures all other parameters passed to method + ) + { + return -1; + } + + // Methods can have the same name, as long as the signature is unique + // A method that differs only in return type is not unique + public static void MethodSignatures( + ref int maxCount, // Pass by reference + out int count) + { + count = 15; // out param must be assigned before control leaves the method + } + + // GENERICS + // The classes for TKey and TValue is specified by the user calling this function. + // This method emulates the SetDefault of Python + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // You can narrow down the objects that are passed in + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // We can iterate, since T is a IEnumerable + foreach (var item in toPrint) + // Item is an int + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // OPTIONAL PARAMETERS + MethodSignatures(3, 1, 3, "Some", "Extra", "Strings"); + MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones + + // BY REF AND OUT PARAMETERS + int maxCount = 0, count; // ref params must have value + MethodSignatures(ref maxCount, out count); + + // EXTENSION METHODS + int i = 3; + i.Print(); // Defined below + + // NULLABLE TYPES - great for database interaction / return values + // any value type (i.e. not a class) can be made nullable by suffixing a ? + // <type>? <var name> = <value> + int? nullable = null; // short hand for Nullable<int> + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // true if not null + + // ?? is syntactic sugar for specifying default value (coalesce) + // in case variable is null + int notNullable = nullable ?? 0; // 0 + + // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is: + var magic = "magic is a string, at compile time, so you still get type safety"; + // magic = 9; will not work as magic is a string, not an int + + // GENERICS + // + var phonebook = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // Add some entries to the phone book + }; + + // Calling SETDEFAULT defined as a generic above + Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone + // nb, you don't need to specify the TKey and TValue since they can be + // derived implicitly + Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555 + + // LAMBDA EXPRESSIONS - allow you to write code in line + Func<int, int> square = (x) => x * x; // Last T item is the return value + Console.WriteLine(square(3)); // 9 + + // ERROR HANDLING - coping with an uncertain world + try + { + var funBike = PennyFarthing.CreateWithGears(6); + + // will no longer execute because CreateWithGears throws an exception + string some = ""; + if (true) some = null; + some.ToLower(); // throws a NullReferenceException + } + catch (NotSupportedException) + { + Console.WriteLine("Not so much fun now!"); + } + catch (Exception ex) // catch all other exceptions + { + throw new ApplicationException("It hit the fan", ex); + // throw; // A rethrow that preserves the callstack + } + // catch { } // catch-all without capturing the Exception + finally + { + // executes after try or catch + } + + // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily. + // Most of objects that access unmanaged resources (file handle, device contexts, etc.) + // implement the IDisposable interface. The using statement takes care of + // cleaning those IDisposable objects for you. + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("Nothing suspicious here"); + // At the end of scope, resources will be released. + // Even if an exception is thrown. + } + + // PARALLEL FRAMEWORK + // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // Will spin up separate threads for each request, and join on them + // before going to the next step! + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads + website => + { + // Do something that takes a long time on the file + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // This won't happen till after all requests have been completed + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // DYNAMIC OBJECTS (great for working with other languages) + dynamic student = new ExpandoObject(); + student.FirstName = "First Name"; // No need to define class first! + + // You can even add methods (returns a string, and takes in a string) + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of + // very useful Map / Filter / Reduce style methods + var bikes = new List<Bicycle>(); + bikes.Sort(); // Sorts the array + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels + var result = bikes + .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string> + + var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection + + // Create a list of IMPLICIT objects based on some parameters of the bike + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // Hard to show here, but you get type ahead completion since the compiler can implicitly work + // out the types above! + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + // ASPARALLEL + // And this is where things get wicked - combines linq and parallel operations + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // this will happen in parallel! Threads will automagically be spun up and the + // results divvied amongst them! Amazing for large datasets when you have lots of + // cores + + // LINQ - maps a store to IQueryable<T> objects, with delayed execution + // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document + var db = new BikeRepository(); + + // execution is delayed, which is great when querying a database + var filter = db.Bikes.Where(b => b.HasTassles); // no query run + if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality + filter = filter.Where(b => b.IsBroken); // no query run + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // still no query run + + // Now the query runs, but opens a reader, so only populates are you iterate through + foreach (string bike in query) + Console.WriteLine(result); + + + + } + + } // End LearnCSharp class + + // You can include other classes in a .cs file + + public static class Extensions + { + // EXTENSION FUNCTIONS + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + + // Class Declaration Syntax: + // <public/private/protected/internal> class <class name>{ + // //data fields, constructors, functions all inside. + // //functions are called as methods in Java. + // } + + public class Bicycle + { + // Bicycle's Fields/Variables + public int Cadence // Public: Can be accessed from anywhere + { + get // get - define a method to retrieve the property + { + return _cadence; + } + set // set - define a method to set a proprety + { + _cadence = value; // Value is the value passed in to the setter + } + } + private int _cadence; + + protected virtual int Gear // Protected: Accessible from the class and subclasses + { + get; // creates an auto property so you don't need a member field + set; + } + + internal int Wheels // Internal: Accessible from within the assembly + { + get; + private set; // You can set modifiers on the get/set methods + } + + int _speed; // Everything is private by default: Only accessible from within this class. + // can also use keyword private + public string Name { get; set; } + + // Enum is a value type that consists of a set of named constants + // It is really just mapping a name to a value (an int, unless specified otherwise). + // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong. + // An enum can't contain the same value twice. + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, //you can explicitly set a value to a name + Gitane // 43 + } + // We defined this type inside a Bicycle class, so it is a nested type + // Code outside of this class should reference this type as Bicycle.Brand + + public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type + + // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on + [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc + public enum BikeAccessories + { + None = 0, + Bell = 1, + MudGuards = 2, // need to set the values manually! + Racks = 4, + Lights = 8, + FullPackage = Bell | MudGuards | Racks | Lights + } + + // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell) + // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell + public BikeAccessories Accessories { get; set; } + + // Static members belong to the type itself rather then specific object. + // You can access them without a reference to any object: + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + public static int BicyclesCreated { get; set; } + + // readonly values are set at run time + // they can only be assigned upon declaration or in a constructor + readonly bool _hasCardsInSpokes = false; // read-only private + + // Constructors are a way of creating classes + // This is a default constructor + public Bicycle() + { + this.Gear = 1; // you can access members of the object with the keyword this + Cadence = 50; // but you don't always need it + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // This is a specified constructor (it contains arguments) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // calls base first + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // Constructors can be chained + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // Function Syntax: + // <public/private/protected> <return type> <function name>(<args>) + + // classes can implement getters and setters for their fields + // or they can implement properties (this is the preferred way in C#) + + // Method parameters can have default values. + // In this case, methods can be called with these parameters omitted + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // properties get/set values + // when only data needs to be accessed, consider using properties. + // properties may have either get or set, or both + private bool _hasTassles; // private variable + public bool HasTassles // public accessor + { + get { return _hasTassles; } + 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: + public bool IsBroken { get; private set; } + + // Properties can be auto-implemented + public int FrameSize + { + get; + // you are able to specify access modifiers for either get or set + // this means only Bicycle class can call set on Framesize + private set; + } + + // It's also possible to define custom Indexers on objects. + // All though this is not entirely useful in this example, you + // could do bicycle[0] which yields "chris" to get the first passenger or + // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle) + private string[] passengers = { "chris", "phil", "darren", "regina" }; + + public string this[int i] + { + get { + return passengers[i]; + } + + set { + return passengers[i] = value; + } + } + + //Método para exibir os valores dos atributos deste objeto. + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Methods can also be static. It can be useful for helper methods + public static bool DidWeCreateEnoughBycles() + { + // Within a static method, we only can reference static class members + return BicyclesCreated > 9000; + } // If your class only needs static members, consider marking the class itself as static. + + + } // end class Bicycle + + // PennyFarthing é uma subclasse de Bicycle + class PennyFarthing : Bicycle + { + // (Penny Farthings são aquelas bicicletas com uma grande roda frontal. + // Elas não tem correias.) + + // chamando construtor pai + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + throw new InvalidOperationException("You can't change gears on a PennyFarthing"); + } + } + + public static PennyFarthing CreateWithGears(int gears) + { + var penny = new PennyFarthing(1, 1); + penny.Gear = gears; // Oops, can't do this! + return penny; + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Calling the base version of the method + return result; + } + } + + // Interfaces contêm apenas as assinaturas dos membros, sem a implementação. + interface IJumpable + { + void Jump(int meters); // todos os membros da interface são implicitamente públicos + } + + interface IBreakable + { + bool Broken { get; } // interfaces can contain properties as well as methods & events + } + + // Class can inherit only one other class, but can implement any amount of interfaces + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// Used to connect to DB for LinqToSql example. + /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional) + /// http://msdn.microsoft.com/en-us/data/jj193542.aspx + /// </summary> + public class BikeRepository : DbContext + { + public BikeRepository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // End Namespace +``` + +## Topics Not Covered + + * Attributes + * async/await, yield, pragma directives + * Web Development + * ASP.NET MVC & WebApi (new) + * ASP.NET Web Forms (old) + * WebMatrix (tool) + * Desktop Development + * Windows Presentation Foundation (WPF) (new) + * Winforms (old) + +## Further Reading + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx) diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown new file mode 100644 index 00000000..956b3614 --- /dev/null +++ b/pt-br/css-pt.html.markdown @@ -0,0 +1,257 @@ +--- +language: css +filename: learncss-pt.css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + - ["Geoffrey Liu", "https://github.com/g-liu"] + - ["Connor Shea", "https://github.com/connorshea"] + - ["Deepanshu Utkarsh", "https://github.com/duci9y"] +translators: + - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"] +lang: pt-br +--- + +Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum. + +CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web. + +CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles. + +Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular. + +**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/). +O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais. + +```css +/* Comentários aparecem dentro do slash-asterisk, tal como esta linha! + Não há "comentários de uma linha"; este é o único estilo de comentário * / + +/* #################### + ## SELETORES + #################### */ + +/* O seletor é usado para direcionar um elemento em uma página. + seletor { propriedade: valor; / * Mais propriedades ... * / } + +/* +Abaixo um elemento de exemplo: + +<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' /> +*/ + +/* Você pode direciona-lo usando uma das suas classes CSS */ +.class1 { } + +/* ou ambas as classes! */ +.class1.class2 { } + +/* ou o seu nome */ +div { } + +/* ou o seu id */ +#anID { } + +/* ou utilizando o fator de que tem um atributo!*/ +[attr] { font-size:smaller; } + +/* ou que o atributo tem um valor específico */ +[attr='value'] { font-size:smaller; } + +/* começa com um valor (CSS 3) */ +[attr^='val'] { font-size:smaller; } + +/* ou terminando com um valor (CSS 3) */ +[attr$='ue'] { font-size:smaller; } + + +/* Ou contém um valor em uma lista separada por espaços */ +[otherAttr ~ = 'foo'] {} +[otherAttr ~ = 'bar'] {} + +/* Ou contém um valor em uma lista separada por hífen, ou seja, "-" (U + 002D) */ +[otherAttr | = 'en'] {font-size: smaller; } + + +/* Você pode concatenar diferentes seletores para criar um seletor mais estreito. Não + colocar espaços entre eles. */ +classe div.some [attr $ = 'ue'] {} + +/* Você pode selecionar um elemento que é filho de outro elemento */ +div.some-parent> .class-name {} + +/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de + seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes + nivelar por baixo da árvore. */ +div.some-parent class-name {} + +/* Atenção: o mesmo seletor sem espaço tem um outro significado. + Você consegue adivinhar o que? */ +div.some-parent.class-name {} + +/* Você também pode selecionar um elemento com base em seu irmão adjacente */ +.i am just-antes + .Este elemento {} + +/* Ou qualquer irmão que o precede */ +.i am-qualquer-elemento antes ~ .Este elemento {} + +/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um + elemento quando ele está em um determinado estado */ + +/* Por exemplo, quando o cursor passa sobre um elemento */ +seletor:hover {} + +/* Ou um link foi visitado */ +seletor:visited {} + +/* Ou não tenha sido visitado */ +seletor:link {} + +/* Ou um elemento em foco */ +seletor:focus {} + +/* Qualquer elemento que é o primeiro filho de seu pai */ +seletor:first-child {} + +/* Qualquer elemento que é o último filho de seu pai */ +seletor:last-child {} + +/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */ + +/* Corresponde a um primeiro filho virtual do elemento selecionado */ +seletor::before {} + +/* Corresponde a um último filho virtual do elemento selecionado */ +seletor::after {} + +/* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos + elemento */ +* {} /* */ Todos os elementos +.parent * {} /* */ todos os descendentes +.parent> * {} /* */ todas as crianças + +/* #################### + ## PROPRIEDADES + #################### */ + +seletor { + + /* Unidades de comprimento pode ser absoluta ou relativa. */ + + /* Unidades relativas */ + width: 50%; /* Percentagem de largura elemento pai */ + font-size: 2em; /* Múltiplos de font-size original de elemento */ + font-size: 2rem; /* Ou do elemento raiz font-size */ + font-size: 2vw; /* Múltiplos de 1% da largura da janela de exibição (CSS 3) */ + font-size: 2vh; /* Ou a sua altura */ + font-size: 2vmin; /* Qualquer um de VH ou um VW é menor */ + font-size: 2vmax; /* Ou superior */ + + /* Unidades absolutas */ + width: 200px; /* píxeis */ + font-size: 20pt; /* Pontos */ + width: 5cm; /* Centímetros */ + min-width: 50mm; /* Milímetros */ + max-width: 5 polegadas; /* Polegadas */ + + /* Cores */ + color: # F6E; /* Formato hexadecimal curto */ + color: # FF66EE; /* Formato hexadecimal longo */ + color: tomato; /* Uma cor nomeada */ + color: rgb (255, 255, 255); /* Como valores rgb */ + color: RGB (10%, 20%, 50%); /* Como porcentagens rgb */ + color: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */ + color: transparent; /* Equivale a definir o alfa a 0 */ + color: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */ + color: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */ + + /* Imagens como fundos de elementos */ + background-image: url (/img-path/img.jpg); /* Citações dentro url () opcional */ + + /* Fontes */ + font-family: Arial; + /* Se o nome da família de fonte tem um espaço, deve ser citado */ + font-family: "Courier New"; + /* Se o primeiro não for encontrada, o navegador usa o próximo, e assim por diante */ + font-family: "Courier New", Trebuchet, Arial, sans-serif; +} +``` + +## Uso + +Guardar uma folha de estilo CSS com a extensão `.css`. + +```xml +<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o + método recomendado. Consulte http://stackoverflow.com/questions/8284365 --> +<link rel='stylesheet' type='text/css' href='path/to/style.css' /> + +<!-- Você também pode incluir alguns CSS inline na sua marcação. --> +<style> + a { color: purple; } +</style> + +<!-- Ou diretamente definir propriedades CSS no elemento. --> +<div style="border: 1px solid red;"> +</div> +``` + +## Precedência ou Cascata + +Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior. + +Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata. + +Dado o seguinte CSS: + +```css +/* UMA */ +p.class1[attr="value"] + +/* B */ +p.class1 {} + +/* C */ +p.class2 {} + +/* D */ +p { } + +/* E */ +p { property: value !important; } +``` + +e a seguinte marcação: + +```xml +<p style='/*F*/ property:value;' class='class1 class2' attr='value' /> +``` + +A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada **propriedade**, não para todo o bloco. + +* `E` tem a precedência mais alta por causa de uma palavra-chave`!important`. É recomendável que você evitar seu uso. +* `F` é a próxima, porque é um estilo interno. +* `A` é a próxima, porque é mais" específico "do que qualquer outra coisa. Tem 3 especificadores: O nome do elemento `p`, o seu `class1` classe, um atributo `attr='value'`. +* `C` está próximo, mesmo que ele tenha a mesma especificidade que `B`. Isso é porque ele aparece depois de `B`. +* `B` é o próximo. +* `D` é a última. + +## Compatibilidade + +A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso. + +## Recursos + +* Para executar uma verificação de compatibilidade rápida, [CanIUse](http://caniuse.com). +* CSS Playground [Dabblet](http://dabblet.com/). +* [Documentação CSS Mozilla Developer Rede](https://developer.mozilla.org/en-US/docs/Web/CSS) +* [Codrops 'Referência CSS](http://tympanus.net/codrops/css_reference/) + +## Leitura adicional + +* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [Selecionando elementos usando atributos](https://css-tricks.com/almanac/selectors/a/attribute/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - O empilhamento context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) +* [SASS](http://sass-lang.com/) e [menos](http://lesscss.org/) para CSS pré-processamento +* [CSS-Tricks](https://css-tricks.com) diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown new file mode 100644 index 00000000..84b055d9 --- /dev/null +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -0,0 +1,76 @@ +--- +category: Algorithms & Data Structures +name: Dynamic Programming +contributors: + - ["Akashdeep Goel", "http://github.com/akashdeepgoel"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +--- + +# Programação Dinâmica + +## Introdução + +Programação Dinâmica é uma técnica poderosa utilizada para resolver uma classe +particular de problemas como veremos. A ideia é bastante simples, se você +solucionou um problema com uma dada entrada, então salve o resultado para +referência futura, e também para evitar resolver o mesmo problema novamente. + +Sempre se lembre!! +"Aqueles que não conseguem lembrar o passado estão condenados a repeti-lo" + +## Maneiras de Solucionar tais Problemas + +1. Top-Down (De cima para baixo): Comece solucionando o problema quebrando-o em +partes. Se você perceber que o problema já foi resolvido, então simplemente +pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a +resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente +referenciado como Memorização. + +2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os +subproblemas são resolvidos e comece a solucionar dos problemas mais triviais, +até o problema dado. Neste processo, é garantido que os subproblemas são +resolvidos antes de resolver o problema. Isto é referenciado como Programação Dinâmica. + +## Exemplo de Programação Dinâmica + +O problema da subsequência crescente máxima consiste em encontrar a maior +subsequência crescente de uma dada sequência. Dada uma sequência +S= {a1 , a2 , a3, a4, ... , an-1, an} nós temos que encontrar o maior subconjunto +de forma que para todo j e i, j < i no subconjunto aj < ai. Antes de mais nada +nós temos que encontrar o valor das maiores subsequências (LSi) para cada índice +i com o último elemento da sequência sendo ai. Então a maior LSi será a maior +subsequência na sequência dada. Para começar LSi é atribuído a um pois ai é +elemento da sequência (último elemento). Então para todo j tal que j < i e aj < +ai, nós procuramos o maior LSj e o adicionamos a LSi. Portanto o algoritmo tem +complexidade de tempo O(n2). O pseudocódigo para procurar o comprimento da +subsequência crescente máxima: A complexidade desse algoritmo poderia ser +reduzida utilizando uma estrutura de dados melhor que um array. Armazenando o +array antecedente e uma variável como maiorSequenciasAteAgora e seu índice +ajudariam a poupar muito tempo. +Um conceito similar poderia ser aplicado ao procurar o maior caminho em um +grafo acíclico dirigido. + +``` + for i=0 to n-1 + LS[i]=1 + for j=0 to i-1 + if (a[i] > a[j] and LS[i]<LS[j]) + LS[i] = LS[j]+1 + for i=0 to n-1 + if (largest < LS[i]) +``` + +## 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 +``` + +## Recursos Online (EN) + +* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming) diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown new file mode 100644 index 00000000..f8c56101 --- /dev/null +++ b/pt-br/elixir-pt.html.markdown @@ -0,0 +1,412 @@ +--- +language: elixir +contributors: + - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] +translators: + - ["Rodrigo Muniz", "http://github.com/muniz95"] +lang: pt-br +filename: learnelixir-pt.ex +--- + +Elixir é uma linguagem funcional moderna construída no topo da Erlang VM. +É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada +e muitos outros recursos. + +```elixir + +# Comentários de linha única começam com um símbolo de número. + +# Não há comentários de múltiplas linhas, +# mas você pode empilhar os comentários. + +# Para usar o shell do elixir use o comando `iex`. +# Compile seus módulos com o comando `elixirc`. + +# Ambos devem estar em seu path se você instalou o Elixir corretamente. + +## --------------------------- +## -- Tipos Básicos +## --------------------------- + +# Há números +3 # integer +0x1F # integer +3.0 # float + +# Atoms, que são literais, uma constante com nome. Elas começam com `:`. +:hello # atom + +# Tuplas que são guardadas contiguamente em memória. +{1,2,3} # tupla + +# Podemos acessar um elemento de uma tupla om a função `elem`: +elem({1, 2, 3}, 0) #=> 1 + +# Listas que são implementadas como listas ligadas. +[1,2,3] # lista + +# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir: +[head | tail] = [1,2,3] +head #=> 1 +tail #=> [2,3] + +# Em elixir, bem como em Erlang, o sinal `=` denota pattern match, +# e não uma atribuição. +# +# Isto significa que o que estiver à esquerda (pattern) é comparado com o que +# estiver à direita. +# +# É assim que o exemplo acima de acesso à head e tail de uma lista funciona. + +# Um pattern match retornará erro quando os lados não conferem, como neste exemplo +# onde as tuplas tem diferentes tamanhos. +# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} + +# Também há binários +<<1,2,3>> # binary + +# Strings e char lists +"hello" # string +'hello' # char list + +# Strings de múltiplas linhas +""" +Strings +de múltiplas +linhas. +""" +#=> "Strings\nde múltiplas\nlinhas" + +# Strings são sempre codificadas em UTF-8: +"héllò" #=> "héllò" + +# Strings são de fato apenas binários, e char lists apenas listas. +<<?a, ?b, ?c>> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# `?a` em elixir retorna o valor ASCII para a letra `a` +?a #=> 97 + +# Para concatenar listas use `++`, para binários use `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'hello ' ++ 'world' #=> 'hello world' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"hello " <> "world" #=> "hello world" + +# Ranges são representados como `início..fim` (ambos inclusivos) +1..10 #=> 1..10 +menor..maior = 1..10 # Pattern matching pode ser usada em ranges também +[lower, upper] #=> [1, 10] + +## --------------------------- +## -- Operadores +## --------------------------- + +# Matemática básica +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# Em elixir o operador `/` sempre retorna um float. + +# Para divisão de inteiros use `div` +div(10, 2) #=> 5 + +# Para obter o resto da divisão use `rem` +rem(10, 3) #=> 1 + +# Há também operadores booleanos: `or`, `and` e `not`. +# Estes operadores esperam um booleano como primeiro argumento. +true and true #=> true +false or true #=> true +# 1 and true #=> ** (ArgumentError) argument error + +# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo. +# Todos os valores exceto `false` e `nil` serão avaliados como true. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil +!true #=> false + +# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` e `!==` são mais estritos ao comparar integers e floats: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# Podemos comparar também dois tipos de dados diferentes: +1 < :hello #=> true + +# A regra de ordenação no geral é definida abaixo: +# number < atom < reference < functions < port < pid < tuple < list < bit string + +# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante, +# mas que uma ordem total esteja bem definida é importante." + +## --------------------------- +## -- Fluxo de Controle +## --------------------------- + +# expressão `if` +if false do + "Isso nunca será visto" +else + "Isso será" +end + +# Também há `unless` +unless true do + "Isso nunca será visto" +else + "Isso será" +end + +# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela. + +# `case` nos permite comparar um valor com muitos patterns: +case {:um, :dois} do + {:quatro, :cinco} -> + "Isso não corresponde" + {:um, x} -> + "Isso corresponde e vincula `x` a `:dois`" + _ -> + "Isso corresponde a qualquer valor" +end + +# É comum vincular o valor a `_` se não precisamos dele. +# Por exemplo, se apenas a head de uma lista nos interessa: +[head | _] = [1,2,3] +head #=> 1 + +# Para melhor legibilidade podemos fazer o seguinte: +[head | _tail] = [:a, :b, :c] +head #=> :a + +# `cond` nos permite verificar várias condições ao mesmo tempo. +# Use `cond` em vez de aninhar vários `if`'s. +cond do + 1 + 1 == 3 -> + "Nunca serei visto" + 2 * 5 == 12 -> + "Nem eu" + 1 + 2 == 3 -> + "Mas eu serei" +end + +# É comum definir a última condição igual a `true`, que sempre irá corresponder. +cond do + 1 + 1 == 3 -> + "Nunca serei visto" + 2 * 5 == 12 -> + "Nem eu" + true -> + "Mas eu serei (isso é essencialmente um else)" +end + +# `try/catch` é usado para capturar valores que são lançados, também suporta uma +# cláusula `after` que é invocada havendo um valor capturado ou não. +try do + throw(:hello) +catch + message -> "Deu #{mensagem}." +after + IO.puts("Sou o after.") +end +#=> Sou o after +# "Deu :hello" + +## --------------------------- +## -- Módulos e Funções +## --------------------------- + +# Funções Anônimas (repare o ponto) +square = fn(x) -> x * x end +square.(5) #=> 25 + +# Elas também aceitam várias cláusulas e guards. +# Guards permitem ajustes finos de pattern matching, +# sendo indicados pela palavra `when`: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir também fornece várias funções embutidas. +# Estas estão disponíveis no escopo atual. +is_number(10) #=> true +is_list("ola") #=> false +elem({1,2,3}, 0) #=> 1 + +# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def` +# para definir suas funções. +defmodule Math do + def sum(a, b) do + a + b + end + + def square(x) do + x * x + end +end + +Math.sum(1, 2) #=> 3 +Math.square(3) #=> 9 + +# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc` +# em seu terminal: elixirc math.ex + +# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`. +# Uma função definida com `def` pode ser invocada por outros módulos, +# já uma função privada pode ser invocada apenas localmente. +defmodule PrivateMath do + def sum(a, b) do + do_sum(a, b) + end + + defp do_sum(a, b) do + a + b + end +end + +PrivateMath.sum(1, 2) #=> 3 +# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError) + +# Declarações de funções também suportam guards cláusulas múltiplas: +defmodule Geometry do + def area({:rectangle, w, h}) do + w * h + end + + def area({:circle, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometry.area({:rectangle, 2, 3}) #=> 6 +Geometry.area({:circle, 3}) #=> 28.25999999999999801048 +# Geometry.area({:circle, "not_a_number"}) +#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1 + +# Devido à imutabilidade, recursão é uma grande parte do elixir +defmodule Recursion do + def sum_list([head | tail], acc) do + sum_list(tail, acc + head) + end + + def sum_list([], acc) do + acc + end +end + +Recursion.sum_list([1,2,3], 0) #=> 6 + +# Módulos do elixir suportam atributos, hpa atributos embutidos e você +# pode também adicionar os seus próprios. +defmodule MyMod do + @moduledoc """ + Este é um atributo embutido em um módulo de exemplo. + """ + + @my_data 100 # Este é um atributo customizado. + IO.inspect(@my_data) #=> 100 +end + +## --------------------------- +## -- Structs e Exceptions +## --------------------------- + +# Structs são extensões no topo de mapas que trazem valores padrão, +# garantias em tempo de compilação e polimorfismo para o Elixir. +defmodule Pessoa do + defstruct nome: nil, idade: 0, peso: 0 +end + +joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 } +#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"} + +# Acessa o valor de nome +joe_info.name #=> "Joe" + +# Atualiza o valor de idade +older_joe_info = %{ joe_info | idade: 31 } +#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"} + +# O bloco `try` com a palavra `rescue` é usado para manipular exceções +try do + raise "algum erro" +rescue + RuntimeError -> "resgatado um erro em tempo de execução" + _error -> "isso resgatará qualquer erro" +end + +# Toda exceção possui uma mensagem +try do + raise "algum erro" +rescue + x in [RuntimeError] -> + x.message +end + +## --------------------------- +## -- Concorrência +## --------------------------- + +# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para +# escrever programas concorrentes em elixir são três primitivos: spawning processes, +# sending messages e receiving messages. + +# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função +# como argumento. +f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> +spawn(f) #=> #PID<0.40.0> + +# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar +# mensagens ao processo. Para envio de mensagens usamos o operador `send`. +# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é +# realizado com o mecanismo `receive`: +defmodule Geometry do + def area_loop do + receive do + {:rectangle, w, h} -> + IO.puts("Area = #{w * h}") + area_loop() + {:circle, r} -> + IO.puts("Area = #{3.14 * r * r}") + area_loop() + end + end +end + +# Compile o módulo e crie um processo que avalie `area_loop` no shell +pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> + +# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento +send pid, {:rectangle, 2, 3} +#=> Area = 6 +# {:rectangle,2,3} + +send pid, {:circle, 2} +#=> Area = 12.56000000000000049738 +# {:circle,2} + +# O shell também é um processo, você pode usar `self` para obter o pid atual +self() #=> #PID<0.27.0> +``` + +## Referências + +* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org) +* [Elixir Documentation](http://elixir-lang.org/docs/master/) +* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas +* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert +* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown new file mode 100644 index 00000000..78a4f1b7 --- /dev/null +++ b/pt-br/elm-pt.html.markdown @@ -0,0 +1,384 @@ +--- +language: Elm +contributors: + - ["Max Goldstein", "http://maxgoldste.in/"] +translators: + - ["Marcel dos Santos", "https://twitter.com/marcelgsantos"] +lang: pt-br +filename: learnelm-pt.elm +--- + +Elm é uma linguagem de programação funcional reativa que compila para (client-side) +JavaScript. Elm é estaticamente tipada, significando que o compilador captura a +maioria dos erros imediatamente e fornece uma mensagem de erro limpa e compreensível. +Elm é excelente para projetar interfaces de usuário e jogos para a web. + + +```haskell +-- Comentários de uma linha começam com dois traços. +{- Comentários de múltiplas linhas podem ser delimitados em um bloco como este. +{- Eles podem ser aninhados. -} +-} + +{-- O Básico --} + +-- Operações Aritméticas +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 + +-- Cada número literal sem um ponto decimal pode ser um Int ou um Float. +33 / 2 -- 16.5 com divisão de ponto flutuante +33 // 2 -- 16 com divisão inteira + +-- Exponenciação +5 ^ 2 -- 25 + +-- Booleanos +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- Strings e caracteres +"Esta é uma string porque ela utiliza aspas duplas." +'a' -- caracteres entre aspas simples + +-- Strings podem ser anexadas. +"Olá " ++ "mundo!" -- "Olá mundo!" + +{-- Listas, Tuplas e Registros --} + +-- Cada elemento em uma lista deve ter o mesmo tipo. +["the", "quick", "brown", "fox"] +[1, 2, 3, 4, 5] +-- O segundo exemplo também pode ser escrito com dois pontos. +[1..5] + +-- Junte listas da mesma forma que strings. +[1..5] ++ [6..10] == [1..10] -- True + +-- Para adicionar um item utilize "cons". +0 :: [1..5] -- [0, 1, 2, 3, 4, 5] + +-- A cabeça e a cauda de uma lista são retornadas como uma Maybe. Em vez de +-- verificar cada valor para ver se ele é nulo, você lida com os valores +-- faltantes explicitamente. +List.head [1..5] -- Just 1 +List.tail [1..5] -- Just [2, 3, 4, 5] +List.head [] -- Nothing +-- List.functionName siginifica que a função faz parte do módulo List. + +-- Cada elemento em uma tupla pode ser de um tipo diferente, mas uma tupla +-- tem um comprimento fixo. +("elm", 42) + +-- Acesse os elementos de um par com as funções first e second. +-- (Este é um atalho; nós iremos para o "caminho real" em breve.) +fst ("elm", 42) -- "elm" +snd ("elm", 42) -- 42 + +-- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder. +-- É o único valor de seu tipo, também chamado de "Unit". +() + +-- Registros são como tuplas mas os campos possuem nomes. A ordem dos campos +-- não importa. Observe que os valores dos registros utilizam sinais de igual, +-- e não dois-pontos. +{ x = 3, y = 7 } + +-- Acesse um campo com um ponto e o nome do campo. +{ x = 3, y = 7 }.x -- 3 + +-- Ou com uma função acessora, que é um ponto e o nome do próprio campo. +.y { x = 3, y = 7 } -- 7 + +-- Atualiza os campos de um registro. (Ele já deve ter os campos.) +{ person | + name = "George" } + +-- Atualiza vários campos de uma só vez utilizando os valores atuais. +{ particle | + position = particle.position + particle.velocity, + velocity = particle.velocity + particle.acceleration } + +{-- Fluxo de Controle --} + +-- Declarações if sempre devem ter um else e os valores devem ser do mesmo tipo. +if powerLevel > 9000 then + "WHOA!" +else + "meh" + +-- Declarações if podem ser encadeadas. +if n < 0 then + "n é negativo" +else if n > 0 then + "n é positivo" +else + "n é zero" + +-- Utilize declarações case para casar padrões entre diferentes possibilidades. +case aList of + [] -> "casa com uma lista vazia" + [x]-> "casa com uma lista de exatamente um item, " ++ toString x + x::xs -> "casa com uma lista de pelo menos um item cuja cabeça é " ++ toString x +-- O casamento do padrão acontece na ordem. Se colocarmos [x] por último, ele +-- nunca iria casar porque x::xs também casa (xs seria a lista vazia). Os +-- casamentos não "falham". +-- O compilador irá alertá-lo sobre casos faltantes ou extras. + +-- Casa padrão com um Maybe. +case List.head aList of + Just x -> "A cabeça é " ++ toString x + Nothing -> "A lista estava vazia." + +{-- Funções --} + +-- A sintaxe do Elm é muito mínima, baseando-se principalmente em espaços em +-- branco em vez de parênteses e chaves. Não existe a palavra-chave "return". + +-- Define uma função com seu nome, argumentos, um sinal de igual e o corpo. +multiply a b = + a * b + +-- Aplica (chama) uma função passando seus argumentos (vírgulas não necessárias). +multiply 7 6 -- 42 + +-- Aplica parcialmente uma função passando somente alguns de seus argumentos. +-- Dando, em seguida, um novo nome a função. +double = + multiply 2 + +-- Constantes são semelhantes, exceto que não há argumentos. +answer = + 42 + +-- Passa funções como argumentos para outras funções. +List.map double [1..4] -- [2, 4, 6, 8] + +-- Ou escreva uma função anônima. +List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8] + +-- Você pode casar um padrão na definição de funções quando há somente um caso. +-- Esta função recebe uma tupla em vez de dois argumentos. +-- Esta é a maneira que você normalmente vai desempacotar/extrair valores de tuplas. +area (width, height) = + width * height + +area (6, 7) -- 42 + +-- Utilize chaves para casar o padrão de nomes de campos de um registro. +-- Utilize let para definir valores intermediários. +volume {width, height, depth} = + let + area = width * height + in + area * depth + +volume { width = 3, height = 2, depth = 7 } -- 42 + +-- Funções podem ser recursivas. +fib n = + if n < 2 then + 1 + else + fib (n - 1) + fib (n - 2) + +List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34] + +-- Outra função recursiva (utilize List.length em um código de verdade). +listLength aList = + case aList of + [] -> 0 + x::xs -> 1 + listLength xs + +-- Chamadas de funções acontecem antes de qualquer operador infixo. +-- Os parênteses indicam a precendência. +cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1 +-- Primeiro degrees é aplicada em 30, então o resultado é passado para as +-- funções de trigonometria, que então é elevado ao quadrado e, por fim, a +-- adição acontece. + +{-- Tipos e Anotações de Tipos --} + +-- O compilador irá inferir o tipo de cada valor em seu programa. +-- Tipos iniciam com letra maiúscula. Leia x : T como "x é do tipo T". +-- Alguns tipos comuns que você pode ver no REPL do Elm. +5 : Int +6.7 : Float +"hello" : String +True : Bool + +-- Funções têm tipos também. Leia -> como "vai para". Pense no tipo mais à +-- direita como o tipo do valor de retorno e os outros como argumentos. +not : Bool -> Bool +round : Float -> Int + +-- Quando você define um valor, é uma boa prática escrever seu tipo acima dele. +-- A anotação é uma forma de documentação, que é verifica pelo compilador. +double : Int -> Int +double x = x * 2 + +-- Argumentos de uma função são passados entre parênteses. +-- Tipos com letra minúscula são tipos variáveis: eles podem ser de qualquer +-- tipo, desde que cada chamada seja consistente. +List.map : (a -> b) -> List a -> List b +-- "List.map é do tipo a-vai-para-b, vai para lista de a e vai para lista de b." + +-- Existem três tipos especiais com minúsculas: number, comparable e appendable. +-- Numbers permite que você utilize aritmética em Ints e Floats. +-- Comparable permite você ordenar números e strings, como a < b. +-- Appendable permite que coisas possam ser combinadas com a ++ b. + +{-- Type Aliases e Union Types --} + +-- Quando você escreve um registro ou uma tupla, seu tipo já existe. +-- (Observe que os tipos de um registro utilizam dois-pontos e os valores de um +-- registro utilizam igual.) +origin : { x : Float, y : Float, z : Float } +origin = + { x = 0, y = 0, z = 0 } + +-- Você pode dar um bom nome para tipos existentes com um type alias. +type alias Point3D = + { x : Float, y : Float, z : Float } + +-- Se você cria um alias para um registro, você pode usar o nome como uma +-- função construtora. +otherOrigin : Point3D +otherOrigin = + Point3D 0 0 0 + +-- Mas ele ainda é do mesmo tipo, então você pode compará-los. +origin == otherOrigin -- True + +-- Por outro lado, a definição de um union type cria um tipo que não existia +-- antes. Um union type é chamado assim porque ele pode ser uma de muitas +-- possibilidades. Cada uma das possibilidades é representada como uma "tag". +type Direction = + North | South | East | West + +-- As tags podem levar outros valores de tipos conhecidos. Isso pode trabalhar +-- recursivamente. +type IntTree = + Leaf | Node Int IntTree IntTree +-- "Leaf" e "Node" são as tags. Tudo após uma tag é um tipo. + +-- As tags podem ser usadas como valores ou funções. +root : IntTree +root = + Node 7 Leaf Leaf + +-- Union types (e type aliases) podem utilizar tipos variáveis. +type Tree a = + Leaf | Node a (Tree a) (Tree a) +-- "O tipo árvore-de-a é uma folha ou um nó de a, árvore-de-a e árvore-de-a." + +-- Casa padrão com union tags. As tags maiúsculas serão casadas de maneira exa- +-- ta. As variáveis minúsculas irão casar com qualquer coisa. Sublinhado também +-- casa com qualquer coisa, mas siginifica que você não o está utilizando. +leftmostElement : Tree a -> Maybe a +leftmostElement tree = + case tree of + Leaf -> Nothing + Node x Leaf _ -> Just x + Node _ subtree _ -> leftmostElement subtree + +-- Isso é praticamente a própria linguagem. Agora vamos ver como organizar e +-- executar seu código. + +{-- Módulos e Imports --} + +-- As bibliotecas internas são organizadas em módulos, assim como quaisquer +-- bibliotecas de terceiros que você possa utilizar. Para grandes projetos, +-- você pode definir seus próprios módulos. + +-- Coloque isso no topo do arquivo. Se for omitido, você está no Main. +module Name where + +-- Por padrão, tudo é exportado. Você pode especificar as exportações de forma +-- explícita. +module Name (MyType, myValue) where + +-- Um padrão comum é exportar um union type mas não suas tags. Isto é conhecido +-- como "tipo opaco" e é frequentemente utilizado em bibliotecas. + +-- Importe código de outros módulos para utilizá-lo no seu código. +-- Coloque Dict no escopo para você poder chamar Dict.insert. +import Dict + +-- Importe o módulo Dict e o tipo Dict para que suas anotações não tenham que +-- dizer Dict.Dict. Você ainda pode utilizar Dict.insert. +import Dict exposing (Dict) + +-- Renomeie um import. +import Graphics.Collage as C + +{-- Portas --} + +-- Uma porta indica que você estará se comunicando com o mundo exterior. +-- Portas são permitidas somente no módulo Main. + +-- Uma porta de entrada é apenas uma assinatura de tipo. +port clientID : Int + +-- Uma porta de saída tem uma definição. +port clientOrders : List String +port clientOrders = ["Books", "Groceries", "Furniture"] + +-- Não vamos entrar em detalhes, mas você configura callbacks no JavaScript +-- para enviar nas portas de entrada e receber nas portas de saída. + +{-- Ferramentas de Linha de Comando --} + +-- Compila um arquivo. +$ elm make MyFile.elm + +-- A primeira vez que você fizer isso, o Elm instalará as bibliotecas internas +-- e criará o elm-package.json, onde a informação sobre seu projeto é mantida. + +-- O reactor é um servidor que compila e roda seus arquivos. +-- Clique na chave ao lado dos nomes de arquivo para entrar no depurador de +-- viagem no tempo. +$ elm reactor + +-- Teste expressões simples no Read-Eval-Print Loop. +$ elm repl + +-- Pacotes são identificados pelo usuário e nome do repositório no GitHub. +-- Instale um novo pacote e registre-o no elm-package.json. +$ elm package install evancz/elm-html + +-- Veja o que mudou entre as versões de um pacote. +$ elm package diff evancz/elm-html 3.0.0 4.0.2 +-- O gerenciador de pacotes do Elm obriga o versionamento semântico, logo +-- mudanças de versões no minor nunca quebrará o seu build! +``` + +A linguagem Elm é supreendentemente pequena. Agora você pode olhar para quase +qualquer código-fonte em Elm e ter uma ideia aproximada do que está acontecendo. +No entanto, as possibilidades para código resistente a erros e de fácil +refatoração são infinitas! + +Aqui estão algumas referências utéis. + +* O [site do Elm](http://elm-lang.org/). Ele inclui: + * Links para os [instaladores](http://elm-lang.org/install) + * [Documentação](http://elm-lang.org/docs), incluindo [a referência de sintaxe](http://elm-lang.org/docs/syntax) + * Muitos [exemplos](http://elm-lang.org/examples) úteis + +* Documentação para as [bibliotecas internas do Elm](http://package.elm-lang.org/packages/elm-lang/core/latest/). Tome nota de: + * [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), que é importada por padrão + * [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) e seu primo [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), comumente utilizados para valores faltantes e manipulação de erros + * Estruturas de dados como [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) e [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set) + * [Codificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) e [decodificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode) JSON + +* [A Arquitetura Elm](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Uma dissertação pelo criador do Elm com exemplos sobre como organizar código em componentes. + +* A [lista de e-mail do Elm](https://groups.google.com/forum/#!forum/elm-discuss). Todos são amigáveis e solícitos. + +* [Escopo em Elm](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) e [Como Ler uma Anotação de Tipo](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Mais sobre guias da comunidade sobre o básico de Elm escrito por desenvolvedores JavaScript. + +Saia e escreva algum código Elm! diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown index 981da503..e59ba901 100644 --- a/pt-br/git-pt.html.markdown +++ b/pt-br/git-pt.html.markdown @@ -2,11 +2,15 @@ category: tool tool: git lang: pt-br -filename: LearnGit.txt +filename: LearnGit-br.txt contributors: - ["Jake Prather", "http://github.com/JakeHP"] + - ["Leo Rudberg" , "http://github.com/LOZORD"] + - ["Betsy Lorton" , "http://github.com/schbetsy"] + - ["Bruno Volcov", "http://github.com/volcov"] translators: - ["Suzane Sant Ana", "http://github.com/suuuzi"] + - ["Bruno Volcov", "http://github.com/volcov"] --- Git é um sistema distribuido de gestão para código fonte e controle de versões. @@ -28,7 +32,7 @@ a um arquivo ou conjunto de arquivos ao longo do tempo. de arquivos. * Controle de versão distribuído foca em compartilhar alterações. Cada alteração é associada a um *id* único. -* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema +* Sistemas distribuídos não têm estrutura definida. É possivel ter um sistema centralizado ao estilo SVN usando git. [Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control) @@ -52,7 +56,7 @@ referências. Pode ser descrito como uma estrutura de dados de código fonte com a particularidade de cada elemento do código fonte permitir acesso ao histórico das suas alterações, entre outras coisas. -Um repositório git é constituido pelo diretório .git e a *working tree* +Um repositório git é constituído pelo diretório .git e a *working tree* ### Diretório .git (componente do repositório) @@ -84,6 +88,11 @@ Um *branch* é essencialmente uma referência que aponta para o último *commit* efetuado. Na medida que são feitos novos commits, esta referência é atualizada automaticamente e passa a apontar para o commit mais recente. +### *Tag* + +Uma tag é uma marcação em um ponto específico da história. Geralmente as +pessoas usam esta funcionalidade para marcar pontos de release (v2.0, e por aí vai) + ### *HEAD* e *head* (componentes do diretório .git) *HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem @@ -131,10 +140,10 @@ Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da # Ver rapidamente os comandos disponiveis $ git help -# Ver todos os comandos disponiveis +# Ver todos os comandos disponíveis $ git help -a -# Usar o *help* para um comando especifico +# Usar o *help* para um comando específico # git help <comando_aqui> $ git help add $ git help commit @@ -149,7 +158,7 @@ do repositório) e o *commit* da *HEAD* atual. ```bash # Apresenta o *branch*, arquivos não monitorados, alterações e outras -# difereças +# diferenças $ git status # Para aprender mais detalhes sobre git *status* @@ -196,6 +205,29 @@ $ git branch -m myBranchName myNewBranchName $ git branch myBranchName --edit-description ``` +### Tag + +Gerencia as *tags* + +```bash +# Listar tags +$ git tag +# Criar uma tag anotada. +# O parâmetro -m define uma mensagem, que é armazenada com a tag. +# Se você não especificar uma mensagem para uma tag anotada, +# o Git vai rodar seu editor de texto para você digitar alguma coisa. +$ git tag -a v2.0 -m 'minha versão 2.0' +# Mostrar informações sobre a tag +# O comando mostra a informação da pessoa que criou a tag, +# a data de quando o commit foi taggeado, +# e a mensagem antes de mostrar a informação do commit. +$ git show v2.0 +# Enviar uma tag para o repositório remoto +$ git push origin v2.0 +# Enviar várias tags para o repositório remoto +$ git push origin --tags +``` + ### checkout Atualiza todos os arquivos no diretório do projeto para que fiquem iguais @@ -368,7 +400,7 @@ perigoso quando não há certeza do que se está fazendo. ```bash # Restabelece a camada intermediária de registo para o último -# commit (o directório fica sem alterações) +# commit (o diretório fica sem alterações) $ git reset # Restabelece a camada intermediária de registo para o último commit, e diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown index 885d5b27..aed23df1 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: @@ -9,7 +9,7 @@ translators: lang: pt-br --- -Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://groovy.codehaus.org) +Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http://www.groovy-lang.org/) ```groovy @@ -226,17 +226,19 @@ for (i in array) { //Itera sobre um mapa def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] -x = 0 +x = "" for ( e in map ) { x += e.value + x += " " } +assert x.equals("Roberto Grails Groovy ") /* Operadores Sobrecarregamento de Operadores para uma lsita dos operadores comuns que Grooby suporta: - http://groovy.codehaus.org/Operator+Overloading + http://www.groovy-lang.org/operators.html#Operator-Overloading Operadores Groovy úteis */ @@ -255,7 +257,7 @@ def nomeUsuario = usuario?.nomeUsuario Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método. É um pedação de código que é definido e executado em um momento posterior. - Mais informação em: http://groovy.codehaus.org/Closures+-+Formal+Definition + Mais informação em: http://www.groovy-lang.org/closures.html */ //Exemplo: def clos = { println "Hello World!" } @@ -413,11 +415,11 @@ assert soma(2,5) == 7 ## Referências -[Groovy documentation](http://groovy.codehaus.org/Documentation) +[Groovy documentation](http://www.groovy-lang.org/documentation.html) [Groovy web console](http://groovyconsole.appspot.com/) -Junte-se a um [grupo de usuários Groovy](http://groovy.codehaus.org/User+Groups) +Junte-se a um [grupo de usuários Groovy](http://www.groovy-lang.org/usergroups.html) ## Livro 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. diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown index 788dc1d2..181aa471 100644 --- a/pt-br/haskell-pt.html.markdown +++ b/pt-br/haskell-pt.html.markdown @@ -93,7 +93,7 @@ not False -- Nega uma falácia "AbBbbcAbbcbBbcbcb" !! 2 -- 'B' ---------------------------------------------------- --- Listas e Túplas +-- 2. Listas e Túplas ---------------------------------------------------- -- A construção de uma lista precisa ser de elementos homogêneos diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown index 4230579d..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: @@ -171,6 +171,6 @@ Este tutorial é apenas uma introdução básica para hy/lisp/python. Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org) -Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy) +Repo Hy no GitHub: [http://github.com/hylang/hy](http://github.com/hylang/hy) Acesso ao freenode irc com #hy, hashtag no twitter: #hylang diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown index a884f273..1b9d7fc6 100644 --- a/pt-br/java-pt.html.markdown +++ b/pt-br/java-pt.html.markdown @@ -42,7 +42,7 @@ public class LearnJava { " Double: " + 3.14 + " Boolean: " + true); - // Para imprimir sem inserir uma nova lina, use o System.out.print + // Para imprimir sem inserir uma nova linha, use o System.out.print System.out.print("Olá "); System.out.print("Mundo"); @@ -214,42 +214,42 @@ public class LearnJava { //Iteração feita 10 vezes, fooFor 0->9 } System.out.println("Valor do fooFor: " + fooFor); - - // O Loop For Each + + // O Loop For Each // Itera automaticamente por um array ou lista de objetos. int[] fooList = {1,2,3,4,5,6,7,8,9}; //estrutura do loop for each => for(<objeto> : <array_de_objeto>) //lê-se: para cada objeto no array //nota: o tipo do objeto deve ser o mesmo do array. - + for( int bar : fooList ){ //System.out.println(bar); //Itera 9 vezes e imprime 1-9 em novas linhas } - + // Switch // Um switch funciona com os tipos de dados: byte, short, char e int // Ele também funciona com tipos enumerados (vistos em tipos Enum) // como também a classe String e algumas outras classes especiais // tipos primitivos: Character, Byte, Short e Integer - int mes = 3; - String mesString; - switch (mes){ + int mes = 3; + String mesString; + switch (mes){ case 1: - mesString = "Janeiro"; + mesString = "Janeiro"; break; case 2: - mesString = "Fevereiro"; + mesString = "Fevereiro"; break; case 3: - mesString = "Março"; + mesString = "Março"; break; default: - mesString = "Algum outro mês"; + mesString = "Algum outro mês"; break; } System.out.println("Resultado do Switch: " + mesString); - + // Condição de forma abreviada. // Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas. // Lê-se "Se (declaração) é verdadeira, use <primeiro valor> @@ -287,9 +287,9 @@ public class LearnJava { // Classes e Métodos /////////////////////////////////////// - System.out.println("\n->Classes e Métodos"); + System.out.println("\n->Classes e Métodos"); - // (segue a definição da classe Bicicleta) + // (segue a definição da classe Bicicleta) // Use o new para instanciar uma classe Bicicleta caloi = new Bicicleta(); // Objeto caloi criado. @@ -318,9 +318,9 @@ class Bicicleta { // Atributos/Variáveis da classe Bicicleta. public int ritmo; // Public: Pode ser acessada em qualquer lugar. - private int velocidade; // Private: Apenas acessível a classe. + private int velocidade; // Private: Apenas acessível a classe. protected int catraca; // Protected: Acessível a classe e suas subclasses. - String nome; // default: Apenas acessível ao pacote. + String nome; // default: Apenas acessível ao pacote. // Construtores são uma forma de criação de classes // Este é o construtor padrão. @@ -388,7 +388,7 @@ class Bicicleta { // Velocipede é uma subclasse de bicicleta. class Velocipede extends Bicicleta { // (Velocípedes são bicicletas com rodas dianteiras grandes - // Elas não possuem catraca.) + // Elas não possuem catraca.) public Velocipede(int ritmoInicial, int velocidadeInicial){ // Chame o construtor do pai (construtor de Bicicleta) com o comando super. @@ -405,6 +405,223 @@ class Velocipede extends Bicicleta { } +// Interfaces +// Sintaxe de declaração de Interface +// <nível de acesso> interface <nome-da-interface> extends <super-interfaces> { +// // Constantes +// // Declarações de método +//} + +// Exemplo - Comida: +public interface Comestivel { + public void comer(); // Qualquer classe que implementa essa interface, deve + // implementar este método. +} + +public interface Digestivel { + public void digerir(); + // Em Java 8, interfaces podem ter métodos default. + // public void digerir() { + // System.out.println("digerindo ..."); + // } +} + + +// Agora podemos criar uma classe que implementa ambas as interfaces. +public class Fruta implements Comestivel, Digestivel { + + @Override + public void comer() { + // ... + } + + @Override + public void digerir() { + // ... + } +} + +// Em Java, você pode estender somente uma classe, mas você pode implementar muitas +// interfaces. Por exemplo: +public class ClasseExemplo extends ExemploClassePai implements InterfaceUm, + InterfaceDois { + + @Override + public void InterfaceUmMetodo() { + } + + @Override + public void InterfaceDoisMetodo() { + } + +} + +// Classes abstratas + +// Sintaxe de declaração de classe abstrata +// <Nível de acesso> abstract <nome-da-classe-abstrata> extends <estende super-abstratas-classes> { +// // Constantes e variáveis +// // Declarações de método +//} + +// Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem +// ser definidos em uma classe filha. Semelhante às interfaces, classes abstratas não podem +// ser instanciadas, ao invés disso devem ser estendidas e os métodos abstratos +// definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de +// métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo, +// a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um +// classe abstrata. Classes abstratas também PODEM ter o método "main". + +public abstract class Animal +{ + public abstract void fazerSom(); + + // Método pode ter um corpo + public void comer() + { + System.out.println("Eu sou um animal e estou comendo."); + //Nota: Nós podemos acessar variáveis privadas aqui. + idade = 30; + } + + // Não há necessidade de inicializar, no entanto, em uma interface + // a variável é implicitamente final e, portanto, tem + // de ser inicializada. + protected int idade; + + public void mostrarIdade() + { + System.out.println(idade); + } + + //Classes abstratas podem ter o método main. + public static void main(String[] args) + { + System.out.println("Eu sou abstrata"); + } +} + +class Cachorro extends Animal +{ + + // Nota: ainda precisamos substituir os métodos abstratos na + // classe abstrata. + @Override + public void fazerSom() + { + System.out.println("Bark"); + // idade = 30; ==> ERRO! idade é privada de Animal + } + + // NOTA: Você receberá um erro se usou a + // anotação Override aqui, uma vez que java não permite + // sobrescrita de métodos estáticos. + // O que está acontecendo aqui é chamado de "esconder o método". + // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Cachorro pluto = new Cachorro(); + pluto.fazerSom(); + pluto.comer(); + pluto.mostrarIdade(); + } +} + +// Classes Finais + +// Sintaxe de declaração de classe final +// <nível de acesso> final <nome-da-classe-final> { +// // Constantes e variáveis +// // Declarações de método +//} + +// Classes finais são classes que não podem ser herdadas e são, portanto, um +// filho final. De certa forma, as classes finais são o oposto de classes abstratas, +// porque classes abstratas devem ser estendidas, mas as classes finais não podem ser +// estendidas. +public final class TigreDenteDeSabre extends Animal +{ + // Nota: Ainda precisamos substituir os métodos abstratos na + // classe abstrata. + @Override + public void fazerSom(); + { + System.out.println("Roar"); + } +} + +// Métodos Finais +public abstract class Mamifero() +{ + // Sintaxe de Métodos Finais: + // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>) + + // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha, + // e são, portanto, a implementação final do método. + public final boolean EImpulsivo() + { + return true; + } +} + + +// Tipo Enum +// +// Um tipo enum é um tipo de dado especial que permite a uma variável ser um conjunto de constantes predefinidas. A +// variável deve ser igual a um dos valores que foram previamente definidos para ela. +// Por serem constantes, os nomes dos campos de um tipo de enumeração estão em letras maiúsculas. +// Na linguagem de programação Java, você define um tipo de enumeração usando a palavra-chave enum. Por exemplo, você poderia +// especificar um tipo de enum dias-da-semana como: + +public enum Dia { + DOMINGO, SEGUNDA, TERÇA, QUARTA, + QUINTA, SEXTA, SABADO +} + +// Nós podemos usar nosso enum Dia assim: + +public class EnumTeste { + + // Variável Enum + Dia dia; + + public EnumTeste(Dia dia) { + this.dia = dia; + } + + public void digaComoE() { + switch (dia) { + case SEGUNDA: + System.out.println("Segundas são ruins."); + break; + + case SEXTA: + System.out.println("Sextas são melhores."); + break; + + case SABADO: + case DOMINGO: + System.out.println("Finais de semana são os melhores."); + break; + + default: + System.out.println("Dias no meio da semana são mais ou menos."); + break; + } + } + + public static void main(String[] args) { + EnumTeste primeiroDia = new EnumTeste(Dia.SEGUNDA); + primeiroDia.digaComoE(); // => Segundas-feiras são ruins. + EnumTeste terceiroDia = new EnumTeste(Dia.QUARTA); + terceiroDia.digaComoE(); // => Dias no meio da semana são mais ou menos. + } +} + +// Tipos Enum são muito mais poderosos do que nós mostramos acima. +// O corpo de um enum pode incluir métodos e outros campos. +// Você pode ver mais em https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html + ``` ## Leitura Recomendada @@ -413,11 +630,11 @@ Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, u Outros tópicos para pesquisar: -* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html) +* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html) * [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) -* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): +* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): * [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) * [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) * [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) @@ -433,3 +650,9 @@ Outros tópicos para pesquisar: Livros: * [Use a cabeça, Java] (http://www.headfirstlabs.com/books/hfjava/) + +Apostila: + +* [Java e Orientação a Objetos] (http://www.caelum.com.br/apostila-java-orientacao-objetos/) + +* [Java para Desenvolvimento Web] (https://www.caelum.com.br/apostila-java-web/) diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown new file mode 100644 index 00000000..ed4a6ff3 --- /dev/null +++ b/pt-br/javascript-pt.html.markdown @@ -0,0 +1,543 @@ +--- +language: javascript +filename: javascript-pt.js +contributors: + - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Ariel Krakowski", "http://www.learneroo.com"] +translators: + - ["Willian Justen", "http://willianjusten.com.br"] +lang: pt-br +--- + +JavaScript foi criada por Brendan Eich, funcionário da Netscape na época, em 1995. Ela +foi originalmente criada para ser uma linguagem de script para websites, +complementando o uso de Java para aplicações web mais complexas, mas a sua +integração com páginas web e seu suporte nativo nos browsers fez com que +ela se tornasse mais comum que Java no frontend web. + +Javascript não é somente limitada a browsers web, existindo o Node.js, +que é um projeto que fornece um interpretador baseado no motor V8 do Google +Chrome e está se tornando cada vez mais famoso. + +Feedback são muito apreciados! Você me encontrar em +[@adambrenecki](https://twitter.com/adambrenecki), ou +[adam@brenecki.id.au](mailto:adam@brenecki.id.au). + +```js +// Comentários são como em C. Comentários de uma linha começam com duas barras, +/* e comentários de múltiplas linhas começam com barra-asterisco + e fecham com asterisco-barra */ + +// comandos podem ser terminados com ; +facaAlgo(); + +// ... mas eles não precisam ser, o ponto-e-vírgula é automaticamente +// inserido quando há uma nova linha, exceto alguns casos. +facaAlgo() + +// Como esses casos podem causar resultados inesperados, vamos continuar +// a usar ponto-e-vírgula neste guia. + +/////////////////////////////////// +// 1. Números, Strings e Operadores + +// Javascript tem um tipo de número (que é o 64-bit IEEE 754 double). +// Doubles tem uma mantissa 52-bit, que é suficiente para guardar inteiros +// acima de 9✕10¹⁵ precisamente. +3; // = 3 +1.5; // = 1.5 + +// A aritmética básica funciona como seria de se esperar. +1 + 1; // = 2 +0.1 + 0.2; // = 0.30000000000000004 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Inclusive divisão desigual. +5 / 2; // = 2.5 + +// Operadores Bitwise também funcionam; quando você faz uma operação bitwise +// seu float é convertido para um int de até 32 bits. +1 << 2; // = 4 + +// A precedência é aplicada com parênteses. +(1 + 3) * 2; // = 8 + +// Existem três especiais valores não-é-número-real: +Infinity; // resultado de 1/0 +-Infinity; // resultado de -1/0 +NaN; // resultado de 0/0 + +// Existe também o tipo booleano. +true; +false; + +// Strings são criados com ' ou ". +'abc'; +"Olá, mundo"; + +// Negação usa o símbolo ! +!true; // = false +!false; // = true + +// Igualdade é o sinal de === +1 === 1; // = true +2 === 1; // = false + +// Desigualdade é o sinal de !== +1 !== 1; // = false +2 !== 1; // = true + +// Mais comparações +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Strings são concatenadas com + +"Olá " + "mundo!"; // = "Olá mundo!" + +// e comparadas com < e > +"a" < "b"; // = true + +// A comparação de tipos não é feita com o uso de ==... +"5" == 5; // = true +null == undefined; // = true + +// ...a menos que use === +"5" === 5; // = false +null === undefined; // = false + +// ...isso pode resultar em comportamentos estranhos... +13 + !0; // 14 +"13" + !0; // '13true' + +// Você pode acessar caracteres de uma String usando o `charAt` +"Isto é uma String".charAt(0); // = 'I' + +// ...ou usar `substring` para pegar pedaços maiores. +"Olá mundo".substring(0, 3); // = "Olá" + +// `length` é uma propriedade, portanto não use (). +"Olá".length; // = 3 + +// Existe também o `null` e o `undefined`. +null; // usado para indicar um valor não considerado +undefined; // usado para indicar um valor que não é a atualmente definido + // (entretando `undefined` é considerado de fato um valor + +// false, null, undefined, NaN, 0 and "" são valores falsos; +// qualquer outro valor é verdadeiro +// Note que 0 é falso e "0" é verdadeiro, até mesmo 0 == "0". + +/////////////////////////////////// +// 2. Variáveis, Arrays e Objetos + +// Variáveis são declaradas com a palavra-chave `var`. O Javascript é +// dinâmicamente tipado, portanto você não precisa especificar o tipo. +// Atribuições usam um simples caracter de `=`. +var someVar = 5; + +// se você deixar de colocar a palavra-chave var, você não irá receber um erro... +someOtherVar = 10; + +// ...mas sua variável será criada no escopo global, não no escopo em que você +// definiu ela. + +// Variáveis declaradas sem receberem um valor são definidas como `undefined`. +var someThirdVar; // = undefined + +// Existe um shorthand para operações matemáticas em variáveis: +someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora +someVar *= 10; // agora someVar é 100 + +// e um para adição e subtração de 1 +someVar++; // agora someVar é 101 +someVar--; // volta para 100 + +// Arrays são listas ordenadas de valores, de qualquer tipo. +var myArray = ["Olá", 45, true]; + +// Seus membros podem ser acessados usando a sintaxe de colchetes. +// O indíce de um Array começa pelo 0. +myArray[1]; // = 45 + +// Arrays são mutáveis e de tamanho variável. +myArray.push("World"); +myArray.length; // = 4 + +// Adicionar/modificar em um índice específico +myArray[3] = "Hello"; + +// Objetos de Javascript são equivalentes aos dicionários ou maps de outras +// linguagens: uma coleção não ordenada de pares chave-valor. +var myObj = {chave1: "Olá", chave2: "Mundo"}; + +// Chaves são strings, mas as aspas não são necessárias se elas são +// identificadores válidos no Javascript. Valores podem ser de qualquer tipo. +var myObj = {myKey: "myValue", "my other key": 4}; + +// Atributos de objetos também podem ser acessados com a sintaxe de colchetes. +myObj["my other key"]; // = 4 + +// ... ou usando a sintaxe de ponto, passando a chave que é um identificador +// válido. +myObj.myKey; // = "myValue" + +// Objetos são mutáveis, valores podem ser modificados e novas chaves +// adicionadas. +myObj.myThirdKey = true; + +// Se você tentar acessar um valor que não foi determinado ainda, você irá +// receber `undefined`. +myObj.myFourthKey; // = undefined + +/////////////////////////////////// +// 3. Lógica e Estruturas de Controle + +// A sintaxe para essa seção é quase idêntica a maioria das linguagens. + +// A estrutura `if` funciona como deveria ser. +var count = 1 +if (count == 3){ + // executa se count é 3 +} else if (count == 4){ + // executa se count é 4 +} else { + // executa se count não é 3 nem 4 +} + +// Como se faz um `while`. +while (true){ + // Um loop infinito! +} + +// Os loops do-while são como os loops de while, exceto quando eles sempre +// executam pelo menos uma vez. +do { + input = getInput(); +} while (!isValid(input)) + +// O loop `for` é o mesmo de C e Java: +// inicialização, condição para continuar; iteração +for (var i = 0; i < 5; i++){ + // vai rodar cinco vezes +} + +// && é o `e` lógico , || é o `ou` lógico +if (house.size == "big" && house.colour == "blue"){ + house.contains = "bear"; +} +if (cor == "red" || cor == "blue"){ + // cor é vermelha OU azul +} + +// && e || "pequeno circuito", é útil para determinar valores padrões. +var name = otherName || "padrão"; + +// O `switch` checa pela igualdade com `===`. +// Use `break` após cada `case` +grade = 'B'; +switch (grade) { + case 'A': + console.log("Great job"); + break; + case 'B': + console.log("OK job"); + break; + case 'C': + console.log("You can do better"); + break; + default: + console.log("Oy vey"); + break; +} + + +/////////////////////////////////// +// 4. Funções, Escopos e Closures + +// Funções Javascript são declaradas com a palavra-chave `function`. +function myFunction(thing){ + return thing.toUpperCase(); +} +myFunction("foo"); // = "FOO" + +// Repare que o valor a ser retornado deve começar na mesma linha que +// a palavra-chave `return`, senão você sempre irá retornar `undefined` +// visto que o ponto-e-vírgula é inserido automáticamente nas quebras de +// linha. Preste atenção quando usar o estilo Allman. +function myFunction() +{ + return // <- ponto-e-vírgula adicionado automaticamente aqui + { + thisIsAn: 'object literal' + } +} +myFunction(); // = undefined + +// Funções Javascript são objetos de primeira classe, portanto elas podem +// ser atribuídas a nomes de variáveis e serem passadas para outras funções +// como argumentos - por exemplo, quando criamos um manipulador de eventos: +function myFunction(){ + // este código será chamado em 5 segundos +} +setTimeout(myFunction, 5000); +// Nota: `setTimeout` não é parte da linguagem Javascript, mas é provido pelos +// browsers e o Node.js. + +// Objetos de funções não precisam nem serem declarados com nome - você pode +// escrever a definição de uma função anônima diretamente nos argumentos de +// outra função. +setTimeout(function(){ + // este código será chamado em 5 segundos +}, 5000); + +// O Javascript tem escopo de função; as funções tem seu próprio escopo, +// mas outros blocos não. +if (true){ + var i = 5; +} +i; // = 5 - não `undefined` como você esperaria numa linguagem de blogo-escopo + +// Isso levou a padrão comum chamado de IIFE (Imediately Invoked Function +// Expression) ou (Expressão de Função Invocada Imediatamente), que previne +// que variáveis temporárias vazem para o escopo global. +(function(){ + var temporary = 5; + // Nós podemos acessar o escopo global definindo o "objeto global", que + // no browser vai ser sempre `window`. O objeto global pode ter um nome + // diferente para ambiente não-browser como o Node.js. + window.permanent = 10; +})(); +temporary; // levanta um erro de referência inexiste +permanent; // = 10 + +// Uma das principais características do Javascript é a closure. Que é +// uma função definida dentro de outra função, a função interna pode acessar +// todas as variáveis da função externa, mesmo depois da função de fora +// finalizar sua execução. +function sayHelloInFiveSeconds(name){ + var prompt = "Hello, " + name + "!"; + + // Funções internas são colocadas no escopo local por padrão, assim como + // se fossem declaradas com `var`. + function inner(){ + alert(prompt); + } + setTimeout(inner, 5000); + // `setTimeout` é assíncrono, portanto a função `sayHelloInFiveSeconds` + // vai sair imediatamente, e o `setTimeout` irá chamar a interna depois. + // Entretanto. como a interna é fechada dentro de "sayHelloInFiveSeconds", + // a interna permanece podendo acessar a variável `prompt` quando depois + // de chamada. +} +sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s + +/////////////////////////////////// +// 5. Mais sobre Objetos; Construtores e Prototypes + +// Objetos podem conter funções. +var myObj = { + myFunc: function(){ + return "Olá mundo!"; + } +}; +myObj.myFunc(); // = "Olá mundo!" + +// Quando uma função ligada a um objeto é chamada, ela pode acessar o objeto +// da qual foi ligada usando a palavra-chave `this`. +myObj = { + myString: "Olá mundo!", + myFunc: function(){ + return this.myString; + } +}; +myObj.myFunc(); // = "Olá mundo!" + +// O `this` só funciona para dentro do escopo do objeto, portanto, se chamarmos +// um método do objeto fora de seu escopo, este não irá funcionar. +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso +// através do `this`, até mesmo se ela não for chamada quando foi definida. +var myOtherFunc = function(){ + return this.myString.toUpperCase(); +} +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = "OLÁ MUNDO!" + +// Nós podemos também especificar um contexto onde a função irá executar, +// usando o `call` ou `apply`. + +var anotherFunc = function(s){ + return this.myString + s; +} +anotherFunc.call(myObj, " E Olá Lua!"); // = "Olá mundo! E Olá Lua!" + +// A função `apply` é praticamente a mesma coisa, mas ela pega um array +// como lista de argumentos. + +anotherFunc.apply(myObj, [" E Olá Sol!"]); // = "Olá mundo! E Olá Sol!" + +// Isto é util quando trabalhamos com uma função que aceita uma sequência de +// argumentos e você quer passar um array. + +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Mas, o `call` e `apply` são somente temporários. Quando você quiser que +// permaneça sempre no escopo, use `bind`. + +var boundFunc = anotherFunc.bind(myObj); +boundFunc(" E Olá Saturno!"); // = "Olá mundo! E Olá Saturno!" + +// `bind` também pode ser usado para parcialmente aplicar (curry) uma função. + +var product = function(a, b){ return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// Quando você invoca uma função com a palavra-chave `new`, um novo objeto +// é criado, e fica disponível para a função pela palavra-chave `this`. +// Funções são desenhadas para serem invocadas como se invocam os construtores. + +var MyConstructor = function(){ + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// Todo objeto JavaScript possui um `prototype`. Quando você tenta acessar +// uma propriedade de um objeto que não existe no objeto atual, o interpretador +// vai olhar imediatamente para o seu prototype. + +// Algumas implementações em JS deixam você acessar o objeto prototype com a +// propriedade mágica `__proto__`. Enquanto isso é util para explicar +// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de +// usar prototypes depois. + +var myObj = { + myString: "Olá Mundo!" +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 + +// Isto funciona para funções, também. +myObj.myFunc(); // = "olá mundo!" + +// É claro, se sua propriedade não está em seu prototype, +// o prototype do prototype será procurado e por aí vai. +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + +// Não há cópia envolvida aqui; cada objeto guarda uma referência do +// prototype. Isso significa que podemos alterar o prototype e nossas mudanças +// serão refletidas em qualquer lugar. +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + + +// Nós mencionamos que o `__proto__` não é uma forma padrão, e não há uma +// forma padrão de mudar o prototype de um objeto já existente. Entretanto, +// existem duas formas de se criar um objeto com um dado prototype. + +// A primeira forma é `Object.create`, que é uma adição recente do JS, +// e ainda não está disponível em todas as implementações. +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// A segunda forma, que funciona em qualquer lugar, é feita com construtores. +// Construtores tem uma propriedade chamada prototype. Este *não* é o prototype +// do construtor em si; ao invés disso, ele é o prototype dos novos objetos +// criados pelo construtor. +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function(){ + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// Tipos originais da linguagem como strings e números também possuem +// construtores equivalentes. +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// Exceto, que eles não são totalmente equivalentes. +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0){ + // O código não vai executar, porque 0 é um valor falso. +} + +// Entretanto, esses objetos encapsulados e as funções originais compartilham +// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string, +// por exemplo. +String.prototype.firstCharacter = function(){ + return this.charAt(0); +} +"abc".firstCharacter(); // = "a" + +// Esse fato é usado para criar os chamados `polyfills`, que implementam +// uma nova característica do Javascript em uma versão mais velha, para que +// assim funcionem em ambientes mais velhos como browsers ultrapassados. + +// Havíamos mencionado que `Object.create` não estava ainda disponível em +// todos as implementações, mas nós podemos usá-lo com esse polyfill: +if (Object.create === undefined){ // Não o sobrescreve se já existir + Object.create = function(proto){ + // faz um construtor temporário com o prototype certo + var Constructor = function(){}; + Constructor.prototype = proto; + // então utiliza o new para criar um objeto prototype apropriado + return new Constructor(); + } +} +``` + +## Leitura Adicional + +O [Mozilla Developer +Network](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript) dispõe de uma +excelente documentação sobre Javascript e seu uso nos browsers. E mais, +é uma wiki, portanto conforme você vai aprendendo, mais você pode ir ajudando +os outros compartilhando do seu conhecimento. + +[Uma re-introdução do JavaScript pela MDN] +(https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +cobre muito dos conceitos abordados aqui em mais detalhes. Este guia fala +somente sobre a linguagem JavaScript em si; se você quiser aprender mais +sobre e como usar o JavaScript em páginas na web, comece aprendendo sobre +[Document Object +Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Aprenda Javascript por Exemplos e com Desafios](http://www.learneroo.com/modules/64/nodes/350) é uma +variação desse guia com desafios. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) é um guia +profundo de todas as partes do JavaScript. + +[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) é o guia clássico +/ livro de referência. + +Parte desse artigo foi adaptado do tutorial de Python do Louie Dinh que está +nesse site e do [Tutorial de JS](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +da Mozilla Developer Network. diff --git a/pt-br/jquery-pt.html.markdown b/pt-br/jquery-pt.html.markdown new file mode 100644 index 00000000..d49bea0f --- /dev/null +++ b/pt-br/jquery-pt.html.markdown @@ -0,0 +1,131 @@ +--- +category: tool +tool: jquery +contributors: + - ["Sawyer Charles", "https://github.com/xssc"] +translators: + - ["Nikolas Silva", "https://github.com/nikolassilva"] +filename: jquery-pt.js +lang: pt-br +--- + +jQuery é uma biblioteca JavaScript que te ajuda a "fazer mais, escrevendo menos". Ela faz com que muitas tarefas comuns em JavaScript sejam mais simples de escrever. jQuery é usado por grandes empresas e desenvolvedores do mundo todo. Ela torna o AJAX, manipulação de eventos, manipulação do DOM, entre outros, mais fácil e rápido. + +Pelo jQuery ser uma biblioteca JavaScript você deve [aprende-lo primeiro](https://learnxinyminutes.com/docs/pt-br/javascript-pt/) + +```js + + +/////////////////////////////////// +// 1. Seletores + +// Seletores no jQuery são usados para selecionar um elemento +var page = $(window); // Seleciona toda a viewport + +// Seletores também podem ser na forma do CSS +var paragraph = $('p'); // Seleciona todos elementos de parágrafo +var table1 = $('#table1'); // Seleciona o elemento com id 'table1' +var squares = $('.square'); // Seleciona todos elementos com classe 'square' +var square_p = $('p.square') // Seleciona todos elementos de parágrafo com a classe 'square' + + +/////////////////////////////////// +// 2. Eventos e Efeitos +// jQuery é muito bom em manipular o que acontece quando um evento é disparado +// Um evento muito usado é o 'ready' +// Você pode usar o método ready para esperar até que um elemento tenha terminado de carregar +$(document).ready(function(){ + // O código não será executado até que o documento carregue +}); +// Você também pode usar funções declaradas +function onAction() { + // Isso será executado quando um evento for disparado +} +$('#btn').click(onAction); // Chama 'onAction' quando o elemento receber um clique + +// Outros eventos comuns são: +$('#btn').dblclick(onAction); // Clique duplo +$('#btn').hover(onAction); // Mouse sobre elemento +$('#btn').focus(onAction); // Elemento recebe foco +$('#btn').blur(onAction); // Elemento perde foco +$('#btn').submit(onAction); // Envio de formulário +$('#btn').select(onAction); // Quando o elemento é selecionado +$('#btn').keydown(onAction); // Quando uma tecla é segurada +$('#btn').keyup(onAction); // Quando uma tecla é solta +$('#btn').keypress(onAction); // Quando uma tecla é pressionada +$('#btn').mousemove(onAction); // Quando o mouse é movido +$('#btn').mouseenter(onAction); // Quando o mouse entra no elemento +$('#btn').mouseleave(onAction); // Quando o mouse sai do elemento + + +// Eles também podem disparar os eventos em vez de manipulá-los, +// simplesmente deixando de passar os parâmetros +$('#btn').dblclick(); // Dispara um clique duplo no elemento + +// Você pode manipular múltiplos eventos usando o seletor apenas uma vez +$('#btn').on( + {dblclick: myFunction1} // Disparado num clique duplo + {blur: myFunction1} // Disparado quando perder o foco +); + +// Você pode mover e esconder elementos com alguns métodos de efeito +$('.table').hide(); // Esconde o elemento + +// Nota: chamar uma função nesse método ainda irá esconder o elemento +$('.table').hide(function(){ + // Elemento é escondido e a função é executada +}); + +// Você pode guardar seletores em variáveis +var tables = $('.table'); + +// Alguns métodos básicos de manipulação do DOM: +tables.hide(); // Esconde elemento(s) +tables.show(); // Exibe elemento(s) +tables.toggle(); // Alterna entre esconder/exibir +tables.fadeOut(); // Efeito fade out +tables.fadeIn(); // Efeito fade in +tables.fadeToggle(); // Alterna entre fade out/in +tables.fadeTo(0.5); // Efeito fade com opacidade específica (entre 0 e 1) +tables.slideUp(); // Efeito de deslize pra cima +tables.slideDown(); // Efeito de deslize pra baixo +tables.slideToggle(); // Alterna entre deslizar pra cima/baixo + +// Todos os métodos acima levam velocidade (em milissegundos) e uma função callback +tables.hide(1000, myFunction); // Esconde o elemento em 1 segundo e chama a função + +// No fadeTo é obrigatório definir a opacidade como segundo parâmetro +tables.fadeTo(2000, 0.1, myFunction); // 2 segundos de fade para 0.1 de opacidade e chama a função + +// Você pode fazer animações mais avançadas com o método animate +tables.animate({'margin-top':"+=50", height: "100px"}, 500, myFunction); +// O método animate leva um objeto com valores CSS, +// um parâmetro de opções para melhorar a animação +// e uma função callback, como de costume + +/////////////////////////////////// +// 3. Manipulação + +// São similares aos efeitos, mas podem fazer mais +$('div').addClass('taming-slim-20'); // Adiciona a classe taming-slim-20 em todas as divs + +// Métodos comuns de manipulação +$('p').append('Hello world'); // Adiciona ao final do elemento +$('p').attr('class'); // Obtém o valor de um atributo +$('p').attr('class', 'content'); // Define o valor de um atributo +$('p').hasClass('taming-slim-20'); // Retorna true se tiver a classe +$('p').height(); // Obtém/define a altura do elemento + + +// Pra maioria dos métodos de manipulação, pegar o valor de um +// elemento só afetará o primeiro deles +$('p').height(); // Obtém a altura da primeira tag 'p' + +// Você pode usar o método each pra percorrer os elementos +var heights = []; +$('p').each(function() { + heights.push($(this).height()); // Adiciona a altura das tags 'p' na array +}); + + +``` diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown index fc63b126..62d9ccad 100644 --- a/pt-br/json-pt.html.markdown +++ b/pt-br/json-pt.html.markdown @@ -3,6 +3,7 @@ language: json contributors: - ["Anna Harren", "https://github.com/iirelu"] - ["Marco Scannadinari", "https://github.com/marcoms"] + - ["Francisco Marques", "https://github.com/ToFran"] translators: - ["Miguel Araújo", "https://github.com/miguelarauj1o"] lang: pt-br @@ -12,10 +13,16 @@ filename: learnjson-pt.json Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o "Learn X in Y minutes" mais simples existente. -JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores -aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto, -tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si. +JSON na sua forma mais pura não tem comentários, mas a maioria dos analisadores +aceitarão comentários no estilo C (//, /\* \*/). No entanto estes devem ser evitados para otimizar a compatibilidade. +Um valor JSON pode ser um número, uma string, um array, um objeto, um booleano (true, false) ou null. + +Os browsers suportados são: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, e Safari 4.0+. + +A extensão dos ficheiros JSON é “.json” e o tipo de mídia de Internet (MIME) é “application/json”. + +Mais informação em: http://www.json.org/ ```json { @@ -35,7 +42,7 @@ tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si. "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5], "outro objeto": { - "ccomentário": "Estas coisas podem ser aninhadas, muito úteis." + "comentário": "Estas coisas podem ser aninhadas, muito úteis." } }, @@ -57,6 +64,6 @@ tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si. , "outro comentário": "que bom" }, - "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.". + "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer." } ``` diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown new file mode 100644 index 00000000..48d97e58 --- /dev/null +++ b/pt-br/julia-pt.html.markdown @@ -0,0 +1,748 @@ +--- +language: Julia +filename: learnjulia-pt.jl +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +translators: + - ["Davidson Mizael", "https://github.com/davidsonmizael"] +lang: pt-br +--- + +Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python. + +Este tutorial é baseado no Julia 0.3. + +```ruby +# Linhas únicas de comentários começam com o simbolo hash(jogo da velha). +#= Comentários de multiplas linhas podem ser escritos + colocando '#=' antes do texto e '=#' + após o texto. Eles também podem ser agrupados +=# + +#################################################### +## 1. Tipos primitivos e operadores +#################################################### + +# Tudo em Julia é uma expressão. + +# Há muitos tipos básicos de numeros. +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# Todos os operadores inseguros normais estão disponiveis. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # dividir um Int por um Int resulta em um float +div(5, 2) # => 2 # para um restultado truncado, use div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # elevado,não o opeardor binário xor +12 % 10 # => 2 + +# Impõe a priodidade nos parenteses +(1 + 3) * 2 # => 8 + +# Operadores binarios +~2 # => -3 # not +3 & 5 # => 1 # and +2 | 4 # => 6 # or +2 $ 4 # => 6 # xor +2 >>> 1 # => 1 # deslocamento lógico de bits a direita +2 >> 1 # => 1 # deslocamento aritmético de bits a direita +2 << 1 # => 4 # deslocamento lógico/aritmético de bits a esquerda + +# Você pode usar a função bits para ver a representação binária de um numero. +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# Valores booleanos são primitivos. +true +false + +# Operadores booleanos +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# Comparações podem ser encadeadas +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# Strings são criadas com " +"Isso é uma String." + +# Caracteres literais são escritos com ' +'a' + +# Uma string pode ser indexada como um vetor de caracteres +"Isso é uma string"[1] # => 'I' # Julia começa a indexar a partir do 1 +# Porém isso não funcionará direito com strings em UTF8, +# portanto é recomendado usar iterações sobre uma string (map, loops com for, etc). + +# $ pode ser usado para interpolação de string: +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# Você pode usar qualquer expressão Julia dentro dos parenteses. + +# Outro jeito de formatar strings é com um macro no printf. +@printf "%d é menor que %f" 4.5 5.3 # 5 é menor que 5.300000 + +# Escrever na tela é fácil +println("Eu sou Julia. Prazer em conhece-lo!") + +#################################################### +## 2. Variáveis e coleções +#################################################### + +#Você não declara variáveis antes de atribui-lás. +some_var = 5 # => 5 +some_var # => 5 + +# Acessando a variável anterior não iniciada é um erro +try + some_other_var # => ERROR: some_other_var não definida +catch e + println(e) +end + +# Nomes de variáveis começam com uma letra. +# Depois disso, você pode usar letras, digitos, underscores e pontos de exclamação. +SomeOtherVar123! = 6 # => 6 + +# Você também pode usar caractéres unicode +☃ = 8 # => 8 +# Estes são especialmente reservados para notações matemáticas. +2 * π # => 6.283185307179586 + +# Uma nota na convenção de nomes em Julia: +# +# * A separação de palavras pode ser feita por underscores ('_'), mas o uso +# de underscore é desencorajado a menos que o nome da variável seja dificil +# de ler. +# +# * Os nomes de tipos começam com letra maiúscula e a separação de letras é +# feita a partir de CamelCase no lugar de underscores. +# +# * Nomes de funções e macros são em minúsculo, sem underscore. +# +# * Funções que modificam a própria entrada tem nomes que terminam em !. Estas +# funções são chamadas as vezes de funções de mutação ou função in-place. + +# Vetores armazenam uma sequencia de valores indexados por integer de 1 a n: +a = Int64[] # => 0-element Int64 Array + +# 1-Vetores dimensionais literais podem ter seus valores separados por virgula. +b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# 2-Vetores dimensionais usam espaço para separar valores e ponto e virgula para linhas. +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] + +# Adiciona-se coisas ao final de uma lista com push! e append! +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# Remove-se do final com pop! +pop!(b) # => 6 e 'b' agora é [4,5] + +# Vamos coloca-lo de novo +push!(b,6) # 'b' agora é [4,5,6] de novo. + +a[1] # => 1 # lembre-se que Julia indexa a partir de 1, não 0. + +# end é um atalho para a ultima posição. Pode ser usada em qualquer +# expressão indexada. +a[end] # => 6 + +# nós também temos shift e unshift +shift!(a) # => 1 e 'a' agora é [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# Funções que terminam com ponto de exclamação indicam que elas modificam +# seus argumentos. +arr = [5,4,6] # => 3-element Int64 Array: [5,4,6] +sort(arr) # => [4,5,6]; 'arr' continua [5,4,6] +sort!(arr) # => [4,5,6]; 'arr' agora é [4,5,6] + +# Olhar além dos limites é um BoundsError +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# Erros listam a linha e o nome do arquivo que ele está, mesmo se for uma +# biblioteca padrão. Se você construiu Julia pelo source, você pode olhar na +# pasta base dentro da pasta do Julia para encontrar esses arquivos. + +# Você pode inicializar vetores com limites +a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5] + +# Você pode ver até um limite com a sintaxe separada +a[1:3] # => [1, 2, 3] +a[2:end] # => [2, 3, 4, 5] + +# Remova elementos de um array pelo index com splice! +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr is now [3,5] + +# Concatene listas com append! +b = [1,2,3] +append!(a,b) # 'a' agora é [1, 2, 3, 4, 5, 1, 2, 3] + +# Cheque se um valor existe me uma lista com in +in(1, a) # => true + +# Veja o tamanho com lenght +length(a) # => 8 + +# Tuples não podem ser mudados. +tup = (1, 2, 3) # => (1,2,3) # um tuple (Int64,Int64,Int64). +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: não há metodo setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# Muitas litas de funções também trabalham com tuples +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +#Você pode desempacotar tuples para variáveis. +a, b, c = (1, 2, 3) # => (1,2,3) # 'a' agora é 1, 'b' agora é 2 e 'c' agora é 3 + +# Tuplas são criados mesmo se você deixar fora dos parenteses +d, e, f = 4, 5, 6 # => (4,5,6) + +# Uma tupla de um elemento é diferente do valor que ele contém +(1,) == 1 # => false +(1) == 1 # => true + +# Olhe como é facil pra trocar dois valores +e, d = d, e # => (5,4) # 'd' agora é 5 e 'e' agora é 4 + +# Dicionários armazenam mapeamentos +empty_dict = Dict() # => Dict{Any,Any}() + +# Você pode criar um dicionário usando um literal +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# Veja os valores com [] +filled_dict["one"] # => 1 + +# Pegue todas as chaves +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Nota - as chaves dos dicionários não são ordenadas nem estão na ordem que você as inseriu. + +# Pegue todos os valores +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Nota - A mesma coisa que na nota acima sobre a ordenação das chaves. + +# Cheque pela existencia de chaves em um dicionário com in e haskey +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# Procurar por uma chave não existente irá gerar um erro +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# Use o método get para escapar desse erro passando um valor padrão +# get(dictionary,key,default_value) +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# Use sets para representar coleções de valores unicos e não ordenados +empty_set = Set() # => Set{Any}() +# Inicialize um set com valores +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# Adicione mais valores para um set +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# Cheque se um valor está no set +in(2, filled_set) # => true +in(10, filled_set) # => false + +# Não há funções para interseção de set, união e diferença. +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + +#################################################### +## 3. Controle de fluxo +#################################################### + +# Vamos fazer uma variável +some_var = 5 + +# Aqui está um if. Identação nao é importante em Julia. +if some_var > 10 + println("some_var é totalmente maior que 10.") +elseif some_var < 10 # Essa clausula elseif é opcional. + println("some_var é menor que 10.") +else # A clausula else é opcional também. + println("some_var é literalmente 10.") +end +# => exibe "some_var é menor que 10" + +# Loops for repetem sobre variaveis iteráveis. +# Tipos iterativos incluem Range, Array, set Dict e String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # Você pode interpolar variáveis usando $ ou expressões em strings +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Você pode usar 'in' no lugar de '='. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# exibe: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# Loops while circulam enquanto a condição é true +x = 0 +while x < 4 + println(x) + x += 1 # Abreveação para x = x + 1 +end +# exibe: +# 0 +# 1 +# 2 +# 3 + +# Trate exceções com um bloco try/catch +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. Funções +#################################################### + +# A palavra chave 'function' cria novas funções +#function name(arglist) +# corpo... +#end +function add(x, y) + println("x is $x and y is $y") + + # Funções retornam o valor da sua ultima declaração +t x + y +end + +add(5, 6) # => 11 after printing out "x is 5 and y is 6" + +# Você pode definir funções que tomam um numero incerto de +# argumentos +function varargs(args...) + return args + # use a palavra chave return para retornar um valor em qualquer parte da função +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# O ... é chamado de splat. +# Nós apenas o usamos na definição de uma função. +# Também pode ser usado na chamada de uma função, +# onde ela vai abrir um Array ou o conteúdo de um Tuple na lista de argumentos. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produz um Set de Arrays +Set([1,2,3]...) # => Set{Int64}(1,2,3) # isso é equivalente a Set(1,2,3) + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # um Set de Tuples +Set(x...) # => Set{Int64}(2,3,1) + +# Você pode definir funções com argumentos posicionais opcionais. +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# Você pode definir funções que tomam argumentos como palavras chaves +function keyword_args(;k1=4,name2="hello") # note the ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] + +# Você pode combinar todos os tipos de argumentos em uma só função +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# exibe: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Julia tem funções de primeira classe +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# Isso é "sintexe furiosa de lambda" pra criar funções anônimas. +(x -> x > 2)(3) # => true + +#Esta função é identica a implementação da create_adder acima. +function create_adder(x) + y -> x + y +end + +# Você também pode nomear funções internas, se você quiser +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# Há +# There are built-in higher order functions +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Nós podemos usar listas de compreensão para melhores mapeamentos +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. Tipos +#################################################### + +#Julia tem um sistema de tipos. +# Todo valor tem um tipo. Variaveis não tem tipos próprios. +# Você pode usar a função 'typeof' para pegar o valor. +typeof(5) # => Int64 + +# Tipos são valores de primeira classe. +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType é o tipo que representa tipos, incluindo ele mesmo. + +# Tipos são usados para documentação, optimização e envio +# Eles não são estaticamente checados. + +# Usuários podem definir tipos +# Eles são como records ou structs em outras linguagens. +# Novos tipos são definidos usando a palavra chave 'type' + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # não incluindo uma notação type é o mesmo que '::Any' +end + +# Os argumentos padrões de um construtor são as propriedades +# do tipo na ordem que eles são listados na definição. +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# O tipo double como construtor de função para valores desse tipo +# The type doubles as the constructor function for values of that type +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# Esses tipos no estilo struct são chamados tipos concretos +# Eles podem ser instanciados, mas não podem ter subtipos. +# O outro tipo de tipos são os tipos abstratos. + +# abstract Name +abstract Cat # apenas um nome e um ponto na hierarquia de tipo + +# Tipos abstratos podem ser instanciados, mas não podem ter subtipos. +# Por exemplo, Number é um tipo abstrato +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# Todo tipo tem um super tipo; use a função 'super' para pegá-lo. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# Todos esss tipos, exceto o Int64, são abstratos. + +# <: é o operador de subtipagem +type Lion <: Cat # Lion é um subtipo de Cat + mane_color + roar::String +end + +# Você pode definir mais construtores para seu tipo +# É só definir uma função com o mesmo nome do tipo +# e chamar um construtor existente para pegar o valor do tipo correto +Lion(roar::String) = Lion("green",roar) +# Isso é um construtor externo porque ele está fora da definição do tipo + +type Panther <: Cat # Panther também é um subtipo de Cat + eye_color + Panther() = new("green") +# Panthers terão apenas esse construtor, e não construtor padrão. +end +# Usando construtores internos, como Panther faz, lhe da o controle +# sobre como os valores dos tipos são criados. +# Quando possivel, você deve usar construtores externos mais do que internos. + +#################################################### +## 6. Multiple-Dispatch +#################################################### + + +# Em Julia todas as funções nomeadas são funções genericas +# Isso significa que elas são construidas de muitos métodos pequenos +# Cada construtor para Lion é um metodo da função genérica Lion.Lion. + +# Para um exemplo sem construtor, vamos fazer a função meow + +# Definição para Lion, Panther e Tiger +function meow(animal::Lion) + animal.roar #propriedades do tipo de acesso usando a notação ponto '.' +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# Testando a função meow +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# Revendo o tipo local de hierarchy +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# Definindo uma função que recebe Cats +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => exibe "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# Em linguagens orientadas a objeto, envio unico é comúm +# isso significa que o método é selecionado baseado no tipo do seu primeiro argumento +# Em Julia todos os tipos de argumentos contribuem na seleção do melhor método + + +# Vamos definir uma função com mais argumentos, então poderemos ver a diferença +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => exibe The orange tiger wins! +fight(tigger,Lion("ROAR")) # => exibir The orange tiger wins! + +# Vamos mudar o comportamento quando o gato é especificamente um leão +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => exobe The orange tiger wins! +fight(tigger,Lion("ROAR")) # => exobe The green-maned lion wins! + +# Nós não precisamos de um tigre para brigar +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => exibe The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# Aliás, vamos deixar o gato ir primeiro +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# Este aviso é porque não está claro qual método fight será chamado em: +fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The victorious cat says rarrr +# O resultado pode ser diferente em outras versões de Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The lions come to a tie + + +# Embaixo dos panos +# Você pode olhar o llvm e o código assembly gerado. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# O que acontece quando alimentamos square_area com um inteiro? +# What happens when we feed square_area an integer? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prólogo + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # Busca l na memoria? + # imul RAX, RAX # Faz o quadrado de l e armazena o resultado em RAX + # pop RBP # Restaura o ponteiro de base antigo + # ret # O resultado continua em RAX + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Múltiplicação escalar unica de precisão (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Duplicação ecalar de precisão multipla(AVX) + # pop RBP + # ret + # +# Note que Julia usará instruções de ponto flutuante se quaser um dos +# argumentos forem float +# Vamos calcular a área de um circulo +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Carrega inteiro (r) da memória + # movabs RAX, 4593140240 # Carrega pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## Extras + +Você pode ver mais um monte de detalhes no [manual de Julia] (http://docs.julialang.org/en/latest/manual/) +O melhor lugar pra pedir ajuda em Julia é a (muito amigável) [mailing list](https://groups.google.com/forum/#!forum/julia-users). 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/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown index 4030ce3c..f22093f9 100644 --- a/pt-br/markdown-pt.html.markdown +++ b/pt-br/markdown-pt.html.markdown @@ -56,7 +56,7 @@ __E este também está._ *--Danouse! Este também__* <!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown -Github, nós também temos: --> +GitHub, nós também temos: --> ~~Este texto é processado com tachado.~~ @@ -148,7 +148,7 @@ dentro do seu código --> John não sabia nem o que o função 'goto()' fazia! -<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código --> +<!-- Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código --> \`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ``` ruby! --> @@ -157,7 +157,7 @@ def foobar end \`\`\` <!-- Aqui também, não barras invertidas, apenas ``` --> -<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe +<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe destacando do idioma que você especificar após a ``` --> <!-- Regra Horizontal (<hr />) --> @@ -230,7 +230,7 @@ Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*. <!-- Tabelas --> -<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente +<!-- Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente complicadas, mas se você realmente quer: --> | Col1 | Col2 | Col3 | diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown new file mode 100644 index 00000000..eb660d4c --- /dev/null +++ b/pt-br/matlab-pt.html.markdown @@ -0,0 +1,540 @@ +--- +language: Matlab +contributors: + - ["mendozao", "http://github.com/mendozao"] + - ["jamesscottbrown", "http://jamesscottbrown.com"] + - ["Colton Kohnke", "http://github.com/voltnor"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +filename: learnmatlab-pt.mat + +--- + +MATLAB significa MATrix LABoratory. É uma poderosa linguagem de computação numérica geralmente utilizada em engenharia e matemática. + +Se você tem algum feedback, por favor fique a vontade para me contactar via +[@the_ozzinator](https://twitter.com/the_ozzinator), ou +[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com). + +```matlab +% Comentários iniciam com um sinal de porcentagem + +%{ +Comentários de múltiplas linhas +parecem +com +algo assim +%} + +% Comandos podem ocupar várinhas linhas, usando '...': + a = 1 + 2 + ... + + 4 + +% Comandos podem ser passados para o sistema operacional +!ping google.com + +who % Exibe todas as variáveis na memória +whos % Exibe todas as variáveis na memória, com seus tipos +clear % Apaga todas as suas variáveis da memória +clear('A') % Apaga uma variável em particular +openvar('A') % Abre a variável no editor de variável + +clc % Apaga o conteúdo escrito na sua janela de comando +diary % Alterna o conteúdo escrito na janela de comando para um arquivo de texto +ctrl-c % Aborta a computação atual + +edit('minhafuncao.m') % Abre a função/script no editor +type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando + +profile on % Ativa o perfil de código +profile off % Desativa o perfil de código +profile viewer % Visualiza os resultados na janela de Profiler + +help comando % Exibe a documentação do comando na janela de comando +doc comando % Exibe a documentação do comando na janela de ajuda +lookfor comando % Procura por comando na primeira linha comentada de todas as funções +lookfor comando -all % Procura por comando em todas as funções + + +% Formatação de saída +format short % 4 casas decimais em um número flutuante +format long % 15 casas decimais +format bank % 2 dígitos após o ponto decimal - para cálculos financeiros +fprintf('texto') % Imprime na tela "texto" +disp('texto') % Imprime na tela "texto" + +% Variáveis & Expressões +minhaVariavel = 4 % O painel Workspace mostra a variável recém-criada +minhaVariavel = 4; % Ponto e vírgula suprime a saída para a janela de comando +4 + 6 % Resposta = 10 +8 * minhaVariavel % Resposta = 32 +2 ^ 3 % Resposta = 8 +a = 2; b = 3; +c = exp(a)*sin(pi/2) % c = 7.3891 + +% A chamada de funções pode ser feita por uma das duas maneiras: +% Sintaxe de função padrão: +load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula +% Sintaxe de comando: +load arquivo.mat y % Sem parênteses, e espaços ao invés de vírgulas +% Observe a falta de aspas na forma de comando: entradas são sempre passadas +% como texto literal - não pode passar valores de variáveis. +% Além disso, não pode receber saída: +[V,D] = eig(A); % Isto não tem um equivalente na forma de comando +[~,D] = eig(A); % Se você só deseja D e não V + + + +% Operadores Lógicos e Relacionais +1 > 5 % Resposta = 0 +10 >= 10 % Resposta = 1 +3 ~= 4 % Diferente de -> Resposta = 1 +3 == 3 % Igual a -> Resposta = 1 +3 > 1 && 4 > 1 % E -> Resposta = 1 +3 > 1 || 4 > 1 % OU -> Resposta = 1 +~1 % NOT -> Resposta = 0 + +% Operadores Lógicos e Relacionais podem ser aplicados a matrizes +A > 5 +% Para cada elemento, caso seja verdade, esse elemento será 1 na matriz retornada +A( A > 5 ) +% Retorna um vetor com os elementos de A para os quais a condição é verdadeira + +% Cadeias de caracteres (Strings) +a = 'MinhaString' +length(a) % Resposta = 11 +a(2) % Resposta = i +[a,a] % Resposta = MinhaStringMinhaString + + +% Vetores de células +a = {'um', 'dois', 'três'} +a(1) % Resposta = 'um' - retorna uma célula +char(a(1)) % Resposta = um - retorna uma string + +% Estruturas +A.b = {'um','dois'}; +A.c = [1 2]; +A.d.e = false; + +% Vetores +x = [4 32 53 7 1] +x(2) % Resposta = 32, índices no Matlab começam por 1, não 0 +x(2:3) % Resposta = 32 53 +x(2:end) % Resposta = 32 53 7 1 + +x = [4; 32; 53; 7; 1] % Vetor coluna + +x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10 + +% Matrizes +A = [1 2 3; 4 5 6; 7 8 9] +% Linhas são separadas por um ponto e vírgula; +% Elementos são separados com espaço ou vírgula +% A = + +% 1 2 3 +% 4 5 6 +% 7 8 9 + +A(2,3) % Resposta = 6, A(linha, coluna) +A(6) % Resposta = 8 +% (implicitamente encadeia as colunas do vetor, e então as indexa) + + +A(2,3) = 42 % Atualiza a linha 2 coluna 3 com o valor 42 +% A = + +% 1 2 3 +% 4 5 42 +% 7 8 9 + +A(2:3,2:3) % Cria uma nova matriz a partir da antiga +%Resposta = + +% 5 42 +% 8 9 + +A(:,1) % Todas as linhas na coluna 1 +%Resposta = + +% 1 +% 4 +% 7 + +A(1,:) % Todas as colunas na linha 1 +%Resposta = + +% 1 2 3 + +[A ; A] % Concatenação de matrizes (verticalmente) +%Resposta = + +% 1 2 3 +% 4 5 42 +% 7 8 9 +% 1 2 3 +% 4 5 42 +% 7 8 9 + +% Isto é o mesmo de +vertcat(A,A); + + +[A , A] % Concatenação de matrizes (horizontalmente) + +%Resposta = + +% 1 2 3 1 2 3 +% 4 5 42 4 5 42 +% 7 8 9 7 8 9 + +% Isto é o mesmo de +horzcat(A,A); + + +A(:, [3 1 2]) % Reorganiza as colunas da matriz original +%Resposta = + +% 3 1 2 +% 42 4 5 +% 9 7 8 + +size(A) % Resposta = 3 3 + +A(1, :) =[] % Remove a primeira linha da matriz +A(:, 1) =[] % Remove a primeira coluna da matriz + +transpose(A) % Transposta a matriz, que é o mesmo de: +A one +ctranspose(A) % Transposta a matriz +% (a transposta, seguida pelo conjugado complexo de cada elemento) + + + + +% Aritmética Elemento por Elemento vs. Aritmética com Matriz +% Naturalmente, os operadores aritméticos agem em matrizes inteiras. Quando +% precedidos por um ponto, eles atuam em cada elemento. Por exemplo: +A * B % Multiplicação de matrizes +A .* B % Multiplica cada elemento em A por seu correspondente em B + +% Existem vários pares de funções nas quais uma atua sob cada elemento, e a +% outra (cujo nome termina com m) age na matriz por completo. +exp(A) % Exponencia cada elemento +expm(A) % Calcula o exponencial da matriz +sqrt(A) % Tira a raiz quadrada de cada elemento +sqrtm(A) % Procura a matriz cujo quadrado é A + + +% Gráficos +x = 0:.10:2*pi; % Vetor que começa em 0 e termina em 2*pi com incrementos de 0,1 +y = sin(x); +plot(x,y) +xlabel('eixo x') +ylabel('eixo y') +title('Gráfico de y = sin(x)') +axis([0 2*pi -1 1]) % x vai de 0 a 2*pi, y vai de -1 a 1 + +plot(x,y1,'-',x,y2,'--',x,y3,':') % Para várias funções em um só gráfico +legend('Descrição linha 1', 'Descrição linha 2') % Curvas com uma legenda + +% Método alternativo para traçar várias funções em um só gráfico: +% Enquanto 'hold' estiver ativo, os comandos serão adicionados ao gráfico +% existente ao invés de o substituirem. +plot(x, y) +hold on +plot(x, z) +hold off + +loglog(x, y) % Plotar em escala loglog +semilogx(x, y) % Um gráfico com eixo x logarítmico +semilogy(x, y) % Um gráfico com eixo y logarítmico + +fplot (@(x) x^2, [2,5]) % Plotar a função x^2 para x=2 até x=5 + +grid on % Exibe as linhas de grade; Oculta com 'grid off' +axis square % Torna quadrada a região dos eixos atuais +axis equal % Taxa de proporção onde as unidades serão as mesmas em todas direções + +scatter(x, y); % Gráfico de dispersão ou bolha +hist(x); % Histograma + +z = sin(x); +plot3(x,y,z); % Plotar em espaço em 3D + +pcolor(A) % Mapa de calor da matriz: traça uma grade de retângulos, coloridos pelo valor +contour(A) % Plotar de contorno da matriz +mesh(A) % Plotar malha 3D + +h = figure % Cria uma nova figura objeto, com identificador h +figure(h) % Cria uma nova janela de figura com h +close(h) % Fecha a figura h +close all % Fecha todas as janelas de figuras abertas +close % Fecha a janela de figura atual + +shg % Traz uma janela gráfica existente para frente, ou cria uma nova se necessário +clf clear % Limpa a janela de figura atual e redefine a maioria das propriedades da figura + +% Propriedades podem ser definidas e alteradas através de um identificador. +% Você pode salvar um identificador para uma figura ao criá-la. +% A função gcf retorna o identificador da figura atual +h = plot(x, y); % Você pode salvar um identificador para a figura ao criá-la +set(h, 'Color', 'r') +% 'y' amarelo; 'm' magenta, 'c' ciano, 'r' vermelho, 'g' verde, 'b' azul, 'w' branco, 'k' preto +set(h, 'LineStyle', '--') + % '--' linha sólida, '---' tracejada, ':' pontilhada, '-.' traço-ponto, 'none' sem linha +get(h, 'LineStyle') + + +% A função gca retorna o identificador para os eixos da figura atual +set(gca, 'XDir', 'reverse'); % Inverte a direção do eixo x + +% Para criar uma figura que contém vários gráficos use subplot, o qual divide +% a janela de gráficos em m linhas e n colunas. +subplot(2,3,1); % Seleciona a primeira posição em uma grade de 2-por-3 +plot(x1); title('Primeiro Plot') % Plota algo nesta posição +subplot(2,3,2); % Seleciona a segunda posição na grade +plot(x2); title('Segundo Plot') % Plota algo ali + + +% Para usar funções ou scripts, eles devem estar no caminho ou na pasta atual +path % Exibe o caminho atual +addpath /caminho/para/pasta % Adiciona o diretório ao caminho +rmpath /caminho/para/pasta % Remove o diretório do caminho +cd /caminho/para/mudar % Muda o diretório + + +% Variáveis podem ser salvas em arquivos *.mat +save('meuArquivo.mat') % Salva as variáveis do seu Workspace +load('meuArquivo.mat') % Carrega as variáveis em seu Workspace + +% Arquivos M (M-files) +% Um arquivo de script é um arquivo externo contendo uma sequência de instruções. +% Eles evitam que você digite os mesmos códigos repetidamente na janela de comandos. +% Possuem a extensão *.m + +% Arquivos M de Funções (M-file Functions) +% Assim como scripts e têm a mesma extensão *.m +% Mas podem aceitar argumentos de entrada e retornar uma saída. +% Além disso, possuem seu próprio workspace (ex. diferente escopo de variáveis). +% O nome da função deve coincidir com o nome do arquivo (salve o exemplo como dobra_entrada.m) +% 'help dobra_entrada.m' retorna os comentários abaixo da linha de início da função +function output = dobra_entrada(x) + %dobra_entrada(x) retorna duas vezes o valor de x + output = 2*x; +end +dobra_entrada(6) % Resposta = 12 + + +% Você também pode ter subfunções e funções aninhadas. +% Subfunções estão no mesmo arquivo da função primária, e só podem ser chamados +% por funções dentro do arquivo. Funções aninhadas são definidas dentro de +% outras funções, e têm acesso a ambos workspaces. + +% Se você quer criar uma função sem criar um novo arquivo, você pode usar uma +% função anônima. Úteis para definir rapidamente uma função para passar a outra +% função (ex. plotar com fplot, avaliar uma integral indefinida com quad, +% procurar raízes com fzero, ou procurar mínimo com fminsearch). +% Exemplo que retorna o quadrado de sua entrada, atribuído ao identificador sqr: +sqr = @(x) x.^2; +sqr(10) % Resposta = 100 +doc function_handle % Saiba mais + +% Entrada do usuário +a = input('Digite o valor: ') + +% Para a execução do arquivo e passa o controle para o teclado: o usuário pode +% examinar ou alterar variáveis. Digite 'return' para continuar a execução, ou 'dbquit' para sair +keyboard + +% Leitura de dados (ou xlsread/importdata/imread para arquivos excel/CSV/imagem) +fopen(nomedoarquivo) + +% Saída +disp(a) % Imprime o valor da variável a +disp('Olá Mundo') % Imprime a string +fprintf % Imprime na janela de comandos com mais controle + +% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática) +if (a > 15) + disp('Maior que 15') +elseif (a == 23) + disp('a é 23') +else + disp('Nenhuma condição reconheceu') +end + +% Estruturas de Repetição +% Nota: fazer o loop sobre elementos de um vetor/matriz é lento! +% Sempre que possível, use funções que atuem em todo o vetor/matriz de uma só vez. +for k = 1:5 + disp(k) +end + +k = 0; +while (k < 5) + k = k + 1; +end + +% Tempo de Execução de Código (Timing Code Execution): 'toc' imprime o tempo +% passado desde que 'tic' foi chamado. +tic +A = rand(1000); +A*A*A*A*A*A*A; +toc + +% Conectando a uma base de dados MySQL +dbname = 'nome_base_de_dados'; +username = 'root'; +password = 'root'; +driver = 'com.mysql.jdbc.Driver'; +dburl = ['jdbc:mysql://localhost:8889/' dbname]; +%Abaixo, o xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/ +javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); +conn = database(dbname, username, password, driver, dburl); +sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL +a = fetch(conn, sql) %a will contain your data + + +% Funções Matemáticas Comuns +sin(x) +cos(x) +tan(x) +asin(x) +acos(x) +atan(x) +exp(x) +sqrt(x) +log(x) +log10(x) +abs(x) +min(x) +max(x) +ceil(x) +floor(x) +round(x) +rem(x) +rand % Números pseudo-aleatórios uniformemente distribuídos +randi % Inteiros pseudo-aleatórios uniformemente distribuídos +randn % Números pseudo-aleatórios normalmente distribuídos + +% Constantes Comuns +pi +NaN +inf + +% Resolvendo equações matriciais (se não houver solução, retorna uma solução de mínimos quadrados) +% Os operadores \ e / são equivalentes às funções mldivide e mrdivide +x=A\b % Resolve Ax=b. Mais rápido e numericamente mais preciso do que inv(A)*b. +x=b/A % Resolve xA=b + +inv(A) % Calcula a matriz inversa +pinv(A) % Calcula a pseudo-inversa + +% Funções Matriciais Comuns +zeros(m,n) % Matriz de zeros m x n +ones(m,n) % Matriz de 1's m x n +diag(A) % Extrai os elementos diagonais da matriz A +diag(x) % Constrói uma matriz com os elementos diagonais listados em x, e zero nas outras posições +eye(m,n) % Matriz identidade +linspace(x1, x2, n) % Retorna n pontos igualmente espaçados, com min x1 e max x2 +inv(A) % Inverso da matriz A +det(A) % Determinante da matriz A +eig(A) % Valores e vetores próprios de A +trace(A) % Traço da matriz - equivalente a sum(diag(A)) +isempty(A) % Testa se a matriz está vazia +all(A) % Testa se todos os elementos são diferentes de zero ou verdadeiro +any(A) % Testa se algum elemento é diferente de zero ou verdadeiro +isequal(A, B) % Testa a igualdade de duas matrizes +numel(A) % Número de elementos na matriz +triu(x) % Retorna a parte triangular superior de x +tril(x) % Retorna a parte triangular inferior de x +cross(A,B) % Retorna o produto cruzado das matrizes A e B +dot(A,B) % Retorna o produto escalar de duas matrizes (devem possuir mesmo tamanho) +transpose(A) % Retorna a matriz transposta de A +fliplr(A) % Inverte a matriz da esquerda para a direita +flipud(A) % Inverte a matriz de cima para baixo + +% Fatorações de Matrizes +% Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação +[L, U, P] = lu(A) +% Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores +[P, D] = eig(A) +% SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente +[U,S,V] = svd(X) + +% Funções Vetoriais Comuns +max % Maior componente +min % Menor componente +length % Tamanho do vetor +sort % Ordena em orcer ascendente +sum % Soma de elementos +prod % Produto de elementos +mode % Valor modal +median % Valor mediano +mean % Valor médio +std % Desvio padrão +perms(x) % Lista todas as permutações de elementos de x + + +% Classes +% Matlab pode suportar programação orientada a objetos. +% Classes devem ser colocadas em um arquivo de mesmo nome com a extensão *.m +% Para começar, criamos uma simples classe que armazena posições de GPS +% Início ClassePosicoesGPS.m +classdef ClassePosicoesGPS % O nome da classe. + properties % As propriedades da classe comportam-se como estruturas + latitude + longitude + end + methods + % Este método que tem o mesmo nome da classe é o construtor. + function obj = ClassePosicoesGPS(lat, lon) + obj.latitude = lat; + obj.longitude = lon; + end + + % Outras funções que usam os objetos de PosicoesGPS + function r = multiplicarLatPor(obj, n) + r = n*[obj.latitude]; + end + + % Se quisermos somar dois objetos de PosicoesGPS juntos sem chamar + % uma função especial nós podemos sobrepor a aritmética do Matlab, desta maneira: + function r = plus(o1,o2) + r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ... + [o1.longitude]+[o2.longitude]); + end + end +end +% End ClassePosicoesGPS.m + +% Podemos criar um objeto da classe usando o construtor +a = ClassePosicoesGPS(45.0, 45.0) + +% Propriedades da classe se comportam exatamente como estruturas Matlab +a.latitude = 70.0 +a.longitude = 25.0 + +% Métodos podem ser chamados da mesma forma que funções +ans = multiplicarLatPor(a,3) + +% O método também pode ser chamado usando a notação de ponto. Neste caso, +% o objeto não precisa ser passado para o método. +ans = a.multiplicarLatPor(a,1/3) + +% Funções do Matlab podem ser sobrepostas para lidar com objetos. +% No método abaixo, nós sobrepomos a forma como o Matlab lida com a soma de +% dois objetos PosicoesGPS. +b = ClassePosicoesGPS(15.0, 32.0) +c = a + b + +``` + +## Mais sobre Matlab + +* O site oficial [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/) +* O fórum oficial de respostas: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/) + diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown new file mode 100644 index 00000000..464a69d2 --- /dev/null +++ b/pt-br/paren-pt.html.markdown @@ -0,0 +1,196 @@ +--- +language: Paren +filename: learnparen-pt.paren +contributors: + - ["KIM Taegyoon", "https://github.com/kimtg"] +translators: + - ["Claudson Martins", "https://github.com/claudsonm"] +lang: pt-br +--- + +[Paren](https://bitbucket.org/ktg/paren) é um dialeto do Lisp. É projetado para ser uma linguagem embutida. + +Alguns exemplos foram retirados de <http://learnxinyminutes.com/docs/racket/>. + +```scheme +;;; Comentários +# Comentários + +;; Comentários de única linha começam com um ponto e vírgula ou cerquilha + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 1. Tipos de Dados Primitivos e Operadores +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Números +123 ; inteiro +3.14 ; double +6.02e+23 ; double +(int 3.14) ; => 3 : inteiro +(double 123) ; => 123 : double + +;; O uso de funções é feito da seguinte maneira (f x y z ...) +;; onde f é uma função e x, y, z, ... são os operandos +;; Se você quiser criar uma lista literal de dados, use (quote) para impedir +;; que sejam interpretados +(quote (+ 1 2)) ; => (+ 1 2) +;; Agora, algumas operações aritméticas +(+ 1 1) ; => 2 +(- 8 1) ; => 7 +(* 10 2) ; => 20 +(^ 2 3) ; => 8 +(/ 5 2) ; => 2 +(% 5 2) ; => 1 +(/ 5.0 2) ; => 2.5 + +;;; Booleanos +true ; para verdadeiro +false ; para falso +(! true) ; => falso +(&& true false (prn "não chega aqui")) ; => falso +(|| false true (prn "não chega aqui")) ; => verdadeiro + +;;; Caracteres são inteiros. +(char-at "A" 0) ; => 65 +(chr 65) ; => "A" + +;;; Strings são arrays de caracteres de tamanho fixo. +"Olá, mundo!" +"Sebastião \"Tim\" Maia" ; Contra-barra é um caractere de escape +"Foo\tbar\r\n" ; Inclui os escapes da linguagem C: \t \r \n + +;; Strings podem ser concatenadas também! +(strcat "Olá " "mundo!") ; => "Olá mundo!" + +;; Uma string pode ser tratada como uma lista de caracteres +(char-at "Abacaxi" 0) ; => 65 + +;; A impressão é muito fácil +(pr "Isso é" "Paren. ") (prn "Prazer em conhecê-lo!") + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 2. Variáveis +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Você pode criar ou definir uma variável usando (set) +;; o nome de uma variável pode conter qualquer caracter, exceto: ();#" +(set alguma-variavel 5) ; => 5 +alguma-variavel ; => 5 + +;; Acessar uma variável ainda não atribuída gera uma exceção +; x ; => Unknown variable: x : nil + +;; Ligações locais: Utiliza cálculo lambda! +;; 'a' e 'b' estão ligados a '1' e '2' apenas dentro de (fn ...) +((fn (a b) (+ a b)) 1 2) ; => 3 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Coleções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Listas + +;; Listas são estruturas de dados semelhantes a vetores. (A classe de comportamento é O(1).) +(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3) +;; 'list' é uma variação conveniente para construir listas +(list 1 2 3) ; => (1 2 3) +;; Um quote também pode ser usado para uma lista de valores literais +(quote (+ 1 2)) ; => (+ 1 2) + +;; Você ainda pode utilizar 'cons' para adicionar um item ao início da lista +(cons 0 (list 1 2 3)) ; => (0 1 2 3) + +;; Listas são um tipo muito básico, portanto existe *enorme* funcionalidade +;; para elas, veja alguns exemplos: +(map inc (list 1 2 3)) ; => (2 3 4) +(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4) +(length (list 1 2 3 4)) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 3. Funções +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use 'fn' para criar funções. +;; Uma função sempre retorna o valor de sua última expressão +(fn () "Olá Mundo") ; => (fn () Olá Mundo) : fn + +;; Use parênteses para chamar todas as funções, incluindo uma expressão lambda +((fn () "Olá Mundo")) ; => "Olá Mundo" + +;; Atribuir uma função a uma variável +(set ola-mundo (fn () "Olá Mundo")) +(ola-mundo) ; => "Olá Mundo" + +;; Você pode encurtar isso utilizando a definição de função açúcar sintático: +(defn ola-mundo2 () "Olá Mundo") + +;; Os () acima é a lista de argumentos para a função +(set ola + (fn (nome) + (strcat "Olá " nome))) +(ola "Steve") ; => "Olá Steve" + +;; ... ou equivalente, usando a definição açucarada: +(defn ola2 (nome) + (strcat "Olá " name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 4. Igualdade +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Para números utilize '==' +(== 3 3.0) ; => verdadeiro +(== 2 1) ; => falso + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 5. Controle de Fluxo +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; Condicionais + +(if true ; Testa a expressão + "isso é verdade" ; Então expressão + "isso é falso") ; Senão expressão +; => "isso é verdade" + +;;; Laços de Repetição + +;; O laço for é para número +;; (for SÍMBOLO INÍCIO FIM SALTO EXPRESSÃO ..) +(for i 0 10 2 (pr i "")) ; => Imprime 0 2 4 6 8 10 +(for i 0.0 10 2.5 (pr i "")) ; => Imprime 0 2.5 5 7.5 10 + +;; Laço while +((fn (i) + (while (< i 10) + (pr i) + (++ i))) 0) ; => Imprime 0123456789 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 6. Mutação +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Use 'set' para atribuir um novo valor a uma variável ou local +(set n 5) ; => 5 +(set n (inc n)) ; => 6 +n ; => 6 +(set a (list 1 2)) ; => (1 2) +(set (nth 0 a) 3) ; => 3 +a ; => (3 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; 7. Macros +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Macros lhe permitem estender a sintaxe da linguagem. +;; Os macros no Paren são fáceis. +;; Na verdade, (defn) é um macro. +(defmacro setfn (nome ...) (set nome (fn ...))) +(defmacro defn (nome ...) (def nome (fn ...))) + +;; Vamos adicionar uma notação infixa +(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. +``` diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown new file mode 100644 index 00000000..217861f9 --- /dev/null +++ b/pt-br/perl-pt.html.markdown @@ -0,0 +1,166 @@ +--- +name: perl +category: language +language: perl +filename: learnperl-pt.pl +contributors: + - ["Korjavin Ivan", "http://github.com/korjavin"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +--- + +Perl 5 é, uma linguagem de programação altamente capaz, rica em recursos, com mais de 25 anos de desenvolvimento. + +Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada tanto para prototipagem rápida, quanto em projetos de desenvolvimento em grande escala. + +```perl +# Comentários de uma linha começam com um sinal de número. + +#### Tipos de variáveis em Perl + +# Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo. +# Um nome de variável válido começa com uma letra ou sublinhado, +# seguido por qualquer quantidade de letras, números ou sublinhados. + +### Perl has three main variable types: $scalar, @array, e %hash. + +## Scalars +# Um scalar representa um valor único: +my $animal = "camelo"; +my $resposta = 42; + +# Valores scalar podem ser strings, inteiros ou números ponto-flutuantes e +# Perl vai automaticamente converter entre eles quando for preciso. + +## Arrays +# Um array representa uma lista de valores: +my @animais = ("camelo", "vaca", "boi"); +my @números = (23, 42, 69); +my @misturado = ("camelo", 42, 1.23); + +## Hashes +# Um hash representa um conjunto de pares chave/valor: + +my %fruta_cor = ("maçã", "vermelho", "banana", "amarelo"); + +# Você pode usar o espaço em branco e o operador "=>" para colocá-los de +# maneira mais agradável: + +my %fruta_cor = ( + maçã => "vermelho", + banana => "amarelo", +); + +# Scalars, arrays and hashes são documentados mais profundamente em perldata. +# (perldoc perldata). + +# Mais tipos de dados complexos podem ser construídos utilizando referências, +# o que permite que você crie listas e hashes dentro de listas e hashes. + +#### Condicionais e construtores de iteração + +# Perl possui a maioria das construções condicionais e de iteração habituais. + +if ($var) { + ... +} elsif ($var eq 'bar') { + ... +} else { + ... +} + +unless (condição) { + ... +} +# Isto é fornecido como uma versão mais legível de "if (!condition)" + +# A forma Perlish pós-condição +print "Yow!" if $zippy; +print "Nós não temos nenhuma banana" unless $bananas; + +# while +while (condição) { + ... +} + +# for +for (my $i = 0; $i < $max; $i++) { + print "valor é $i"; +} + +for (my $i = 0; $i < @elements; $i++) { + print "Elemento atual é " . $elements[$i]; +} + +for my $element (@elements) { + print $element; +} + +# implícito + +for (@elements) { + print; +} + +#### Expressões regulares + +# O suporte a expressões regulares do Perl é ao mesmo tempo amplo e profundo, +# e é objeto de longa documentação em perlrequick, perlretut, e em outros +# lugares. No entanto, em suma: + +# Casamento simples +if (/foo/) { ... } # verdade se $_ contém "foo" +if ($a =~ /foo/) { ... } # verdade se $a contém "foo" + +# Substituição simples + +$a =~ s/foo/bar/; # substitui foo com bar em $a +$a =~ s/foo/bar/g; # substitui TODAS AS INSTÂNCIAS de foo com bar em $a + +#### Arquivos e I/O + +# Você pode abrir um arquivo para entrada ou saída usando a função "open()". + +open(my $in, "<", "input.txt") ou desistir "Não pode abrir input.txt: $!"; +open(my $out, ">", "output.txt") ou desistir "Não pode abrir output.txt: $!"; +open(my $log, ">>", "my.log") ou desistir "Não pode abrir my.log: $!"; + +# Você pode ler de um arquivo aberto usando o operador "<>". No contexto +# scalar, ele lê uma única linha do arquivo, e em contexto de lista lê o +# arquivo inteiro, atribuindo cada linha a um elemento da lista: + +my $linha = <$in>; +my @linhas = <$in>; + +#### Escrevendo subrotinas + +# Escrever subrotinas é fácil: + +sub logger { + my $mensagem = shift; + + open my $arquivo, ">>", "my.log" or die "Não poderia abrir my.log: $!"; + + print $arquivo $ensagem; +} + +# Agora nós podemos usar a subrotina como qualquer outra função construída: + +logger("Nós temos uma subrotina de log!"); +``` + +#### Usando módulos Perl + +Módulos Perl provê uma lista de recursos para lhe ajudar a evitar redesenhar +a roda, e tudo isso pode ser baixado do CPAN (http://www.cpan.org/). Um número +de módulos populares podem ser incluídos com a própria distribuição do Perl. + +perlfaq contém questões e respostas relacionadas a muitas tarefas comuns, e frequentemente provê sugestões para um bom números de módulos CPAN. + +#### Leitura Adicional + + - [perl-tutorial](http://perl-tutorial.org/) + - [Learn at www.perl.com](http://www.perl.org/learn.html) + - [perldoc](http://perldoc.perl.org/) + - and perl built-in : `perldoc perlintro` diff --git a/pt-br/php-composer-pt.html.markdown b/pt-br/php-composer-pt.html.markdown new file mode 100644 index 00000000..145f5cab --- /dev/null +++ b/pt-br/php-composer-pt.html.markdown @@ -0,0 +1,184 @@ +--- +category: tool +tool: composer +contributors: + - ["Brett Taylor", "https://github.com/glutnix"] +translators: + - ["David Lima", "https://github.com/davelima"] +lang: pt-br +filename: LearnComposer-pt.sh +--- + +[Composer](https://getcomposer.org/) é uma ferramenta de gerenciamento de dependências para PHP. Ele permite que você defina as bibliotecas que seu projeto precisa, e então ele as gerencia (instala/atualiza) para você. + +# Instalando + +```sh +# Instala o binário composer.phar no diretório atual +curl -sS https://getcomposer.org/installer | php +# Se você fizer desta forma, você precisará chamar o composer assim: +php composer.phar about + +# Instala o binário em ~/bin/composer +# Nota: certifique-se de que ~/bin está na variável de ambiente PATH do seu shell +curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer +``` + +Usuários Windows devem seguir as Instruções de instalação para Windows: +https://getcomposer.org/doc/00-intro.md#installation-windows (EN) + +## Confirmando a instalação + +```sh +# Verifica a versão e lista as opções +composer + +# Para obter ajuda com os comandos +composer help require + +# Verifica se o Composer tem as permissões necessárias e se está atualizado +composer diagnose +composer diag # atalho + +# Atualiza o binário do Composer para a última versão +composer self-update +composer self # atalho +``` + +# Modo de uso + +O Composer armazena as dependências do seu projeto em `composer.json`. +Você pode editar este arquivo, mas é recomendável deixar que o Composer faça isso. + +```sh +# Cria um novo projeto na pasta atual +composer init +# Executa um questionário interativo, te pedindo detalhes sobre o projeto. +# Você pode deixar o questionário em branco, desde que não haja outros projetos dependendo deste. + +# Se um arquivo composer.json já existir, baixa as dependências +composer install + +# Para baixar apenas as dependências de produção, excluindo as de desenvolvimento +composer install --no-dev + +# Adiciona uma dependência de produção ao projeto +composer require guzzlehttp/guzzle +# O Composer se encarrega de verificar qual é a última versão de +# guzzlehttp/guzzle, baixar e adicionar a nova dependência no +# campo 'require' do composer.json + +composer require guzzlehttp/guzzle:6.0.* +# O composer baixa a última versão que combine com o padrão informado (6.0.2, por exemplo) +# e adiciona essa dependência ao campo 'require' do arquivo composer.json + +composer require --dev phpunit/phpunit:~4.5.0 +# O composer irá baixar a dependencia como desenvolvimento, +# usando a versão mais recente >= 4.5.0 e < 4.6.0 + +composer require-dev phpunit/phpunit:^4.5.0 +# O composer irá baixar a dependencia como desenvolvimento, +# usando a versão mais recente >= 4.5.0 e < 5.0 + +# Para mais informações sobre os padrões de versões, veja a +# Documentação sobre Versões do Composer: https://getcomposer.org/doc/articles/versions.md (EN) + +# Para ver quais pacotes estão disopníveis e quais estão instalados +composer show + +# Para ver quais pacotes estão instalados +composer show --installed + +# Para encontrar um pacote que tenha 'mailgun' no nome ou descrição +composer search mailgun +``` + +[Packagist.org](https://packagist.org/) é o repositório principal para pacotes Composer. Pesquise aqui por pacotes existentes. + +## `composer.json` vs `composer.lock` + +O arquivo `composer.json` armazena as preferências de de versão de cada dependência, além de outras informações + +O arquivo `composer.lock` armazena exatamente qual versão foi baixada para cada dependência. Nunca altere este arquivo. + +Se você incluir o arquivo `composer.lock` no seu repositório git, todos os desenvolvedores irão instalar a mesma versão das dependências que você. +Mesmo se uma nova versão for lançada, o Composer baixará apenas a versão salva no arquivo de lock. + +```sh +# Atualizar todas as dependências para a versão mais recente (ainda dentro das preferências definidas) +composer update + +# Para atualizar a versão de uma dependência específica: +composer update phpunit/phpunit + +# Para migrar um pacote para uma nova preferência de versão, você pode precisar +# remover o pacote antigo e suas dependências primeiro +composer remove --dev phpunit/phpunit +composer require --dev phpunit/phpunit:^5.0 + +``` + +## Autoloader + +O Composer cria uma classe autoloader que você pode usar na sua aplicação. +Você pode instanciar as classes pelos seus namespaces. + +```php +require __DIR__ . '/vendor/autoload.php'; + +$mailgun = new Mailgun\Mailgun("key"); +``` + +### Autoloader da PSR-4 + +Você pode adicionar seus próprios namespaces ao autoloader. + +No `composer.json`, adicione um campo 'autoload': + +```json +{ + "autoload": { + "psr-4": {"Acme\\": "src/"} + } +} +``` +Isso irá dizer ao autoloader para buscar na pasta `src` tudo o que estiver no namespace `\Acme\`. + +Você também pode [usar a PSR-0, um mapa de classes ou apenas listar os arquivos para incluir](https://getcomposer.org/doc/04-schema.md#autoload), +e pode usar o campo `autoload-dev` para namespaces de desenvolvimento. + +Ao adicionar ou alterar alguma chave de autoload, você precisará recriar o autoloader + +```sh +composer dump-autoload +composer dump # shorthand + +# Otimiza pacotes PSR-0 e PSR-4 para carregar com mapas de classes também. +# É mais demorado, mas melhora a performance em produção. +composer dump-autoload --optimize --no-dev +``` + +# O cache do Composer + +```sh +# O Composer irá evitar baixar pacotes caso eles estejam no cache. Para limpar o cache: +composer clear-cache +``` + +# Resolução de problemas + +```sh +composer diagnose +composer self-update +composer clear-cache +``` + +## Tópicos (ainda) não falados neste tutorial + +* Criando e distribuindo seus próprios pacotes no Packagist.org ou qualquer lugar +* Hooks Pré- e Pós-: rodar tarefas específicas em determinados eventos do Composer + +### Referências + +* [Composer - O gerenciador de dependências do PHP](https://getcomposer.org/) (EN) +* [Packagist.org](https://packagist.org/) (EN) diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown index 0e710742..8a1c956e 100644 --- a/pt-br/php-pt.html.markdown +++ b/pt-br/php-pt.html.markdown @@ -7,7 +7,7 @@ translators: - ["Abdala Cerqueira", "http://abda.la"] - ["Raquel Diniz", "http://twitter.com/raquelrdiniz"] lang: pt-br -filename: learnphp-pt.php +filename: php-pt.html.markdown --- Este documento descreve PHP 5+. @@ -20,21 +20,23 @@ Este documento descreve PHP 5+. // Duas barras iniciam o comentário de uma linha. -# O hash (aka pound symbol) também inicia, mas // é mais comum +# O hash (aka pound symbol) também inicia, mas // é mais comum. /* O texto envolto por barra-asterisco e asterisco-barra - faz um comentário de múltiplas linhas + faz um comentário de múltiplas linhas. */ -// Utilize "echo" ou "print" para imprimir a saída -print('Olá '); // Imprime "Olá " sem quebra de linha +// Utilize "echo" ou "print" para imprimir a saída. +print('Olá '); // Imprime "Olá " sem quebra de linha. +print 'Olá '; // Não tem a necessidade de utilizar as chaves. // () são opcionais para print e echo -echo "Mundo\n"; // Imprime "Mundo" com quebra de linha -// (Todas as declarações devem terminar com um ponto e vírgula) +echo "Mundo\n"; // Imprime "Mundo" com quebra de linha. +echo ("Mundo\n"); // Podemos tambem utilizar com chaves no echo. +// (Todas as declarações devem terminar com um ponto e vírgula.) -// Qualquer coisa fora da tag <?php é impresso automaticamente +// Qualquer coisa fora da tag <?php é impresso automaticamente. ?> Olá mundo novamente! <?php @@ -48,7 +50,7 @@ Olá mundo novamente! // Um nome de variável válido se inicia com uma letra ou sublinhado, // seguido por qualquer quantidade de letras, números ou sublinhados. -// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive) +// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive). $boolean = true; // ou TRUE ou True $boolean = false; // ou FALSE ou False @@ -63,8 +65,8 @@ $float = 1.234; $float = 1.2e3; $float = 7E-10; -// Excluir variável -unset($int1) +// Excluir variável. +unset($int1); // Aritmética $soma = 1 + 1; // 2 @@ -79,17 +81,19 @@ echo $numero++; // Imprime 1 (incrementa após a avaliação) echo ++$numero; // Imprime 3 (incrementa antes da avaliação) $numero /= $float; // Divide e atribui o quociente de $numero -// Strings podem ser colocadas entre aspas simples +// Strings podem ser colocadas entre aspas simples. $sgl_quotes = '$String'; // => '$String' // Evite o uso de aspas duplas, exceto para incorporar outras variáveis $dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.' -// Os caracteres especiais só são escapados entre aspas duplas -$escapado = "Este contém um \t caractere tab."; -$naoescapado = 'Este contém somente a barra e o t: \t'; +// Os caracteres especiais só são escapados entre aspas duplas. +$escapado = "Este contém um \t caractere tab."; +echo $escapado; //Imprime: Este contém um caractere tab. +$naoescapado = 'Este contém somente a barra e o t: \t'; +echo $naoescapado; //Imprime: Este contém somente a barra e o t: \t -// Coloque uma variável entre chaves se necessário +// Coloque uma variável entre chaves se necessário. $dinheiro = "Eu tenho $${numero} no banco."; // Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise @@ -105,7 +109,7 @@ $sgl_quotes FIM; // Concatenação de string é feita com . -echo 'Esta string ' . 'é concatenada'; +echo 'Esta string ' . 'é concatenada'; //Imprime: 'Esta string é concatenada' /******************************** @@ -120,7 +124,7 @@ echo 'Esta string ' . 'é concatenada'; define("FOO", "alguma coisa"); // Acesso a uma constante é possível usando diretamente o nome escolhido -echo 'Isto sairá '.FOO; +echo 'Isto sairá '.FOO; //Imprime: Isto sairá alguma coisa /******************************** @@ -135,16 +139,16 @@ $associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3); // PHP 5.4 introduziu uma nova sintaxe $associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3]; -echo $associativo['Um']; // imprime 1 +echo $associativo['Um']; // Imprime 1. // Uma lista de literais atribui chaves inteiras implicitamente $array = ['Um', 'Dois', 'Tres']; -echo $array[0]; // => "Um" +echo $array[0]; // Imprime => "Um" // Adiciona um elemento no final do array $array[] = 'Quatro'; -// Remove um elemento do array +// Remove um elemento do array. unset($array[3]); /******************************** @@ -155,12 +159,12 @@ echo('Olá Mundo!'); // Imprime Olá Mundo! para stdout. // Stdout é uma página web se executado em um navegador. -print('Olá Mundo!'); // O mesmo que o echo +print('Olá Mundo!'); // O mesmo que o echo. // echo é atualmente um construtor de linguagem, então você pode // remover os parênteses. -echo 'Olá Mundo!'; -print 'Olá Mundo!'; // O print também é +echo 'Olá Mundo!'; // Imprime: Olá Mundo! +print 'Olá Mundo!'; // O print também é - Imprime: Olá Mundo! $paragrafo = 'parágrafo'; @@ -181,11 +185,11 @@ $z = &$y; // $z irá mudar o valor de $y também, e vice-versa. // $x irá permanecer inalterado com o valor original de $y -echo $x; // => 2 -echo $z; // => 2 +echo $x; // Imprime => 2 +echo $z; // Imprime => 2 $y = 0; -echo $x; // => 2 -echo $z; // => 0 +echo $x; // Imprime => 2 +echo $z; // Imprime => 0 // Despeja tipos e valores de variável para o stdout var_dump($z); // imprime int(0) @@ -222,13 +226,13 @@ assert(1 !== '1'); // As variáveis podem ser convertidas entre tipos, dependendo da sua utilização. $inteiro = 1; -echo $inteiro + $inteiro; // => 2 +echo $inteiro + $inteiro; // Imprime => 2 $string = '1'; -echo $string + $string; // => 2 (strings são coagidas para inteiros) +echo $string + $string; // Imprime => 2 (strings são coagidas para inteiros) $string = 'one'; -echo $string + $string; // => 0 +echo $string + $string; // Imprime => 0 // Imprime 0 porque o operador + não pode fundir a string 'um' para um número // Tipo de fundição pode ser utilizado para tratar uma variável diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown new file mode 100644 index 00000000..10d55784 --- /dev/null +++ b/pt-br/pyqt-pt.html.markdown @@ -0,0 +1,92 @@ +--- +category: tool +tool: PyQT +filename: learnpyqt-pt.py +contributors: + - ["Nathan Hughes", "https://github.com/sirsharpest"] +translators: + - ["Lucas Pugliesi", "https://github.com/fplucas"] +lang: pt-br +--- + +**Qt** é amplamente conhecido como um framework para desenvolvimento de +software multi-plataforma que pode rodar em vários outras plataformas de +softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém +o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido +originalmente escrito em *C++*. + + +Essa é uma adaptação de uma introdução ao QT em C++ por +[Aleksey Kholovchuk](https://github.com/vortexxx192), alguns dos exemplos de +código podem resultar na mesma funcionalidade que essa versão, apenas usando +o pyqt! + +```python +import sys +from PyQt4 import QtGui + +def window(): + # Cria um objeto para a aplicação + app = QtGui.QApplication(sys.argv) + # Cria um widget onde o nosso label será inserido + w = QtGui.QWidget() + # Adiciona um label ao widget + b = QtGui.QLabel(w) + # Informa algum texto ao label + b.setText("Hello World!") + # Define os tamanhos e posições dos objetos + w.setGeometry(100, 100, 200, 50) + b.move(50, 20) + # Define o título da janela + w.setWindowTitle("PyQt") + # Exibe a janela + w.show() + # Executa tudo o que foi pedido, apenas uma vez + sys.exit(app.exec_()) + +if __name__ == '__main__': + window() + +``` + +Para utilizar mais funcionalidades no **pyqt** veremos a construção de alguns +outros elementos. +Aqui mostraremos como criar uma janela popup, muito útil para perguntar ao +usuário qual decisão tomar ou exibir alguma informação. + +```Python +import sys +from PyQt4.QtGui import * +from PyQt4.QtCore import * + + +def window(): + app = QApplication(sys.argv) + w = QWidget() + # Cria um botão e o anexa ao widget w + b = QPushButton(w) + b.setText("Press me") + b.move(50, 50) + # Informa b a chamar essa função quando for clicado + # observe que a função chamada não necessita de "()" + b.clicked.connect(showdialog) + w.setWindowTitle("PyQt Dialog") + w.show() + sys.exit(app.exec_()) + +# Essa função deve criar uma janela de diálogo com um botão, +# aguarda ser clicado e encerra o programa +def showdialog(): + d = QDialog() + b1 = QPushButton("ok", d) + b1.move(50, 50) + d.setWindowTitle("Dialog") + # Essa modalidade define que o popup deve bloquear as outras janelas quando ativo + d.setWindowModality(Qt.ApplicationModal) + # Ao ser clicado deve encerrar o processo + b1.clicked.connect(sys.exit) + d.exec_() + +if __name__ == '__main__': + window() +``` diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown new file mode 100644 index 00000000..9b6bd1b6 --- /dev/null +++ b/pt-br/python3-pt.html.markdown @@ -0,0 +1,746 @@ +--- +language: python3 +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] + - ["Steven Basart", "http://github.com/xksteven"] + - ["Andre Polykanine", "https://github.com/Oire"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] +translators: + - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"] +lang: pt-br +filename: learnpython3-pt.py +--- + +Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma +das mais populares linguagens em existência. Eu fiquei morrendo de amor +pelo Python por sua clareza sintática. É praticamente pseudocódigo executável. + +Suas opiniões são grandemente apreciadas. Você pode encontrar-me em +[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em] +[serviço de e-mail do google]. + +Observação: Este artigo trata de Python 3 especificamente. Verifique +[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende +aprender o velho Python 2.7. + +```python + +# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido). + +""" Strings de várias linhas podem ser escritas + usando três ", e são comumente usadas + como comentários. +""" + +#################################################### +## 1. Tipos de dados primitivos e operadores +#################################################### + +# Você usa números normalmente +3 # => 3 + +# Matemática é como você espera que seja +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 + +# Números inteiros por padrão, exceto na divisão, que retorna número +# de ponto flutuante (float). +35 / 5 # => 7.0 + +# O resultado da divisão inteira arredonda para baixo tanto para números +# positivos como para negativos. +5 // 3 # => 1 +5.0 // 3.0 # => 1.0 # funciona em float também +-5 // 3 # => -2 +-5.0 // 3.0 # => -2.0 + +# Quando você usa um float, o resultado é float. +3 * 2.0 # => 6.0 + +# operador módulo +7 % 3 # => 1 + +# Exponenciação (x**y, x elevado à potência y) +2**4 # => 16 + +# Determine a precedência usando parêntesis +(1 + 3) * 2 # => 8 + +# Valores lógicos são primitivos (Atenção à primeira letra maiúscula) +True +False + +# negação lógica com not +not True # => False +not False # => True + +# Operadores lógicos +# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas +True and False # => False +False or True # => True + +# Observe a utilização de operadores lógicos com números inteiros +0 and 2 # => 0 +-5 or 0 # => -5 +0 == False # => True +2 == True # => False +1 == True # => True + +# Igualdade é == +1 == 1 # => True +2 == 1 # => False + +# Diferença é != +1 != 1 # => False +2 != 1 # => True + +# Mais comparações +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Comparações podem ser agrupadas +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. +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 +b == a # => True, objetos a e b tem o mesmo conteúdo +b = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4] +b is a # => False, a e b não referenciam o mesmo objeto +b == a # => True, objetos a e b tem o mesmo conteúdo + +# Strings são criadas com " ou ' +"Isto é uma string." +'Isto também é uma string.' + +# Strings também podem ser somadas! Mas tente não fazer isso. +"Olá " + "mundo!" # => "Olá mundo!" +# Strings podem ser somadas sem usar o '+' +"Olá " "mundo!" # => "Olá mundo!" + +# Uma string pode ser manipulada como se fosse uma lista de caracteres +"Isso é uma string"[0] # => 'I' + +# .format pode ser usado para formatar strings, dessa forma: +"{} podem ser {}".format("Strings", "interpoladas") # => "Strings podem ser interpoladas" + +# Você pode repetir os argumentos para digitar menos. +"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal") +# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack." + +# Você pode usar palavras-chave se quiser contar. +"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha") # => "Beto quer comer lasanha" + +# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto: +"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga") # => "Strings podem ser interpoladas da forma antiga" + + +# None é um objeto +None # => None + +# Não use o operador de igualdade "==" para comparar objetos com None +# Use "is" para isso. Ele checará pela identidade dos objetos. +"etc" is None # => False +None is None # => True + +# None, 0, e strings/listas/dicionários vazios todos retornam False. +# Qualquer outra coisa retorna True +bool(0) # => False +bool("") # => False +bool([]) # => False +bool({}) # => False + + +#################################################### +## 2. Variáveis e coleções +#################################################### + +# Python tem uma função print +print("Eu sou o Python. Prazer em conhecer!") # => Eu sou o Python. Prazer em conhecer! + +# Por padrão a função print também imprime o caractere de nova linha ao final. +# Use o argumento opcional end para mudar o caractere final. +print("Olá, Mundo", end="!") # => Olá, Mundo! + +# Forma simples para capturar dados de entrada via console +input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string +# Observação: Em versões antigas do Python, o método input() era chamado raw_input() + +# Não é necessário declarar variáveis antes de iniciá-las +# È uma convenção usar letras_minúsculas_com_sublinhados +alguma_variavel = 5 +alguma_variavel # => 5 + +# Acessar uma variável que não tenha sido inicializada gera uma exceção. +# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções. +alguma_variavel_nao_inicializada # Gera a exceção NameError + +# Listas armazenam sequencias +li = [] +# Você pode iniciar com uma lista com alguns valores +outra_li = [4, 5, 6] + +# Adicionar conteúdo ao fim da lista com append +li.append(1) # li agora é [1] +li.append(2) # li agora é [1, 2] +li.append(4) # li agora é [1, 2, 4] +li.append(3) # li agora é [1, 2, 4, 3] +# Remover do final da lista com pop +li.pop() # => 3 e agora li é [1, 2, 4] +# Vamos colocá-lo lá novamente! +li.append(3) # li agora é [1, 2, 4, 3] novamente. + +# Acessar uma lista da mesma forma que você faz com um array +li[0] # => 1 +# Acessa o último elemento +li[-1] # => 3 + +# Acessando além dos limites gera um IndexError +li[4] # Gera o IndexError + +# Você pode acessar vários elementos com a sintaxe de limites +# (É um limite fechado, aberto pra você que gosta de matemática.) +li[1:3] # => [2, 4] +# Omitindo o final +li[2:] # => [4, 3] +# Omitindo o início +li[:3] # => [1, 2, 4] +# Selecione cada segunda entrada +li[::2] # => [1, 4] +# Tenha uma cópia em ordem invertida da lista +li[::-1] # => [3, 4, 2, 1] +# Use qualquer combinação dessas para indicar limites complexos +# li[inicio:fim:passo] + +# Faça uma cópia profunda de um nível usando limites +li2 = li[:] # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False. + +# Apague elementos específicos da lista com "del" +del li[2] # li agora é [1, 2, 3] + +# Você pode somar listas +# Observação: valores em li e other_li não são modificados. +li + other_li # => [1, 2, 3, 4, 5, 6] + +# Concatene listas com "extend()" +li.extend(other_li) # Agora li é [1, 2, 3, 4, 5, 6] + +# Verifique se algo existe na lista com "in" +1 in li # => True + +# Examine tamanho com "len()" +len(li) # => 6 + + +# Tuplas são como l istas, mas imutáveis. +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # Gera um TypeError + +# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do +# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,. +type((1)) # => <class 'int'> +type((1,)) # => <class 'tuple'> +type(()) # => <class 'tuple'> + +# Você pode realizar com tuplas a maior parte das operações que faz com listas +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# Você pode desmembrar tuplas (ou listas) em variáveis. +a, b, c = (1, 2, 3) # a é 1, b é 2 e c é 3 +# Por padrão, tuplas são criadas se você não coloca parêntesis. +d, e, f = 4, 5, 6 +# Veja como é fácil permutar dois valores +e, d = d, e # d é 5, e é 4 + +# Dicionários armazenam mapeamentos +empty_dict = {} +# Aqui está um dicionário preenchido na definição da referência +filled_dict = {"um": 1, "dois": 2, "três": 3} + +# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para +# assegurar que a chave pode ser convertida para uma valor hash constante para +# buscas rápidas. +# Tipos imutáveis incluem inteiros, flotas, strings e tuplas. +invalid_dict = {[1,2,3]: "123"} # => Gera um TypeError: unhashable type: 'list' +valid_dict = {(1,2,3):[1,2,3]} # Já os valores, podem ser de qualquer tipo. + +# Acesse valores com [] +filled_dict["um"] # => 1 + +# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular +# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso +# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida. +# Por isso, os resultados aqui apresentados podem não ser exatamente como os +# aqui apresentados. +list(filled_dict.keys()) # => ["três", "dois", "um"] + + +# Acesse todos os valores de um iterável com "values()". Novamente, é +# necessário encapsular ele com list() para não termos um iterável, e sim os +# valores. Observe que, como foi dito acima, a ordem dos elementos não é +# garantida. +list(filled_dict.values()) # => [3, 2, 1] + + +# Verifique a existência de chaves em um dicionário com "in" +"um" in filled_dict # => True +1 in filled_dict # => False + +# Acessar uma chave inexistente gera um KeyError +filled_dict["quatro"] # KeyError + +# Use o método "get()" para evitar um KeyError +filled_dict.get("um") # => 1 +filled_dict.get("quatro") # => None +# O método get permite um parâmetro padrão para quando não existir a chave +filled_dict.get("um", 4) # => 1 +filled_dict.get("quatro", 4) # => 4 + +# "setdefault()" insere em dicionário apenas se a dada chave não existir +filled_dict.setdefault("cinco", 5) # filled_dict["cinco"] tem valor 5 +filled_dict.setdefault("cinco", 6) # filled_dict["cinco"] continua 5 + +# Inserindo em um dicionário +filled_dict.update({"quatro":4}) # => {"um": 1, "dois": 2, "três": 3, "quatro": 4} +#filled_dict["quatro"] = 4 #outra forma de inserir em um dicionário + +# Remova chaves de um dicionário com del +del filled_dict["um"] # Remove a chave "um" de filled_dict + + +# Armazenamento em sets... bem, são conjuntos +empty_set = set() +# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe. +some_set = {1, 1, 2, 2, 3, 4} # some_set agora é {1, 2, 3, 4} + +# Da mesma forma que chaves em um dicionário, elementos de um set devem ser +# imutáveis. +invalid_set = {[1], 1} # => Gera um TypeError: unhashable type: 'list' +valid_set = {(1,), 1} + +# Pode definir novas variáveis para um conjunto +filled_set = some_set + +# Inclua mais um item no set +filled_set.add(5) # filled_set agora é {1, 2, 3, 4, 5} + +# Faça interseção de conjuntos com & +other_set = {3, 4, 5, 6} +filled_set & other_set # => {3, 4, 5} + +# Faça união de conjuntos com | +filled_set | other_set # => {1, 2, 3, 4, 5, 6} + +# Faça a diferença entre conjuntos com - +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Verifique a existência em um conjunto com in +2 in filled_set # => True +10 in filled_set # => False + + + +#################################################### +## 3. Controle de fluxo e iteráveis +#################################################### + +# Iniciemos um variável +some_var = 5 + +# Aqui está uma expressão if. Indentação é significante em python! +# imprime "somevar é menor que10" +if some_var > 10: + print("some_var é absolutamente maior que 10.") +elif some_var < 10: # Esta cláusula elif é opcional. + print("some_var é menor que 10.") +else: # Isto também é opcional. + print("some_var é, de fato, 10.") + + +""" +Laços for iteram sobre listas +imprime: + cachorro é um mamífero + gato é um mamífero + rato é um mamífero +""" +for animal in ["cachorro", "gato", "rato"]: + # Você pode usar format() para interpolar strings formatadas + print("{} é um mamífero".format(animal)) + +""" +"range(número)" retorna um iterável de números +de zero até o número escolhido +imprime: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +"range(menor, maior)" gera um iterável de números +começando pelo menor até o maior +imprime: + 4 + 5 + 6 + 7 +""" +for i in range(4, 8): + print(i) + +""" +"range(menor, maior, passo)" retorna um iterável de números +começando pelo menor número até o maior númeno, pulando de +passo em passo. Se o passo não for indicado, o valor padrão é um. +imprime: + 4 + 6 +""" +for i in range(4, 8, 2): + print(i) +""" + +Laços while executam até que a condição não seja mais válida. +imprime: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Maneira mais curta para for x = x + 1 + +# Lide com exceções com um bloco try/except +try: + # Use "raise" para gerar um erro + raise IndexError("Isto é um erro de índice") +except IndexError as e: + pass # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui. +except (TypeError, NameError): + pass # Varias exceções podem ser gerenciadas, se necessário. +else: # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção. + print("Tudo certo!") # Executa apenas se o código em try não gera exceção +finally: # Sempre é executado + print("Nós podemos fazer o código de limpeza aqui.") + +# Ao invés de try/finally para limpeza você pode usar a cláusula with +with open("myfile.txt") as f: + for line in f: + print(line) + +# Python provê uma abstração fundamental chamada Iterável. +# Um iterável é um objeto que pode ser tratado como uma sequência. +# O objeto retornou a função range, um iterável. + +filled_dict = {"um": 1, "dois": 2, "três": 3} +our_iterable = filled_dict.keys() +print(our_iterable) # => range(1,10). Esse é um objeto que implementa nossa interface iterável. + +# Nós podemos percorrê-la. +for i in our_iterable: + print(i) # Imprime um, dois, três + +# Mas não podemos acessar os elementos pelo seu índice. +our_iterable[1] # Gera um TypeError + +# Um iterável é um objeto que sabe como criar um iterador. +our_iterator = iter(our_iterable) + +# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos. +# Nós acessamos o próximo objeto com "next()". +next(our_iterator) # => "um" + +# Ele mantém o estado enquanto nós o percorremos. +next(our_iterator) # => "dois" +next(our_iterator) # => "três" + +# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator +next(our_iterator) # Gera StopIteration + +# Você pode capturar todos os elementos de um iterador aplicando list() nele. +list(filled_dict.keys()) # => Retorna ["um", "dois", "três"] + + +#################################################### +## 4. Funções +#################################################### + +# Use "def" para criar novas funções. +def add(x, y): + print("x é {} e y é {}".format(x, y)) + return x + y # Retorne valores com a cláusula return + +# Chamando funções com parâmetros +add(5, 6) # => imprime "x é 5 e y é 6" e retorna 11 + +# Outro meio de chamar funções é com argumentos nomeados +add(y=6, x=5) # Argumentos nomeados podem aparecer em qualquer ordem. + +# Você pode definir funções que pegam um número variável de argumentos +# posicionais +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1, 2, 3) + +# Você pode definir funções que pegam um número variável de argumentos nomeados +# também +def keyword_args(**kwargs): + return kwargs + +# Vamos chamá-lo para ver o que acontece +keyword_args(peh="grande", lago="ness") # => {"peh": "grande", "lago": "ness"} + + +# Você pode fazer ambos simultaneamente, se você quiser +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) imprime: + (1, 2) + {"a": 3, "b": 4} +""" + +# Quando chamar funções, você pode fazer o oposto de args/kwargs! +# Use * para expandir tuplas e use ** para expandir dicionários! +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # equivalente a foo(1, 2, 3, 4) +all_the_args(**kwargs) # equivalente a foo(a=3, b=4) +all_the_args(*args, **kwargs) # equivalente a foo(1, 2, 3, 4, a=3, b=4) + +# Retornando múltiplos valores (com atribuição de tuplas) +def swap(x, y): + return y, x # Retorna múltiplos valores como uma tupla sem os parêntesis. + # (Observação: os parêntesis foram excluídos mas podem estar + # presentes) + +x = 1 +y = 2 +x, y = swap(x, y) # => x = 2, y = 1 +# (x, y) = swap(x,y) # Novamente, os parêntesis foram excluídos mas podem estar presentes. + +# Escopo de função +x = 5 + +def setX(num): + # A variável local x não é a mesma variável global x + x = num # => 43 + print (x) # => 43 + +def setGlobalX(num): + global x + print (x) # => 5 + x = num # variável global x agora é 6 + print (x) # => 6 + +setX(43) +setGlobalX(6) + + +# Python tem funções de primeira classe +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) # => 13 + +# Também existem as funções anônimas +(lambda x: x > 2)(3) # => True +(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5 + +# TODO - Fix for iterables +# Existem funções internas de alta ordem +map(add_10, [1, 2, 3]) # => [11, 12, 13] +map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3] + +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# Nós podemos usar compreensão de lista para interessantes mapas e filtros +# Compreensão de lista armazena a saída como uma lista que pode ser uma lista +# aninhada +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +#################################################### +## 5. Classes +#################################################### + + +# Nós usamos o operador "class" para ter uma classe +class Human: + + # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa + # classe. + species = "H. sapiens" + + # Construtor básico, é chamado quando esta classe é instanciada. + # Note que dois sublinhados no início e no final de uma identificados + # significa objetos ou atributos que são usados pelo python mas vivem em + # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos) + # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou + # algumas vezes chamados métodos dunder - "double underscore") + # Você não deve usar nomes assim por sua vontade. + def __init__(self, name): + @ Atribui o argumento ao atributo da instância + self.name = name + + # Um método de instância. Todos os métodos tem "self" como primeiro + # argumento + def say(self, msg): + return "{name}: {message}".format(name=self.name, message=msg) + + # Um método de classe é compartilhado por todas as instâncias + # Eles são chamados com a classe requisitante como primeiro argumento + @classmethod + def get_species(cls): + return cls.species + + # Um método estático é chamado sem uma referência a classe ou instância + @staticmethod + def grunt(): + return "*grunt*" + + +# Instancie uma classe +i = Human(name="Ian") +print(i.say("oi")) # imprime "Ian: oi" + +j = Human("Joel") +print(j.say("olá")) # imprime "Joel: olá" + +# Chama nosso método de classe +i.get_species() # => "H. sapiens" + +# Altera um atributo compartilhado +Human.species = "H. neanderthalensis" +i.get_species() # => "H. neanderthalensis" +j.get_species() # => "H. neanderthalensis" + +# Chama o método estático +Human.grunt() # => "*grunt*" + + +#################################################### +## 6. Módulos +#################################################### + +# Você pode importar módulos +import math +print(math.sqrt(16)) # => 4 + +# Você pode importar apenas funções específicas de um módulo +from math import ceil, floor +print(ceil(3.7)) # => 4.0 +print(floor(3.7)) # => 3.0 + +# Você pode importar todas as funções de um módulo para o namespace atual +# Atenção: isso não é recomendado +from math import * + +# Você pode encurtar o nome dos módulos +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Módulos python são apenas arquivos python comuns. Você +# pode escrever os seus, e importá-los. O nome do +# módulo é o mesmo nome do arquivo. + +# Você pode procurar que atributos e funções definem um módulo. +import math +dir(math) + + +#################################################### +## 7. Avançado +#################################################### + +# Geradores podem ajudar você a escrever código "preguiçoso" +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Um gerador cria valores conforme necessário. +# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em +# cada interação. Isto significa que valores maiores que 15 não serão +# processados em double_numbers. +# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar +# um nome que normalmente colide com uma palavra reservada do python. +range_ = range(1, 900000000) +# Multiplica por 2 todos os números até encontrar um resultado >= 30 +for i in double_numbers(range_): + print(i) + if i >= 30: + break + + +# Decoradores +# Neste exemplo beg encapsula say +# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem +# retornada +from functools import wraps + + +def beg(target_function): + @wraps(target_function) + def wrapper(*args, **kwargs): + msg, say_please = target_function(*args, **kwargs) + if say_please: + return "{} {}".format(msg, "Por favor! Eu sou pobre :(") + return msg + + return wrapper + + +@beg +def say(say_please=False): + msg = "Você me paga uma cerveja?" + return msg, say_please + + +print(say()) # Você me paga uma cerveja? +print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :( +``` + +## Pronto para mais? + +### Free Online + +* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) +* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/) +* [Dive Into Python](http://www.diveintopython.net/) +* [Ideas for Python Projects](http://pythonpracticeprojects.com) +* [The Official Docs](http://docs.python.org/3/) +* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/) +* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) +* [Python Course](http://www.python-course.eu/index.php) +* [First Steps With Python](https://realpython.com/learn/python-first-steps/) +* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python) +* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html) +* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/) + +### Dead Tree + +* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20) +* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20) +* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20) diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown new file mode 100644 index 00000000..99579c35 --- /dev/null +++ b/pt-br/qt-pt.html.markdown @@ -0,0 +1,174 @@ +--- +category: tool +tool: Qt Framework +language: c++ +filename: learnqt-pt.cpp +contributors: + - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] +translators: + - ["Lucas Pugliesi", "https://github.com/fplucas"] +lang: pt-br +--- + +**Qt** é amplamente conhecido como um framework para desenvolvimento de +software multi-plataforma que pode rodar em vários outras plataformas de +softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém +o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido +originalmente escrito em *C++*, é possível utilizá-lo em outras linguagens: +*[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc. + +**Qt** é ótimo para criar aplicações com interface gráfica (GUI). Esse tutorial +será feito em *C++*. + +```c++ +/* + * Vamos começar + */ + +// Todos as dependências do framework Qt iniciam com a letra 'Q' maiúscula +#include <QApplication> +#include <QLineEdit> + +int main(int argc, char *argv[]) { + // Cria um objeto para utilizar todos os recursos da aplicação + QApplication app(argc, argv); + + // Cria um widget com linha editável e exibe na tela + QLineEdit lineEdit("Hello world!"); + lineEdit.show(); + + // Inicia a aplicação em um evento de loop + return app.exec(); +} +``` + +A parte gráfica do **Qt** é toda composta de *widgets* e *conexões* entre eles. + +[LEIA MAIS SOBRE WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html) + +```c++ +/* + * Vamos criar um label e um botão. + * Um label irá aparecer quando o botão for clicado + * + * O próprio código do Qt é autoexplicativo. + */ + +#include <QApplication> +#include <QDialog> +#include <QVBoxLayout> +#include <QPushButton> +#include <QLabel> + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + // Adiciona um layout vertical + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + QLabel textLabel("Thanks for pressing that button"); + layout.addWidget(&textLabel); + textLabel.hide(); + + QPushButton button("Press me"); + layout.addWidget(&button); + + // Exibe o label oculto quando o botão é clicado + QObject::connect(&button, &QPushButton::pressed, + &textLabel, &QLabel::show); + + return app.exec(); +} +``` + +Veja o *QObject::connect*. O método é usado para conectar o *SINAL* de um objeto +ao *ENCAIXE* outro. + +**Sinais** são emitidos quando algo ocorre com o objeto, como quando o sinal de +*clique* é acionado apertando o QPushButton. + +**Encaixes** são *ações* que são executadas em resposta aos sinais recebidos. + +[LEIA MAIS SOBRE SINAIS E ENCAIXES](http://doc.qt.io/qt-5/signalsandslots.html) + + +A seguir vamos aprender como usar não somente o comportamento padrão dos +widgets, mas também extender seus comportamentos usando herança. Vamos criar um +botão e contar quantas vezes é pressionado. Para esse propósito definiremos +nossa própria classe *CounterLabel*. Ela deve ser declarada em um arquivo +diferente devido a estrutura específica do Qt. + +```c++ +// counterlabel.hpp + +#ifndef COUNTERLABEL +#define COUNTERLABEL + +#include <QLabel> + +class CounterLabel : public QLabel { + Q_OBJECT // Define os macros presente em todo objeto Qt + +public: + CounterLabel() : counter(0) { + setText("Counter has not been increased yet"); // método do QLabel + } + +public slots: + // Ação que será chamada em resposta ao clique do botão + void increaseCounter() { + setText(QString("Counter value: %1").arg(QString::number(++counter))); + } + +private: + int counter; +}; + +#endif // COUNTERLABEL +``` + +```c++ +// main.cpp +// Quase igual ao exemplo anterior + +#include <QApplication> +#include <QDialog> +#include <QVBoxLayout> +#include <QPushButton> +#include <QString> +#include "counterlabel.hpp" + +int main(int argc, char *argv[]) { + QApplication app(argc, argv); + + QDialog dialogWindow; + dialogWindow.show(); + + QVBoxLayout layout; + dialogWindow.setLayout(&layout); + + CounterLabel counterLabel; + layout.addWidget(&counterLabel); + + QPushButton button("Push me once more"); + layout.addWidget(&button); + QObject::connect(&button, &QPushButton::pressed, + &counterLabel, &CounterLabel::increaseCounter); + + return app.exec(); +} +``` + +É isso! Claro, o framework Qt é muito maior do que exemplificamos no tutorial, +então esteja preparado para ler e praticar mais. + +## Leitura complementar + +- [Tutoriais Qt 4.8](http://doc.qt.io/qt-4.8/tutorials.html) +- [Tutoriais Qt 5](http://doc.qt.io/qt-5/qtexamplesandtutorials.html) + +Boa sorte e divirta-se! diff --git a/pt-br/ruby-ecosystem-pt.html.markdown b/pt-br/ruby-ecosystem-pt.html.markdown new file mode 100644 index 00000000..da4f6f37 --- /dev/null +++ b/pt-br/ruby-ecosystem-pt.html.markdown @@ -0,0 +1,147 @@ +--- +category: tool +tool: ruby ecosystem +contributors: + - ["Jon Smock", "http://github.com/jonsmock"] + - ["Rafal Chmiel", "http://github.com/rafalchmiel"] +translators: + - ["Claudson Martins", "http://github.com/claudsonm"] +lang: pt-br + +--- + +Pessoas utilizando Ruby geralmente têm uma forma de instalar diferentes versões +do Ruby, gerenciar seus pacotes (ou gemas) e as dependências das gemas. + +## Gerenciadores Ruby + +Algumas plataformas possuem o Ruby pré-instalado ou disponível como um pacote. +A maioria dos "rubistas" não os usam, e se usam, é apenas para inicializar outro +instalador ou implementação do Ruby. Ao invés disso, rubistas tendêm a instalar +um gerenciador para instalar e alternar entre diversas versões do Ruby e seus +ambientes de projeto. + +Abaixo estão os gerenciadores Ruby mais populares: + +* [RVM](https://rvm.io/) - Instala e alterna entre os rubies. RVM também possui + o conceito de gemsets para isolar os ambientes dos projetos completamente. +* [ruby-build](https://github.com/sstephenson/ruby-build) - Apenas instala os + rubies. Use este para um melhor controle sobre a instalação de seus rubies. +* [rbenv](https://github.com/sstephenson/rbenv) - Apenas alterna entre os rubies. + Usado com o ruby-build. Use este para um controle mais preciso sobre a forma + como os rubies são carregados. +* [chruby](https://github.com/postmodern/chruby) - Apenas alterna entre os rubies. + A concepção é bastante similar ao rbenv. Sem grandes opções sobre como os + rubies são instalados. + +## Versões do Ruby + +O Ruby foi criado por Yukihiro "Matz" Matsumoto, que continua a ser uma espécie +de [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), embora +isso esteja mudando recentemente. Como resultado, a implementação de referência +do Ruby é chamada de MRI (Matz' Reference Implementation), e quando você ver uma +versão do Ruby, ela está se referindo a versão de lançamento do MRI. + +As três principais versões do Ruby em uso são: + +* 2.0.0 - Lançada em Fevereiro de 2013. Maioria das principais bibliotecas e + suporte a frameworks 2.0.0. +* 1.9.3 - Lançada em Outubro de 2011. Está é a versão mais utilizada pelos rubistas + atualmente. Também [aposentada](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/). +* 1.8.7 - O Ruby 1.8.7 foi + [aposentado](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/). + +A diferença entre a versão 1.8.7 para 1.9.x é muito maior do que a da 1.9.3 para +a 2.0.0. Por exemplo, a série 1.9 introduziu encodes e uma VM bytecode. Ainda +existem projetos na versão 1.8.7, mas eles estão tornando-se uma pequena minoria +pois a maioria da comunidade migrou para a versão, pelo menos, 1.9.2 ou 1.9.3. + +## Implementações Ruby + +O ecossistema Ruby conta com várias diferentes implementações do Ruby, cada uma +com pontos fortes e estados de compatibilidade. Para ser claro, as diferentes +implementações são escritas em diferentes linguagens, mas *todas elas são Ruby*. +Cada implementação possui hooks especiais e recursos extra, mas todas elas +executam arquivos normais do Ruby tranquilamente. Por exemplo, JRuby é escrita +em Java, mas você não precisa saber Java para utilizá-la. + +Muito maduras/compatíveis: + +* [MRI](https://github.com/ruby/ruby) - Escrita em C, esta é a implementação de + referência do Ruby. Por definição, é 100% compatível (consigo mesma). Todos os + outros rubies mantêm compatibilidade com a MRI (veja [RubySpec](#rubyspec) abaixo). +* [JRuby](http://jruby.org/) - Escrita em Java e Ruby, esta implementação + robusta é um tanto rápida. Mais importante ainda, o ponto forte do JRuby é a + interoperabilidade com JVM/Java, aproveitando ferramentas JVM, projetos, e + linguagens existentes. +* [Rubinius](http://rubini.us/) - Escrita principalmente no próprio Ruby, com + uma VM bytecode em C++. Também madura e rápida. Por causa de sua implementação + em Ruby, ela expõe muitos recursos da VM na rubyland. + +Medianamente maduras/compatíveis: + +* [Maglev](http://maglev.github.io/) - Construída em cima da Gemstone, uma + máquina virtual Smalltalk. O Smalltalk possui algumas ferramentas impressionantes, + e este projeto tenta trazer isso para o desenvolvimento Ruby. +* [RubyMotion](http://www.rubymotion.com/) - Traz o Ruby para o desenvolvimento iOS. + +Pouco maduras/compatíveis: + +* [Topaz](http://topazruby.com/) - Escrita em RPython (usando o conjunto de + ferramentas PyPy), Topaz é bastante jovem e ainda não compatível. Parece ser + promissora como uma implementação Ruby de alta performance. +* [IronRuby](http://ironruby.net/) - Escrita em C# visando a plataforma .NET, + o trabalho no IronRuby parece ter parado desde que a Microsoft retirou seu apoio. + +Implementações Ruby podem ter seus próprios números de lançamento, mas elas +sempre focam em uma versão específica da MRI para compatibilidade. Diversas +implementações têm a capacidade de entrar em diferentes modos (1.8 ou 1.9, por +exemplo) para especificar qual versão da MRI focar. + +## RubySpec + +A maioria das implementações Ruby dependem fortemente da [RubySpec](http://rubyspec.org/). +Ruby não tem uma especificação oficial, então a comunidade tem escrito +especificações executáveis em Ruby para testar a compatibilidade de suas +implementações com a MRI. + +## RubyGems + +[RubyGems](http://rubygems.org/) é um gerenciador de pacotes para Ruby mantido +pela comunidade. RubyGems vem com o Ruby, portanto não é preciso baixar separadamente. + +Os pacotes do Ruby são chamados de "gemas", e elas podem ser hospedadas pela +comunidade em RubyGems.org. Cada gema contém seu código-fonte e alguns metadados, +incluindo coisas como versão, dependências, autor(es) e licença(s). + +## Bundler + +[Bundler](http://bundler.io/) é um gerenciador de dependências para as gemas. +Ele usa a Gemfile de um projeto para encontrar dependências, e então busca as +dependências dessas dependências de forma recursiva. Ele faz isso até que todas +as dependências sejam resolvidas e baixadas, ou para se encontrar um conflito. + +O Bundler gerará um erro se encontrar um conflito entre dependências. Por exemplo, +se a gema A requer versão 3 ou maior que a gema Z, mas a gema B requer a versão +2, o Bundler irá notificá-lo que há um conflito. Isso se torna extremamente útil +quando diversas gemas começam a referenciar outras gemas (que referem-se a outras +gemas), o que pode formar uma grande cascata de dependências a serem resolvidas. + +# Testes + +Testes são uma grande parte da cultura do Ruby. O Ruby vem com o seu próprio +framework de teste de unidade chamado minitest (ou TestUnit para Ruby versão 1.8.x). +Existem diversas bibliotecas de teste com diferentes objetivos. + +* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - + Framework de testes "Unit-style" para o Ruby 1.8 (built-in) +* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - + Framework de testes para o Ruby 1.9/2.0 (built-in) +* [RSpec](http://rspec.info/) - Um framework de testes que foca na expressividade +* [Cucumber](http://cukes.info/) - Um framework de testes BDD que analisa testes Gherkin formatados + +## Seja Legal + +A comunidade Ruby orgulha-se de ser uma comunidade aberta, diversa, e receptiva. +O próprio Matz é extremamente amigável, e a generosidade dos rubistas em geral +é incrível. diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown index 89a051d4..1078f6c5 100644 --- a/pt-br/ruby-pt.html.markdown +++ b/pt-br/ruby-pt.html.markdown @@ -4,8 +4,10 @@ lang: pt-br filename: learnruby-pt.rb contributors: - ["Bruno Henrique - Garu", "http://garulab.com"] + - ["Jean Matheus Souto", "http://jeanmatheussouto.github.io"] translators: - ["Katyanna Moura", "https://twitter.com/amelie_kn"] + - ["Alan Peterson Carvalho Silva", "https://twitter.com/DemonKart"] --- ```ruby @@ -100,7 +102,7 @@ caminho_para_a_raiz_do_projeto = '/bom/nome/' caminho = '/nome/ruim/' # Símbolos (são objetos) -# Símbolos são imutáveis, são constantes reutilizáveis representadadas +# Símbolos são imutáveis, são constantes reutilizáveis representados # internamente por um valor inteiro. Eles são frequentemente usados no # lugar de strings para transmitir com eficiência os valores específicos # e significativos @@ -161,9 +163,6 @@ hash['numero'] #=> 5 hash['nada aqui'] #=> nil # Interar sobre hashes com o método #each: -hash.each do |k, v| - puts "#{k} is #{v}" -end hash.each do |k, v| puts "#{k} é #{v}" @@ -262,7 +261,7 @@ somar 3, 4 #=> 7 somar(3,4), 5 #=> 12 # yield -# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco +# Todos os métodos possuem implicitamente um paramêtro opcional que é um bloco # ele pode ser chamado com a palavra chave 'yield' def ao_redor @@ -287,7 +286,7 @@ class Humano # Inicialização básica (contructor) def initialize(nome, idade=0) - # Atribui o argumento para a variável de instancia "nome" do objeto + # Atribui o argumento para a variável de instância "nome" do objeto @nome = nome # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos @idade = idade @@ -303,7 +302,7 @@ class Humano @nome end - # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância. + # Um método de classe usa a palavra chave self para se diferenciar dos métodos de instância. # Ele só pode ser chamado na classe, não na instancia def self.diz(msg) puts "#{msg}" @@ -364,7 +363,7 @@ Trabalhador.foo # 0 Humano.foo = 2 # 2 Trabalhador.foo # 2 -# Uma variável de instância não é compartilhada por suas classes decendentes. +# Uma variável de instância não é compartilhada por suas classes descendentes. class Humano @bar = 0 @@ -384,4 +383,65 @@ end Humano.bar # 0 Doutor.bar # nil +--- + +module ModuloDeExemplo + def foo + 'foo' + end +end + +# Incluir (include) módulos conecta seus métodos às instâncias da classe +# Herdar (extend) módulos conecta seus métodos à classe em si + +class Pessoa + include ExemploDeModulo +end + +class Livro + extend ExemploDeModulo +end + +Pessoa.foo # => NoMethodError: undefined method `foo' for Pessoa:Class +Pessoa.new.foo # => 'foo' +Livro.foo # => 'foo' +Livro.new.foo # => NoMethodError: undefined method `foo' + +# Callbacks são executados ao incluir e herdar um módulo + +module ExemploDeConceito + def self.included(base) + base.extend(MetodosDeClasse) + base.send(:include, MetodosDeInstancia) + end + + module MetodosDeClasse + def bar + 'bar' + end + end + + module MetodosDeInstancia + def qux + 'qux' + end + end +end + +class Algo + include ExemploDeConceito +end + +Algo.bar # => 'bar' +Algo.qux # => NoMethodError: undefined method `qux' +Algo.new.bar # => NoMethodError: undefined method `bar' +Algo.new.qux # => 'qux' ``` + +## Recursos adicionais + +- [Aprenda Ruby com desafios](http://www.learneroo.com/modules/61/nodes/338) - Uma coleção de desafios para testar a linguagem. +- [Documentação oficial](http://www.ruby-doc.org/core-2.1.1/) +- [Ruby a partir de outras linguagens](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) +- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/)- Um mais antigo [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) e tambem uma versão online disponível. +- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Uma versão colaborativa de um *style-guide* diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown new file mode 100644 index 00000000..8134d3c5 --- /dev/null +++ b/pt-br/rust-pt.html.markdown @@ -0,0 +1,332 @@ +--- +language: rust +filename: rust-pt.rs +contributors: + - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"] +lang: pt-br + +--- + +Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust +combina controle de baixo nível sobre o desempenho com facilidades de alto +nível e garantias de segurança. + +Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo +*runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas +em C. + +A primeira versão de Rust, 0.1, apareceu em janeiro de 2012, e por três anos o +desenvolvimento correu tão rapidamente que que até recentemente o uso de +versões estáveis foi desencorajado e em vez disso a recomendação era usar as +versões empacotadas toda noite. + +Em 15 de maio de 2015, a versão 1.0 de Rust foi liberada com a garantia total +de compatibilidade reversa. Melhorias no tempo de compilação e em outros +aspectos do compilador estão disponíveis atualmente nas versões empacotadas à +noite. Rust adotou um modelo de versões *train-based* com novas versões +regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi +disponibilizada ao mesmo tempo que a versão 1.0. + +Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos +funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust +não apenas rápido, mas também fácil e eficiente para programar. + +```rust +// Isso é um comentário. Linhas de comentários são assim... +// e múltiplas linhas se parecem assim. + +/// Comentários para documentação são assim e permitem notação em markdown. +/// # Exemplos +/// +/// ``` +/// let five = 5 +/// ``` + +/////////////// +// 1. Básico // +/////////////// + +// Funções +// `i32` é o tipo para inteiros com sinal de 32 bits +fn add2(x: i32, y: i32) -> i32 { + // Implicit return (no semicolon) + x + y +} + +// Função main +fn main() { + // Números // + + // Immutable bindings + let x: i32 = 1; + + // Inteiros/Sufixos para ponto flutuante + let y: i32 = 13i32; + let f: f64 = 1.3f64; + + // Inferência de tipos + // Em geral, o compilador Rust consegue inferir qual o tipo de uma + // variável, então você não tem que escrever uma anotação explícita de tipo. + // Ao longo desse tutorial, os tipos serão explicitamente anotados em + // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de + // tipos pode gerenciar isso na maioria das vezes. + let implicit_x = 1; + let implicit_f = 1.3; + + // Aritmética + let sum = x + y + 13; + + // Variáveis mutáveis + let mut mutable = 1; + mutable = 4; + mutable += 2; + + // Strings // + + // String literais + let x: &str = "hello world!"; + + // Imprimindo + println!("{} {}", f, x); // 1.3 hello world + + // Uma `String` – uma String alocada no heap + let s: String = "hello world".to_string(); + + // Uma String slice - uma visão imutável em outra string. + // Basicamente, isso é um par imutável de ponteiros para uma string - ele + // não contém o conteúdo de uma strinf, apenas um ponteiro para o começo e + // um ponteiro para o fim da área de memória para a string, estaticamente + // alocada ou contida em outro objeto (nesse caso, `s`) + let s_slice: &str = &s; + + println!("{} {}", s, s_slice); // hello world hello world + + // Vetores/arrays // + + // Um array de tamanho fixo + let four_ints: [i32; 4] = [1, 2, 3, 4]; + + // Um array dinâmico (vetor) + let mut vector: Vec<i32> = vec![1, 2, 3, 4]; + vector.push(5); + + // Uma fatia – uma visão imutável em um vetor ou array + // Isso é como um string slice, mas para vetores + let slice: &[i32] = &vector; + + // Use `{:?}` para imprimir alguma coisa no estilo de depuração + println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + + // Tuplas // + + // Uma tupla é um conjunto de tamanho fixo de valores de tipos + // possivelmente diferentes + let x: (i32, &str, f64) = (1, "hello", 3.4); + + // Desestruturando `let` + let (a, b, c) = x; + println!("{} {} {}", a, b, c); // 1 hello 3.4 + + // Indexando + println!("{}", x.1); // hello + + ////////////// + // 2. Tipos // + ////////////// + + // Struct + struct Point { + x: i32, + y: i32, + } + + let origin: Point = Point { x: 0, y: 0 }; + + // Uma estrutura com campos sem nome, chamada 'estrutura em tupla' + struct Point2(i32, i32); + + let origin2 = Point2(0, 0); + + // enum básico com na linguagem C + enum Direction { + Left, + Right, + Up, + Down, + } + + let up = Direction::Up; + + // Enum com campos + enum OptionalI32 { + AnI32(i32), + Nothing, + } + + let two: OptionalI32 = OptionalI32::AnI32(2); + let nothing = OptionalI32::Nothing; + + // Generics // + + struct Foo<T> { bar: T } + + // Isso é definido na biblioteca padrão como um `Option` + enum Optional<T> { + SomeVal(T), + NoVal, + } + + // Methods // + + impl<T> Foo<T> { + // Métodos recebem um parâmetro `self` explícito + fn get_bar(self) -> T { + self.bar + } + } + + let a_foo = Foo { bar: 1 }; + println!("{}", a_foo.get_bar()); // 1 + + // Traits (conhecidos como interfaces ou typeclasses em outras linguagens)// + + trait Frobnicate<T> { + fn frobnicate(self) -> Option<T>; + } + + impl<T> Frobnicate<T> for Foo<T> { + fn frobnicate(self) -> Option<T> { + Some(self.bar) + } + } + + let another_foo = Foo { bar: 1 }; + println!("{:?}", another_foo.frobnicate()); // Some(1) + + ////////////////////////////////// + // 3. Reconhecimento de padrões // + ////////////////////////////////// + + let foo = OptionalI32::AnI32(1); + match foo { + OptionalI32::AnI32(n) => println!("it’s an i32: {}", n), + OptionalI32::Nothing => println!("it’s nothing!"), + } + + // Reconhecimento avançado de padrões + struct FooBar { x: i32, y: OptionalI32 } + let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) }; + + match bar { + FooBar { x: 0, y: OptionalI32::AnI32(0) } => + println!("The numbers are zero!"), + FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m => + println!("The numbers are the same"), + FooBar { x: n, y: OptionalI32::AnI32(m) } => + println!("Different numbers: {} {}", n, m), + FooBar { x: _, y: OptionalI32::Nothing } => + println!("The second number is Nothing!"), + } + + ////////////////////////// + // 4. Controle de fluxo // + ////////////////////////// + + // `for` laços de repetição/iteração + let array = [1, 2, 3]; + for i in array.iter() { + println!("{}", i); + } + + // Ranges + for i in 0u32..10 { + print!("{} ", i); + } + println!(""); + // prints `0 1 2 3 4 5 6 7 8 9 ` + + // `if` + if 1 == 1 { + println!("Maths is working!"); + } else { + println!("Oh no..."); + } + + // `if` como expressão + let value = if true { + "good" + } else { + "bad" + }; + + // laço `while` de repetição + while 1 == 1 { + println!("The universe is operating normally."); + } + + // Repetição infinita + loop { + println!("Hello!"); + } + + //////////////////////////////////////// + // 5. Proteção de memória & ponteiros // + //////////////////////////////////////// + + // Ponteiro com dono - somente uma coisa pode 'possuir' esse ponteiro por + // vez. + // Isso significa que quando `Box` perde seu escopo, ele pode ser + // automaticamente desalocado com segurança. + let mut mine: Box<i32> = Box::new(3); + *mine = 5; // dereference + // Aqui, `now_its_mine` possui o controle exclusivo de `mine`. Em outras + // palavras, `mine` tem o controle transferido. + let mut now_its_mine = mine; + *now_its_mine += 2; + + println!("{}", now_its_mine); // 7 + // println!("{}", mine); // não compila porque `now_its_mine` é o dono + + // Referência - um ponteiro imutável que referencia outro dado + // Quando uma referência é dada a um valor, nós dizemos que o valor foi + // emprestado 'borrowed'. + // Quando um valor é emprestado sem ser mutável, ele não pode ser alterado + // ou ter a sua propriedade transferida. + // Um empréstimo finaliza quando o escopo em que ele foi criado termina. + + let mut var = 4; + var = 3; + let ref_var: &i32 = &var; + + println!("{}", var); // AO contrário de `mine`, `var` ainda pode ser usado + println!("{}", *ref_var); + // var = 5; // não compila porque `var` é emprestado + // *ref_var = 6; // não compila, porque `ref_var` é uma referência imutável + + // Referência mutável + // Quando um valor mutável é emprestado, ele não pode ser acessado. + let mut var2 = 4; + let ref_var2: &mut i32 = &mut var2; + *ref_var2 += 2; // '*' aponta para var2, que é mutável e emprestada + + println!("{}", *ref_var2); // 6 , // var2 não compila. + // ref_var2 é do tipo &mut i32, que guarda uma referência i32, não o valor. + // var2 = 2; // não compila porque `var2` é empretada. +} +``` + +## Outras leituras + +Existe muita coisa sobre Rust - isto aqui é apenas o básico para que você possa +entender as coisas mais importantes. Para aprender mais sobre Rust, leia [The +Rust Programming Language](http://doc.rust-lang.org/book/index.html) e +acompanhe [/r/rust](http://reddit.com/r/rust). A galera no canal #rust do +irc.mozilla.org também estão sempre dispostos a ajudar os novatos. + +Você pode brincar com outras característica de Rust com um compilador online +no portal oficial do projeto [Rust playpen](http://play.rust-lang.org), or ler +mais na página oficial [Rust website](http://rust-lang.org). + +No Brasil acompanhe os encontros do [Meetup Rust São Paulo] +(http://www.meetup.com/pt-BR/Rust-Sao-Paulo-Meetup/). + diff --git a/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown new file mode 100644 index 00000000..3d91f1ca --- /dev/null +++ b/pt-br/sass-pt.html.markdown @@ -0,0 +1,452 @@ +--- +language: sass +filename: learnsass-pt.scss +contributors: + - ["Laura Kyle", "https://github.com/LauraNK"] + - ["Sean Corrales", "https://github.com/droidenator"] +translators: + - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"] + - ["Cássio Böck", "https://github.com/cassiobsilva"] +lang: pt-br +--- + +Sass é uma linguagem de extensão CSS que adiciona recursos, como variáveis, aninhamento, mixins e muito mais. +Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os desenvolvedores a escrever código de fácil manutenção e DRY (Do not Repeat Yourself). + +Sass tem duas opções de sintaxe diferentes para escolher. SCSS, que tem a mesma sintaxe de CSS, mas com os recursos adicionais de Sass. Ou Sass (a sintaxe original), que usa o recuo, em vez de chaves e ponto e vírgula. +Este tutorial é escrito usando SCSS. + +Se você já está familiarizado com CSS3, você será capaz de pegar Sass de forma relativamente rápida. Ele não fornece quaisquer novas opções de estilo, mas sim as ferramentas para escrever sua CSS de forma mais eficiente e fazer a manutenção mais fácilmente. + +```scss + + +// Comentários de linha única são removidos quando Sass é compilado para CSS. + +/* Comentários multi-line são preservados. */ + + + +/*Variáveis +==============================*/ + + + +/* É possível armazenar um valor CSS (tais como a cor) de uma variável. +Use o símbolo "$" para criar uma variável. */ + +$primary-color: #A3A4FF; +$secondary-color: #51527F; +$body-font: 'Roboto', sans-serif; + +/* Você pode usar as variáveis em toda a sua folha de estilo. +Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */ + +body { + background-color: $primary-color; + color: $secondary-color; + font-family: $body-font; +} + +/* Quando compilar ficaria assim: */ +body { + background-color: #A3A4FF; + color: #51527F; + font-family: 'Roboto', sans-serif; +} + + +/ * Este é muito mais fácil de manter do que ter de mudar a cor +cada vez que aparece em toda a sua folha de estilo. * / + + + + +/*Mixins +==============================*/ + + + +/* Se você achar que você está escrevendo o mesmo código para mais de um +elemento, você pode querer armazenar esse código em um mixin. + +Use a diretiva '@mixin', além de um nome para o seu mixin. */ + +@mixin center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +/* Você pode usar o mixin com '@include' e o nome mixin. */ + +div { + @include center; + background-color: $primary-color; +} + +/* Apoś compilar ficaria assim: */ +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #A3A4FF; +} + + +/* Você pode usar mixins para criar uma propriedade estenográfica. */ + +@mixin size($width, $height) { + width: $width; + height: $height; +} + +/* O que você pode invocar passando argumentos de largura e altura. */ + +.rectangle { + @include size(100px, 60px); +} + +.square { + @include size(40px, 40px); +} + +/* Isso compilado ficará assim: */ +.rectangle { + width: 100px; + height: 60px; +} + +.square { + width: 40px; + height: 40px; +} + + + +/*Funções +==============================*/ + + + +/* Sass fornece funções que podem ser utilizados para realizar uma variedade de + tarefas. Considere o seguinte */ + +/* Funções pode ser chamado usando seu nome e passando o + argumentos necessários */ +body { + width: round(10.25px); +} + +.footer { + background-color: fade_out(#000000, 0.25) +} + +/* Compiles to: */ + +body { + width: 10px; +} + +.footer { + background-color: rgba(0, 0, 0, 0.75); +} + +/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos + mixins. Ao tentar escolher entre uma função ou um mixin, lembre- + que mixins são os melhores para gerar CSS enquanto as funções são melhores para + lógica que pode ser usado em todo o seu código Sass. Os exemplos + seção Operadores Math 'são candidatos ideais para se tornar um reutilizável + função. */ + +/* Esta função terá um tamanho de destino eo tamanho do pai e calcular + e voltar a percentagem */ + +@function calculate-percentage($target-size, $parent-size) { + @return $target-size / $parent-size * 100%; +} + +$main-content: calculate-percentage(600px, 960px); + +.main-content { + width: $main-content; +} + +.sidebar { + width: calculate-percentage(300px, 960px); +} + +/* Compila para: */ + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + + + +/* Extend (Herança) +============================== */ + + + +/*Extend é uma maneira de compartilhar as propriedades de um seletor com outro. */ + +.display { + @include size(5em, 5em); + border: 5px solid $secondary-color; +} + +.display-success { + @extend .display; + border-color: #22df56; +} + +/* Compiles to: */ +.display, .display-success { + width: 5em; + height: 5em; + border: 5px solid #51527F; +} + +.display-success { + border-color: #22df56; +} + +/* Ampliando uma declaração CSS é preferível a criação de um mixin + por causa da maneira agrupa as classes que todos compartilham + o mesmo estilo base. Se isso for feito com um mixin, a largura, + altura, e a borda seria duplicado para cada instrução que + o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será + adicionar inchaço desnecessário para os arquivos criados pelo compilador Sass. */ + + + +/*Assentamento +==============================*/ + + + +/ * Sass permite seletores ninhos dentro seletores * / + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: #FF0000; + } +} + +/* '&' será substituído pelo selector pai. */ +/* Você também pode aninhar pseudo-classes. */ +/* Tenha em mente que o excesso de nidificação vai fazer seu código menos sustentável. +Essas práticas também recomendam não vai mais de 3 níveis de profundidade quando nidificação. +Por exemplo: */ + + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: red; + + &:hover { + background-color: blue; + } + + a { + color: white; + } + } +} + +/* Compila para: */ + +ul { + list-style-type: none; + margin-top: 2em; +} + +ul li { + background-color: red; +} + +ul li:hover { + background-color: blue; +} + +ul li a { + color: white; +} + + + +/*Parciais e Importações +==============================*/ + + +/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass + código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css. + Parciais não são geradas em CSS. */ + + + +/* Considere o seguinte CSS que nós vamos colocar em um arquivo chamado _reset.css */ + +html, +body, +ul, +ol { + margin: 0; + padding: 0; +} + +/* Sass oferece @import que pode ser usado para importar parciais em um arquivo. + Isso difere da declaração CSS @import tradicional, que faz + outra solicitação HTTP para buscar o arquivo importado. Sass converte os + importadas arquivo e combina com o código compilado. */ + +@import 'reset'; + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + +/* Compiles to: */ + +html, body, ul, ol { + margin: 0; + padding: 0; +} + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + + + +/*Placeholder Selectors +==============================*/ + + +/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você + queria criar uma instrução CSS que foi usado exclusivamente com @extend, + Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez + de '.' ou '#'. Espaços reservados não aparece no CSS compilado. * / + +%content-window { + font-size: 14px; + padding: 10px; + color: #000; + border-radius: 4px; +} + +.message-window { + @extend %content-window; + background-color: #0000ff; +} + +/* Compilado para: */ + +.message-window { + font-size: 14px; + padding: 10px; + color: #000; + border-radius: 4px; +} + +.message-window { + background-color: #0000ff; +} + + + +/*Operações Math +============================== * / + + +/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem + ser úteis para calcular os valores diretamente no seu Sass arquivos em vez + de usar valores que você já calculados pela mão. Abaixo está um exemplo + de uma criação de um projeto simples de duas colunas. * / + +$content-area: 960px; +$main-content: 600px; +$sidebar-content: 300px; + +$main-size: $main-content / $content-area * 100%; +$sidebar-size: $sidebar-content / $content-area * 100%; +$gutter: 100% - ($main-size + $sidebar-size); + +body { + width: 100%; +} + +.main-content { + width: $main-size; +} + +.sidebar { + width: $sidebar-size; +} + +.gutter { + width: $gutter; +} + +/* Compiles to: */ + +body { + width: 100%; +} + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + +.gutter { + width: 6.25%; +} + + +``` + + + +## SASS ou Sass? +Alguma vez você já se perguntou se Sass é um acrônimo ou não? Você provavelmente não tem, mas vou dizer-lhe de qualquer maneira. O nome do idioma é uma palavra, "Sass", e não uma sigla. +Porque as pessoas estavam constantemente a escrevê-lo como "SASS", o criador da linguagem de brincadeira chamou de "StyleSheets Sintaticamente Incríveis". + + +## Prática Sass +Se você quiser jogar com Sass em seu navegador, vá para [SassMeister](http://sassmeister.com/). +Você pode usar uma sintaxe, basta ir para as configurações e selecionar Sass ou SCSS. + + +## Compatibilidade + +Sass pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo +em CSS. Você vai querer verificar se o CSS que você está usando é compatível +com os seus navegadores de destino. + +[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificação de compatibilidade. + + +## Leitura +* [Official Documentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html) +* [The Sass Way](http://thesassway.com/) fornece tutoriais (iniciante avançados) e artigos. diff --git a/pt-br/scala-pt.html.markdown b/pt-br/scala-pt.html.markdown new file mode 100644 index 00000000..3459f567 --- /dev/null +++ b/pt-br/scala-pt.html.markdown @@ -0,0 +1,668 @@ +--- +language: Scala +filename: learnscala-pt.scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra", "http://dbousamra.github.com"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Ha-Duong Nguyen", "http://reference-error.org"] +translators: + - ["Francieli Viane", "https://github.com/FFrancieli"] +lang: pt-br +--- + +Scala - a linguagem escalável + +```scala + +///////////////////////////////////////////////// +// 0. O básico +///////////////////////////////////////////////// +/* + Configurando o Scala: + + 1) Baixe o instalador do Scala - http://www.scala-lang.org/downloads + 2) Extraia (unzip ou tar) para sua localização favorita e coloque o subdiretório + bin na variável de ambiente `PATH` +*/ + +/* + Tente o REPL + + Scala tem uma ferramenta chamada REPL (Read-Eval-Print Loop) que é análogo a + interpretadores de linha de comando de outras linguagens. Você pode digitar + qualquer expressão de Scala e o resultado será calculado e impresso. + + O REPL é uma ferramenta muito conveniente para testar e verificar código. Use-o + enquanto você lê o tutorial para explorar os conceitos rapidamente por conta própria. +*/ + +//Inicialize um REPL de Scala executando o comando scala no terminal. Você deve ver o prompt: +$ scala +scala> + +//Por padrão, cada expressão que você executa é salva como um novo valor enumerado: +scala> 2 + 2 +res0: Int = 4 + +// Valores padrões podem ser reutilizados. Observe o tipo do valor exibido no resultado... +scala> res0 + 2 +res1: Int = 6 + +// Scala é uma linguagem fortemente tipada. Você pode usar o REPL para verfificar o tipo +// sem avaliar uma expressão. + +scala> :type (true, 2.0) +(Boolean, Double) + +// As sessões do REPL podem ser salvas +scala> :save /sites/repl-test.scala + +//Arquivos podem ser carregados no REPL +scala> :load /sites/repl-test.scala +Loading /sites/repl-test.scala... +res2: Int = 4 +res3: Int = 6 + +// Você pode pesquisar em seu histórico recente +scala> :h? +1 2 + 2 +2 res0 + 2 +3 :save /sites/repl-test.scala +4 :load /sites/repl-test.scala +5 :h? + +// Agora que você já sabe brincar, vamos aprender um pouco de Scala... + +///////////////////////////////////////////////// +// 1. Introdução +///////////////////////////////////////////////// + +// Comentários de uma linha começam com duas barras + +/* + Comentários com múltiplas linhas, como você já pode ver, são assim. +*/ + +// Imprimir e forçar uma linha na próxima impressão +println("Hello world!") +println(10) +// Hello world! +// 10 + +//Imprimir sem forçar uma nova linha na próxima impressão +print("Hello world") +print(10) +// Hello world10 + +//A declaração de valores pode ser feita usando tanto o var quanto o val. +// Declarações feitas com `val` são imutáveis, enquanto que declarações feitas +// com var são mutáveis. Imutabilidade é uma coisa boa. +val x = 10 // x is now 10 +x = 20 // error: reassignment to val +var y = 10 + = 20 // y agora é 20 + +/* + Scala é uma linguagem estaticamente tipada. Observe ainda que nas declarações + acima nós não especificamos um tipo. Isso se deve a um recurso da linguagem + chamado de inferência. Na maioria dos casos, o compilador do Scala consegue + adivinhar qual tipo é, de forma que você não precisa digitar sempre. Nós + podemos declarar o tipo da variável de maneira explícita asim: +*/ + +val z: Int = 10 +val a: Double = 1.0 + +// Note que a conversão automática de Int para Double, o resultado é 10.0, não 10 +val b: Double = 10 + +//Valores booleanos +true +false + +//Operações booleanas +!true // false +!false // true +true == false // false +10 > 5 // true + +// Matemática é como o de costume +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 +6 / 4 // 1 +6.0 / 4 // 1.5 +6 / 4.0 // 1.5 + +// Calcular uma expressão no REPL te dá o tipo e o valor do resultado +1 + 7 + +/* A linha acima resulta em: + scala> 1 + 7 + res29: Int = 8 + + Isso significa que o resultado ao culcular 1 + 7 é um objeto do tipo Int com + valor 8. + + Note que "res29" é o nome de uma variável gerada sequencialmente para guardar + os resultados das expressões que você executa, logo seu nome pode ser + diferente. +*/ + +"Strings em Scala são delimitadas por aspas duplas" +'a' // Um caractere em Scala +// 'Strings com aspas simples não existem em Scala.' <= isso causa um erro. + +// Strings possuem os métodos comuns de Java definidos +"hello world".length +"hello world".substring(2, 6) +"hello world".replace("C", "3") + +// Elas também possuem alguns métodos extras do Scala. Veja também: +scala.collection.immutable.StringOps +"hello world".take(5) +"hello world".drop(5) + +//Interpolação de string: observe o prefixo "s" +val n = 45 +s"We have $n apples" // => "We have 45 apples" + +// Também é possível ter expressões dentro de interpolação de strings +val a = Array(11, 9, 6) +s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old." +s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples." +s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" + +// Formatação de strings interpoladas com o prefixo "f" +f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" +f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" + + +// Strings cruas, ignorando caracteres especiais +raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." + +//Alguns caracteres precisam ser "escapados", ex. uma aspa dupla dentro de uma string + +"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" + +// Aspas triplas permitem strings a abrangerem múltiplas linhas e conter Aspas +val html = """<form id="daform"> + <p>Press belo', Joe</p> + <input type="submit"> + </form>""" + + +///////////////////////////////////////////////// +// 2. Funções +///////////////////////////////////////////////// + +// Funções são definidas da seguinte maneira: +// +// def nomeDaFuncao(args ...): TipoDeRetorno = {body ...} +// +// Se você vem de linguagens mais tradicionais, note a omissão da palavra chave +//return. Em Scala a última expressão no bloco da função é o valor de retorno +def sumOfSquares(x: Int, y: Int): Int = { + val x2 = x * x + val y2 = y * y + x2 + y2 +} + +// As { } podem ser omitidas se o corpo da função possui apenas uma expressão: +def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y + +// A sintaxe para chamar funções é familiar: +sumOfSquares(3, 4) // => 25 + +// Você poode usar o nome dos parâmetros para especificá-los numa ordem diferente +def subtract(x: Int, y: Int): Int = x - y + +subtract(10, 3) // => 7 +subtract(y=10, x=3) // => -7 + +// Na maioria dos casos (sendo funções recursivas a a exceção mais notável) o +// tipo de retorno da função pode ser omitido, e o mesmo tipo de inferência que +// vimos nas variáveis funcionará com o valor de retorno da função: +def sq(x: Int) = x * x // O compilador consegue adivinhar que o tipo de retorno é Int + +// Funções podem ter parâmetros padrão: +def addWithDefault(x: Int, y: Int = 5) = x + y +addWithDefault(1, 2) // => 3 +addWithDefault(1) // => 6 + +// Funções anônimas são semelhantes a essa: +(x: Int) => x * x + +// Diferente de defs, até mesmo a entrada de funções anônimas podem ser omitidas +// se o contexto deixar isso claro. Observe o tipo "Int => Int", que significa +// uma função que recebe umn Int e retorna um Int. +val sq: Int => Int = x => x * x + +// Se cada argumento na sua função anônima é usado apenas uma vez, Scala te fornece +// uma maneira ainda mais curta de definí-lo. Estas funções anônimas acabam por +// ser muito comuns, como será mostrado na sessão de estrutura de dados. +val addOne: Int => Int = _ + 1 +val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) + +addOne(5) // => 6 +weirdSum(2, 4) // => 16 + +// A palavra chave return existe em Scala, mas só retorna do def mais profundo que o cerca. +//AVISO: O uso do return em Scala é propenso a erros e deve ser evitado. +//Não há efeito em funções anônimas. Per exemplo: +def foo(x: Int): Int = { + val anonFunc: Int => Int = { z => + if (z > 5) + return z // Esta linha faz Z retornar o valor de foo! + else + z + 2 // Esta linha retorna o valor de anonFunc + } + anonFunc(x) // Esta linha retorna o valor de foo +} + +///////////////////////////////////////////////// +// 3. Controle de Fluxo +///////////////////////////////////////////////// + +1 to 5 +val r = 1 to 5 +r.foreach(println) + +r foreach println +///N.B.: Scala é bem flexível quando se fala de pontos e parêntesis - estude as regras +//separadamente. Isso ajuda a escrever DSLs e APIs que são lidas como inglês. + +(5 to 1 by -1) foreach (println) + +// Um loop while +var i = 0 +while (i < 10) { println("i " + i); i += 1 } + +while (i < 10) { println("i " + i); i += 1 } // Sim, de novo. O que aconteceu? Por quê? + +i // Exibe o valor de i. Note que o while é um loop no senso clássico - + // executa sequencialmente enquanto muda a variável do loop. While é muito + // rápido, mas usar os combinadores e compreenões acima é mais fácil + // para entender e paralizar + +// Um loop do-while +i = 0 +do { + println("i ainda é menor que 10") + i += 1 +} while (i < 10) + + +// Recursão é a forma mais idiomática de repetir uma ação em Scala (assim como na +// maioria das linguagens de programação funcional) +// Funções recursivas precisam de um tipo de retorno explícito, o compilador não +// consegue inferir; +// Aqui está o Unit +def showNumbersInRange(a: Int, b: Int): Unit = { + print(a) + if (a < b) + showNumbersInRange(a + 1, b) +} +showNumbersInRange(1, 14) + +// Condicionais + +al x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + +///////////////////////////////////////////////// +// 4. Estrutura de Dados +///////////////////////////////////////////////// + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) // Int = 1 +a(3) // Int = 5 +a(21) // Lança uma exceção + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") // java.lang.String = no lo se + +val s = Set(1, 3, 7) +s(0) // Boolean = false +s(1) // Boolean = true + +/* Veja a documantação do map aqui - + * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + * e garanta que você leia + */ + + // Tuplas + + (1, 2) + + (4, 3, 2) + + (1, 2, "three") + + (a, 2, "three") + + //Por que ter isso? + val divideInts = (x: Int, y: Int) => (x / y, x % y) + +//A função divideInts te dá o resultado e o resultado +divideInts(10, 3) // (Int, Int) = (3,1) + +//Para acessar os elementos de uma tupla, use _._n onde n é o índex do elemento + +val d = divideInts(10, 3) // (Int, Int) = (3,1) + +d._1 // Int = 3 +d._2 // Int = 1 + +// Alternativamente, você pode atribuir múltiplas variáveis para uma tupla, o +// que é mais conveniente e legível em muitos casos +val (div, mod) = divideInts(10, 3) + +div // Int = 3 +mod // Int = 1 + +///////////////////////////////////////////////// +// 5. Object Oriented Programming +///////////////////////////////////////////////// + +/* + Tudo o que vimos até agora neste tutorial foram expressões simples (valores, funções, etc). + Essas expressões são boas para digitar no interpretador da linha de comando para + testes rápidos, mas elas não podem existir por si só em um arquivo Scala. Por exemplo, + você não pode ter simplesmente "val x = 5" em um arquivo Scala. Ao invés disso, os únicos + construtores de alto nível permitidos em Scala são: + + - objects + - classes + - case classes + - traits + + E agora vamos explicar o que é cada um deles. +*/ + +//classes são similares a classes em outras linguagens. Os argumentos do construtor +// são declarados logo depois do nome da classe e a inicialização é feita no corpo da classe. + +class Dog(br: String) { + // codigo do construtor aqui + var breed: String = br + + // Define um método chamado bark que retorna uma String + def bark = "Woof, woof!" + + // Assume-se que os métodos e valores são públicos. As palavras chave "protected" + // e "private" também estão disponíveis. + private def sleep(hours: Int) = + println(s"I'm sleeping for $hours hours") + + // Métodos abstratos são simplesmente métodos sem corpo. Se a gente remover o + // comentário da próxima linha a classe Dog teria que ser declarada como abstrata + + // abstract class Dog(...) { ... } + // def chaseAfter(what: String): String +} + +// A palavra chave "object" cria um tipo e uma instância singlenton desse tipo. +// É comum para classes em Scala ter um "companion object" (objeto companheiro), +// onde, por exemlo, o comportamento é capturado pelas classes em si, mas o comportamento +// relacionado a toda instância da classe vai em objects. A diferença é semelhante +// a métodos versus métodos estáticos em outras linguagens. Note que objects e +// classes podem ter o mesmo nome. + +object Dog { + def allKnownBreeds = List("pitbull", "shepherd", "retriever") + def createDog(breed: String) = new Dog(breed) +} + +// Case classes são classes que possuem uma funcionalidade extra incorporada. +// Uma dúvida comum para iniciantes em Scala é quando usar classes e quando usar +// case classes. A linha é bem tênue, mas em geral classes tendem a focar em encapsulamento, +// polimorfismo e comportamento. Os valores nestas classes tendem a ser privados e +// apenas métodos ficam expostos. O propósito primário de uma case class é guardar +// dados imutáveis. Às vezes as case classes possuem alguns poucos métodos, os quais +// raramente possuem efeitos colaterais (side effects). +case class Person(name: String, phoneNumber: String) + +// Cria uma nova instância. Observe que case classes não precisam de usar "new" ao serem instanciadas +val george = Person("George", "1234") +val kate = Person("Kate", "4567") + +// Com case classes você ganha algumas regalias, como getters: +// With case classes, you get a few perks for free, like getters: +george.phoneNumber // => "1234" + +// Verificação de igualdade por campo (sem a necessidade de sobrescrever o método equals) +Person("George", "1234") == Person("Kate", "1236") // => false + +// Uma maneira fácil de copiar +// otherGeorge == Person("george", "9876") +val otherGeorge = george.copy(phoneNumber = "9876") + +// E muitas outras. Case classes também possuem pattern matching de graça. Veja no próximo tópico. + +// Traits a caminho. + + +///////////////////////////////////////////////// +// 6. Pattern Matching +///////////////////////////////////////////////// + +// Pattern matching é um recurso muito poderoso e muito usado em Scala. Aqui +// mostramos como o seu pattern se adequa a uma case class. +// NB: Diferente de outras linguagens, Scala não precisa de quebras. Entrar em +// todas as condições do pattern matching simples não acontece. + +def matchPerson(person: Person): String = person match { + // Enrão você especifica os padrões + case Person("George", number) => "We found George! His number is " + number + case Person("Kate", number) => "We found Kate! Her number is " + number + case Person(name, number) => "We matched someone : " + name + ", phone : " + number +} + +val email = "(.*)@(.*)".r // Define uma regex para o próximo exemplo. + +// Pattern matching pode parecer com o comando switch nas liguagens da família C, +// mas é muito mais poderoso. Em Scala você pode encontrar mais correpondências: + +def matchEverything(obj: Any): String = obj match { + // Você pode encontrar valores correspondentes: + case "Hello world" => "Got the string Hello world" + + // Você pode fazer correspondência por tipo: + case x: Double => "Got a Double: " + x + + // Você pode especificar condições: + case x: Int if x > 10000 => "Got a pretty big number!" + + // Você pode encontrar correspondência com case classes, como fizemos antes: + case Person(name, number) => s"Got contact info for $name!" + + // Você pode encontrar correspondências por regex: + case email(name, domain) => s"Got email address $name@$domain" + + // Você pode encontrar correspondencias por tuplas: + case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" + + // Você pode encontrar corresponências por estruturas de dados: + case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" + + // Você pode aninhar padrões: + case List(List((1, 2, "YAY"))) => "Got a list of list of tuple" + + // Retornar qualquer valor (padrão - default) caso nenhuma das possibilidades é correspondente. + case _ => "Got unknown object" + + // Na verdade, você pode fazer correspondência de padrão de qualquer objeto que + // tenha o método "unnaply". Este recurso é tão poderoso que o Scala te deixa + // criar funções inteiras como patterns: + + val patternFunc: Person => String = { + case Person("George", number) => s"George's number: $number" + case Person(name, number) => s"Random person's number: $number" + } +} + +///////////////////////////////////////////////// +// 7. Programação Funcional +///////////////////////////////////////////////// + +// Scala permite que métodos e funções recebam ou retornem outras funções ou métodos. + +val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int +List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element + +// Funções anônimas podem ser usadas ao invés de funções com nomes: +List(1, 2, 3) map (x => x + 10) + +// E o símbolo underline ("_") pode ser usado quando há apenas um argumento para a função anônima. +List(1, 2, 3) map (_ + 10) + +// Se tanto o bloco animo quanto a função que você estiver usando receberem apenas +// um argumento, você pode inclusive omitir o símbolo _ +List(1, 2, 3) map (_ + 10) + +// Combinadores + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) + +// A função filter recebe um predicado (uma função do tipo A -> Boolean) e seleciona +// todos os elementos que satisfazem o predicado. +List(1, 2, 3) filter (_ > 2) // List(3) +case class Person(name: String, age: Int) +List( + Person(name = "Dom", age = 23), + Person(name = "Bob", age = 30) +).filter(_.age > 25) // List(Person("Bob", 30)) + +// Scala tem o método foreach definido em algumas collections em específico, o qual +// recebe um tipo e retorna Unit (um método void) +val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + +/* NB Ests não são laços for. A semântica dos laços for é 'repetir' enquanto um + for-comprehension define um relacionamento entre dois conjuntos de dados */ + + +///////////////////////////////////////////////// +// 8. Implicits +///////////////////////////////////////////////// + +/* ALERTA ALERTA: + Implicits são um conjunto de recursos poderosos de Scala e consequentemente é + fácil abusar deles. Iniciantes em Scala deveriam resistir a tentação de usá-los + até que eles entendam não apenas como eles funcionam mas também as melhores práticas + deles. Incluimos uma sessão neste tutorial sobre isso porque implicits são tão + corriqueiros em bibliotecas do Scala que é impossível fazer qualqeuer coisa expressiva + sem utilizar uma biblioteca que usa implicits. Isto é para você entender e trabalhar + com implicits. Não declare seus próprios implicits por conta própria. +*/ + +// qualquer valor (val, function, objects, etc) pode ser declarado para ser implícito +// usando a, você adivinhou, palavra chave "implicit". Usaremos a classe Dog definida +// na sessão 5 para os próximos exemplos. +implicit val myImplicitInt = 100 +implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed) + +// A palavra chave implicit não muda o comportamento do valor por si só, então +// os valores acima podem ser usados como de costume. +myImplicitInt + 2 // => 102 +myImplicitFunction("Pitbull").breed // => "Golden Pitbull" + +A diferença é que agora esses valores são elegíveis para serem usados quando outra +// parte do código "precisa" de um valor implícito. Uma situação é uma função +// com argumentos implícitos: +def sendGreetings(toWhom: String)(implicit howMany: Int) = + s"Hello $toWhom, $howMany blessings to you and yours!" + +// Se fornecermos um valor para "howMany" a função se comporta como sempre +sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" + +// Mas se omitirmos o parâmetro implícito um valor implícito de mesmo tipo é usado, +// neste caso, "myImplicitInt": +sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" + +// Parâmetros implícitos de funções nos permitem simular type classes em outras +//linguagens funcionais. As linhas abaixo são a mesma coisa: +// def foo[T](implicit c: C[T]) = ... +// def foo[T : C] = ... + +// Outro caso no qual o compilador procura por um implicit é quando você tem obj.method(...) +// mas "obj" não possui "method" como um método. Neste caso, se houver uma conversão +// de implicit do tipo A => B, onde A é o tipo do "obj" e B tem um método chamado +// "method", a conversão é aplicada. Então, tendo myImplicitFunction acima em escopo, podemos dizer: +"Retriever".breed // => "Golden Retriever" +"Sheperd".bark // => "Woof, woof!" + +// Aqui, a String é convertida para Dog usando nossa função acima, então o método +// apropriado é chamado. Isso é um recurso extremamente poderoso, mas de novo, não +// é para ser usado de maneira leviana. Na verdade, quando você define a função +// implícita, o seu compilador deve exibir um aviso de que você não deveria fazer isso, +// a menos que você realmente saiba o que você está fazendo. + +///////////////////////////////////////////////// +// 9. Misc +///////////////////////////////////////////////// + +// Importando coisas +import scala.collection.immutable.List + +// Importando todos os sub pacotes +import scala.collection.immutable._ + +// Importando várias classes em um único comando +import scala.collection.immutable.{List, Map} + +// Renomeando um import usando '=>' +import scala.collection.immutable.{List => ImmutableList} + +// Importa todas as classes, com exceção de algumas. O import abaixo importa todas as classes excluindo Map e Set: +import scala.collection.immutable.{Map => _, Set => _, _} + +// Classes Java também podem ser importadas. A syntaxe de Scala pode ser usada: +import java.swing.{JFrame, JWindow} + +// O ponto de entrada do seu programa é definido em um arquivo Scala usando um object com um único método main: +object Application { + def main(args: Array[String]): Unit = { + // o código fica aqui + } +} + +// Arquivos podem ter múltiplas classes e objects. Compile com scalac + +// Entrada e saída + +// Para ler um arquivo linha a linha +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// Para escrever um arquivo use o PrintWriter do Javaval writer = new PrintWriter("myfile.txt") +writer.write("Writing line for line" + util.Properties.lineSeparator) +writer.write("Another line here" + util.Properties.lineSeparator) +writer.close() + +## Recursos adicionais + +* [Scala for the impatient](http://horstmann.com/scala/) +* [Twitter Scala school](http://twitter.github.io/scala_school/) +* [Documentação de Scala](http://docs.scala-lang.org/) +* [Tente Scala no seu navegador](http://scalatutorials.com/tour/) +* Junte [Scala user group](https://groups.google.com/forum/#!forum/scala-user) +``` diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown new file mode 100644 index 00000000..2fb2953b --- /dev/null +++ b/pt-br/self-pt.html.markdown @@ -0,0 +1,165 @@ +--- +language: self +contributors: + - ["Russell Allen", "http://github.com/russellallen"] +translators: + - ["Ricardo de Almeida Gonzaga", "http://github.com/ricardotk"] +lang: pt-br +filename: learnself-br.self +--- + +Self é um protótipo rápido baseado em linguagem orientada a objeto a qual roda em sua própria JIT vm. A maior parte do desenvolvimento é feito através de interações com objetos ativos, através de um ambiente visual de desenvolvimento chamado *morphic* com navegador e depurador integrados. + +Tudo em Self é um objeto. Toda computação é feita através do envio de mensagens para objetos. Objetos em Self podem ser compreendidos como conjuntos de slots de chave-valor. + +# Construindo objetos + +O analisador interno de Self pode construir objetos, incluindo objetos método. + +``` +"Isto é um comentario" + +"A string:" +'Isto é uma string com caracteres \'escapados\'.\n' + +"Um inteiro de 30 bits" +23 + +"Um float de 30 bits" +3.2 + +"-20" +-14r16 + +"Um objeto o qual entende apenas uma menssagem, 'x' que retorna 20" +(| + x = 20. +|) + +"Um objeto o qual tambem entende 'x', que atribui o slot x" +(| + x <- 20. +|) + +"Um objeto o qual entende o método 'doubleX' que +dobra o valor de x e então retorna o objeto" +(| + x <- 20. + doubleX = (x: x * 2. self) +|) + +"Um objeto o qual entende todas as mensagens +que 'traits point' entende". O analisador +procura 'traits point' enviando as mensagens +'traits' e 'point' para um objeto conhecido +chamado de 'lobby'. Ele procura pelo objeto +'true' também enviando a mensagem 'true' +para o 'lobby'."" +(| parent* = traits point. + x = 7. + y <- 5. + isNice = true. +|) +``` + +# Enviando mensagens para objetos + +Mensagens podem ser unárias, binárias ou palavras-chave. Precedência é nesta ordem. Diferentemente de Smalltalk, a precedência de mensagens binárias precisam ser especificadas, e todas as palavras-chave após a primeira devem começar com letra maiúscula. Mensagens são separadas de seu destinatário através de espaço em branco. + +``` +"mensagem unária, envia 'printLine' para o objeto '23' +o qual escreve a string '23' para stdout e retorna o objeto recebido (ie 23)" +23 printLine + +"envia a mensagem '+' com '7' para '23', em seguida a mensagem '*' com '8' para o resultado" +(23 + 7) * 8 + +"envia 'power:' para '2' com '8' retorna 256" +2 power: 8 + +"envia 'keyOf:IfAbsent:' para 'hello' com argumentos 'e' e '-1'. +Retorna 1, o índice de 'e' em 'hello'." +'hello' keyOf: 'e' IfAbsent: -1 +``` + +# Blocos + +Self define controle de fluxo assim como Smalltalk e Ruby por meio de blocos. Blocos são computações atrasadas da forma: + +``` +[|:x. localVar| x doSomething with: localVar] +``` + +Exemplos do uso de um bloco: + +``` +"retorna 'HELLO'" +'hello' copyMutable mapBy: [|:c| c capitalize] + +"retorna 'Nah'" +'hello' size > 5 ifTrue: ['Yay'] False: ['Nah'] + +"retorna 'HaLLO'" +'hello' copyMutable mapBy: [|:c| + c = 'e' ifTrue: [c capitalize] + False: ['a']] +``` + +Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente. + +``` +"retorna An 'E'! How icky!" +'hello' copyMutable mapBy: [|:c. tmp <- ''| + tmp: c capitalize. + tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!']. + c capitalize + ] +``` + +Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos: +``` +"retorna 0" +[|x| + x: 15. + "Repetidamente envia 'value' para o primeiro bloco enquanto o resultado do + envio de 'value' para o segundo bloco é o objeto 'true'" + [x > 0] whileTrue: [x: x - 1]. + x +] value +``` + +# Métodos + +Métodos são como blocos, porém eles não estão dentro de um contexto, ao invés disto são armazenados como valores de slots. Diferentemente de Smalltalk, métodos por padrão retornam o seu valor final e não 'self'. + +``` +"Aqui está um objeto com um slot atribuível 'x' e um método 'reduceXTo: y'. +Enviar a mensagem 'reduceXTo: 10' para este objeto colocará +o objeto '10' no slot 'x' e retornará o objeto original" +(| + x <- 50. + reduceXTo: y = ( + [x > y] whileTrue: [x: x - 1]. + self) +|) +. +``` + +# Protótipos + +Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo. + +``` +| d | +d: dictionary copy. +d at: 'hello' Put: 23 + 8. +d at: 'goodbye' Put: 'No!. +"Imprime No!" +( d at: 'goodbye' IfAbsent: 'Yes! ) printLine. +"Imprime 31" +( d at: 'hello' IfAbsent: -1 ) printLine. +``` + +# Informações adicionais + +O [Manual do Self](http://handbook.selflanguage.org) tem muito mais informações, e nada melhor do que por a mão na massa com Self através de sua [homepage](http://www.selflanguage.org). 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 a29490b0..bf410352 100644 --- a/pt-br/swift-pt.html.markdown +++ b/pt-br/swift-pt.html.markdown @@ -1,22 +1,23 @@ --- language: swift +filename: learnswift-pt.swift contributors: - - ["Grant Timmerman", "http://github.com/grant"], + - ["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 +Swift é uma linguagem de programação para desenvolvimento de aplicações no iOS e OS X criada pela Apple. Criada para coexistir com Objective-C e para ser mais resiliente a código com erros, Swift foi apresentada em 2014 na Apple's developer conference WWDC. Foi construída com o compilador LLVM já incluído no Xcode 6 beta. O livro oficial [Swift Programming Language] (https://itunes.apple.com/us/book/swift-programming-language/id881256329) da Apple já está disponível via IBooks (apenas em inglês). -Confira também o tutorial completo de Swift da Apple [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html), também disponível apenas em inglês. +Confira também o tutorial completo de Swift da Apple [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), também disponível apenas em inglês. ```swift // importa um módulo @@ -59,9 +60,9 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolação de strings println("Build value: \(buildValue)") // Build value: 7 /* - Optionals fazem parte da linguagem e permitem que você armazene um + Optionals fazem parte da linguagem e permitem que você armazene um valor `Some` (algo) ou `None` (nada). - + Como Swift requer que todas as propriedades tenham valores, até mesmo nil deve ser explicitamente armazenado como um valor Optional. @@ -76,7 +77,7 @@ if someOptionalString != nil { if someOptionalString!.hasPrefix("opt") { println("has the prefix") } - + let empty = someOptionalString?.isEmpty } someOptionalString = nil @@ -221,7 +222,7 @@ println("Gas price: \(price)") // Número variável de argumentos func setup(numbers: Int...) { - // its an array + // é um array let number = numbers[0] let argCount = numbers.count } @@ -289,7 +290,7 @@ print(numbers) // [3, 6, 18] // Estruturas e classes tem funcionalidades muito similares struct NamesTable { let names: [String] - + // Custom subscript subscript(index: Int) -> String { return names[index] @@ -319,7 +320,7 @@ public class Shape { internal class Rect: Shape { var sideLength: Int = 1 - + // Getter e setter personalizado private var perimeter: Int { get { @@ -330,13 +331,13 @@ internal class Rect: Shape { sideLength = newValue / 4 } } - + // Carregue uma propriedade sob demanda (lazy) // subShape permanece nil (não inicializado) até seu getter ser chamado lazy var subShape = Rect(sideLength: 4) - + // Se você não precisa de um getter e setter personalizado, - // mas ainda quer roda código antes e depois de configurar + // mas ainda quer roda código antes e depois de configurar // uma propriedade, você pode usar `willSet` e `didSet` var identifier: String = "defaultID" { // o argumento `willSet` será o nome da variável para o novo valor @@ -344,25 +345,25 @@ internal class Rect: Shape { print(someIdentifier) } } - + init(sideLength: Int) { self.sideLength = sideLength // sempre chame super.init por último quand inicializar propriedades personalizadas (custom) super.init() } - + func shrink() { if sideLength > 0 { - --sideLength + sideLength -= 1 } } - + override func getArea() -> Int { return sideLength * sideLength } } -// Uma classe básica `Square` que estende `Rect` +// Uma classe básica `Square` que estende `Rect` class Square: Rect { convenience init() { self.init(sideLength: 5) @@ -388,13 +389,13 @@ if mySquare === mySquare { // Podem conter métodos do mesmo jeito que classes. enum Suit { - case Spades, Hearts, Diamonds, Clubs + case spades, hearts, diamonds, clubs func getIcon() -> String { switch self { - case .Spades: return "♤" - case .Hearts: return "♡" - case .Diamonds: return "♢" - case .Clubs: return "♧" + case .spades: return "♤" + case .hearts: return "♡" + case .diamonds: return "♢" + case .clubs: return "♧" } } } @@ -420,10 +421,10 @@ protocol ShapeGenerator { class MyShape: Rect { var delegate: TransformShape? - + func grow() { sideLength += 2 - + if let allow = self.delegate?.canReshape?() { // test for delegate then for method // testa por delegação e então por método @@ -439,7 +440,7 @@ class MyShape: Rect { // `extension`s: Adicionam uma funcionalidade extra para um tipo já existente. -// Square agora "segue" o protocolo `Printable` +// Square agora "segue" o protocolo `Printable` extension Square: Printable { var description: String { return "Area: \(self.getArea()) - ID: \(self.identifier)" @@ -453,7 +454,7 @@ extension Int { var customProperty: String { return "This is \(self)" } - + func multiplyBy(num: Int) -> Int { return num * self } diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown new file mode 100644 index 00000000..ce3be407 --- /dev/null +++ b/pt-br/tmux-pt.html.markdown @@ -0,0 +1,244 @@ +--- +category: tool +tool: tmux +contributors: + - ["mdln", "https://github.com/mdln"] +translators: + - ["Luis Custodio", "http://luiscustodio.com"] +lang: pt-br +filename: LearnTmux-pt.txt +--- + +O [tmux](http://tmux.sourceforge.net) é um multiplexador de terminal, +ele permite criar vários terminais e gerenciar tudo na mesma interface. +tmux pode também rodar em background e depois ser recuperado(exibido) novamente. + +``` + + tmux [command] # Roda um [comando] + # 'tmux' sem comandos irá criar uma nova seção + + new # Cria uma nova seção + -s "Nome" # Cria uma nova seção com nome "Nome" + -n "Janela" # Cria uma janela com o nome "Janela" + -c "/dir" # Inícia em uma pasta específica + + attach # Acopla a última seção disponível + -t "#" # Acopla a seção com nome "#" + -d # Separa (Desacopla) a seção de outras instâncias. + + ls # Lista todas as seções + -a # Lista todas as seções abertas + + lsw # Lista as janelas + -a # Lista todas as janelas + -s # Lista todas janleas em uma seção + + lsp # Lista os painéis + -a # Lista todos os painéis + -s # Lista todos os painéis em uma seção + -t "#" # Lista os painéis chamados "#" + + kill-window # Encerrar a janela atual + -t "#" # Encerrar a janela chamada "#" + -a # Encerrar todas as janelas + -a -t "#" # Encerrar todas as janelas exceto a "#" + + kill-session # Encerrar seção atual + -t "#" # Encerrar seção com nome "#" + -a # Encerrar todas as seções + -a -t "#" # Encerrar todas as seções exceto a "#" + +``` + +### Teclas de atalhos (comandos) + +As seções tmux acopladas são controladas através de teclas de atalho. (prefix key) + +``` +---------------------------------------------------------------------- + (C-b) = Ctrl + b # Abre a opção de receber comandos(atalhos). + + (M-1) = Meta + 1 -or- Alt + 1 +---------------------------------------------------------------------- + + ? # Lista todos os comandos. + : # Acessa o prompt command do tmux + r # Força a reinicialização do cliente acoplado. + c # Cria uma nova janela. + + ! # Retira o painel atual da janela. + % # Divide o painel atual em dois. Esquerda e direita. + " # Divide o painel atual em dois. Para cima e para baixo. + + n # Muda para a próxima janela. + p # Muda para a janela anterior. + { # Troca o painel atual pelo anterior. + } # Troca o painel corrent pelo posterior. + + s # Seleciona uma nova seção para o cliente acoplado iterativamente. + w # Seleciona a janela atual iterativamente. + 0 to 9 # Seleciona a janela de 0 à 9. + + d # Separa o cliente atual. + D # Seleciona um cliente a ser separado. + + & # Encerra a janela atual. + x # Encerra o painel atual. + + Up, Down # Move para o painel acima, abaixo, a esquerda ou a direita. + Left, Right + + M-1 to M-5 # Organiza os paines: + # 1) Horizontalmente de maneira igual + # 2) Verticalmente de maineira igual. + # 3) Principal horizontalmente + # 4) Principal verticamente. + # 5) Mosaico + + C-Up, C-Down # Altera o tamanho do painel atual em uma célula. + C-Left, C-Right + + M-Up, M-Down # Altera o tamanho do painel atual em cinco células. + M-Left, M-Right + +``` + + +### Configurando ~/.tmux.conf + +Existe um arquivo chamado tmux.conf, ele pode ser usado para definir opções no + momento de inicialização, da mesma maneira que .vimrc, init.el, .bash_profile são usados. + + +``` +# Exemplo tmux.conf +# 2015.12 + + +### General +########################################################################### + +# Limite da história de comandos +set -g history-limit 2048 + +# Indíce de inicialização +set -g base-index 1 + +# Mouse +set-option -g -q mouse on + +# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa +unbind r +bind r source-file ~/.tmux.conf + + +### Keybinds / Comandos +########################################################################### + +# Desvincular C-b como prefixo padrão. +unbind C-b + +# Define um novo prefixo padrão. +set-option -g prefix ` + +# Voltar janela anterior quando comando for usado duas vezes. +bind C-a last-window +bind ` last-window + +# Fazer com que F11 e F12 alterem o comportamento de C-a e ` +bind F11 set-option -g prefix C-a +bind F12 set-option -g prefix ` + +# Preferencia de comandos +setw -g mode-keys vi +set-option -g status-keys vi + +# Alternar enter painéis com teclas de orientaçao do vim +bind h select-pane -L +bind j select-pane -D +bind k select-pane -U +bind l select-pane -R + +# Iterar entre as Janelas +bind e previous-window +bind f next-window +bind E swap-window -t -1 +bind F swap-window -t +1 + +# Dividir painéis +bind = split-window -h +bind - split-window -v +unbind '"' +unbind % + +# Habilitar a sub-seção a enviar comandos. +bind a send-prefix + + +### Theme // Estilo +########################################################################### + +# Paleta de cores para a barra de status +set-option -g status-justify left +set-option -g status-bg black +set-option -g status-fg white +set-option -g status-left-length 40 +set-option -g status-right-length 80 + +# Paleta de cores para bordas do painel +set-option -g pane-active-border-fg green +set-option -g pane-active-border-bg black +set-option -g pane-border-fg white +set-option -g pane-border-bg black + +# Palta de cores para mensagem +set-option -g message-fg black +set-option -g message-bg green + +# Paleta de cores para janela de status +setw -g window-status-bg black +setw -g window-status-current-fg green +setw -g window-status-bell-attr default +setw -g window-status-bell-fg red +setw -g window-status-activity-attr default +setw -g window-status-activity-fg yellow + + +### UI +########################################################################### + +# Notificações +setw -g monitor-activity on +set -g visual-activity on +set-option -g bell-action any +set-option -g visual-bell off + +# Definir automaticamente o título de janelas +set-option -g set-titles on +set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not) + +# Ajustes na barra de status +set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]" + +# Mostrar indicativos de performance na barra de status +# Requires https://github.com/thewtex/tmux-mem-cpu-load/ +set -g status-interval 4 +set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]" + +``` + + +### Referências + +[Tmux | Início](http://tmux.sourceforge.net) + +[Manual Tmux (em inglês)](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux) + +[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux) + +[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux) + +[Mostrar CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux) + +Possui uma sugestão? Uma correção, talvez? Abra um issue no Repositório GitHub, ou então faça um pull request. diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown new file mode 100644 index 00000000..f072b257 --- /dev/null +++ b/pt-br/typescript-pt.html.markdown @@ -0,0 +1,179 @@ +--- +language: TypeScript +filename: learntypescript-pt.ts +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +translators: + - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"] +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. + +Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown). + +Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida. + +```js +// Existem 3 tipos básicos no TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// Quando é impossível saber, há o "Qualquer" tipo +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // Ok, definitivamente um boolean + +// Para coleções, não são matrizes e matrizes genéricas digitado +var list: number[] = [1, 2, 3]; +// Como alternativa, usando o tipo de matriz genérica +var list: Array<number> = [1, 2, 3]; + +// Para enumerações: +enum Color {Red, Green, Blue}; +var c: Color = Color.Green; + +// Por último, "vazio" é utilizado no caso especial de uma função que não retorna nada +function bigHorribleAlert(): void { + alert("I'm a little annoying box!"); +} + +// Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e +// Tipo de uso inferência + +// A seguir são equivalentes, a mesma assinatura será inferido pelo +// Compilador, e mesmo JavaScript será emitido +var f1 = function(i: number): number { return i * i; } +// Tipo de retorno inferida +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Tipo de retorno inferida +var f4 = (i: number) => { return i * i; } +// Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário +var f5 = (i: number) => i * i; + +// Interfaces são estruturais, qualquer coisa que tenha as propriedades é compatível com +// A interface +interface Person { + name: string; + // Propriedades opcionais, marcado com um "?" + age?: number; + // E de funções curso + move(): void; +} + +// Objeto que implementa a "Pessoa" Interface +// Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades +var p: Person = { name: "Bobby", move: () => {} }; +// Os objetos que têm a propriedade opcional: +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// Não é uma pessoa porque a idade não é um número +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Interfaces também pode descrever um tipo de função +interface SearchFunc { + (source: string, subString: string): boolean; +} +// Somente tipos dos parâmetros são importantes, os nomes não são importantes. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Classes - membros são públicos por padrão +class Point { + // Propriedades + x: number; + + // Construtor - the public/private keywords in this context will generate + // o código clichê para a propriedade e a inicialização no + // construtor. + // Neste exemplo, "y" será definida como "X" é, mas com menos código + // Os valores padrão também são suportados. + + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Funções + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Membros Estáticos + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); //y será 0 + +// Herança +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + super(x, y); // Chamada explícita para o construtor da super classe é obrigatória + } + + // Sobrescrever + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Módulos, "." pode ser utilizado como separador de sub módulos +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Alias no local para fazer referência a um módulo +import G = Geometry; + +var s2 = new G.Square(10); + +// Genericos +// Classes +class Tuple<T1, T2> { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair<T> { + item1: T; + item2: T; +} + +// e funções +var pairToTuple = function<T>(p: Pair<T>) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Incluindo referências a um arquivo de definição: +/// <reference path="jquery.d.ts" /> + +``` + +## Leitura adicional + * [TypeScript site oficial](http://www.typescriptlang.org/) + * [TypeScript especificações de idioma (pdf)](http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Apresentando texto datilografado no Canal 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Código fonte no GitHub](https://github.com/Microsoft/TypeScript) + * [Definitivamente datilografado - repositório de definições de tipo](http://definitelytyped.org/) diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown new file mode 100644 index 00000000..51eddb48 --- /dev/null +++ b/pt-br/vim-pt.html.markdown @@ -0,0 +1,239 @@ +--- +category: tool +tool: vim +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["David Lima", "https://github.com/davelima"] +lang: pt-br +filename: LearnVim-pt.txt +--- + + +[Vim](http://www.vim.org) +(Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um +editor de texto projetado para ter velocidade e produtividade, e está presente +na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado +para agilizar a navegação para pontos específicos no arquivo, além de edição rápida. + +## Navegação do Vim: o básico + +``` + vim <nome-do-arquivo> # Abre <nome-do-arquivo> no vim + :q # Fecha o vim + :w # Salva o arquivo atual + :wq # Salva o arquivo e fecha o vim + :q! # Fecha o vim e descarta as alterações no arquivo + # ! *força* :q a executar, fechando o vim sem salvar antes + :x # Salvar o arquivo e fechao vim (atalho para :wq) + + u # Desfazer + CTRL+R # Refazer + + h # Move o cursor para a esquerda + j # Move o cursor para baixo + k # Move o cursor para cima + l # Move o cursor para a direita + + # Movendo o cursor dentro da linha + + 0 # Move para o início da linha + $ # Move para o final da linha + ^ # Move para o primeiro caractere da linha (ignora caracteres em branco) + + # Pesquisa no texto + + /palavra # Destaca todas as ocorrências de 'palavra' após o cursor + ?palavra # Destaca todas as ocorrências de 'palavra' antes do cursor + n # Move o cursor para a próxima ocorrência após a pesquisa + N # Move o cursor para a ocorrência anterior após a pesquisa + + :%s/foo/bar/g # Substitui 'foo' por 'bar' no arquivo inteiro + :s/foo/bar/g # Substitui 'foo' por 'bar' na linha atual + + # Pulando para caracteres específicos + + f<caracter> # Posiciona o cursor no próximo <caracter> + t<character> # Posiciona o cursor antes do próximo <caracter> + + # Por exemplo, + f< # Posiciona o cursor no < + t< # Posiciona o cursor logo antes do < + + # Movendo por palavras + + w # Move o cursor uma palavra a diante + b # Move o cursor uma palavra atrás + e # Move o cursor ao fim da palavra atual + + # Outros caracteres para mover o cursor no arquivo + + gg # Move para o topo do arquivo + G # Move para o final do arquivo + :NUM # Move para a linha NUM (NUM é qualquer número) + H # Move para o topo da tela visível + M # Move para o meio da tela visível + L # Move para o final da tela visível +``` + +## Modos: + +O Vim é baseado no conceito de **modos**. + +Modo Comando - usado para navegar e escrever comandos - o Vim já inicia nesse modo +Modo Inserção - usado para fazer alterações no arquivo +Modo Visual - usado para destacar textos e executar comandos neles +Modo Ex - usado para ir a linha com ':' no final da tela para executar comandos + +``` + i # Coloca o Vim no Modo Inserção, logo antes do cursor + a # Coloca o Vim no Modo Inserção, logo após o cursor + v # Coloca o Vim no Modo Visual + : # Coloca o Vim no Modo Ex + <esc> # Sai de qualquer modo que você estiver, e coloca o Vim no Modo Comando + + # Copiando e colando texto + + y # Coloca a seleção atual na área de transferência + yy # Coloca a linha atual na área de transferência + d # Deleta a seleção tual + dd # Deleta a linha atual + p # Cola o texto copiado após a posição do cursor + P # Cola o texto copiado antes da posição do cursor + x # Deleta o caractere que está na posição do cursor +``` + +## A 'Gramática' do Vim + +Podemos pensar no Vim como uma série de comendos +em um formato 'Verbo-Modificador-Nome', onde: + +Verbo - sua ação +Modificador - como você executará sua ação +Nome - o objeto onde você vai executar sua acão + +Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes': + +``` + # 'Verbos' + + d # Apagar (Delete) + c # Alterar (Change) + y # Copiar (Yank) + v # Seleção Visual + + # 'Modificadores' + + i # Dentro (Inside) + a # Em torno de (Around) + NUM # Número (NUM qualquer número) + f # Pesquisa algo e posiciona o cursor acima do resultado + t # Pesquisa algo e posiciona o cursor logo antes do resultado + / # Encontra algo a frente do cursor + ? # Encontra algo antes do cursor + + # 'Nomes' + + w # Palavra (word) + s # Sentência + p # Parágrafo + b # Bloco + + # Exemplos de comandos + + d2w # Apaga 2 palavras + cis # Altera dentro de uma sentência + yip # Coloca o parágrafo atual da área de transferência) + ct< # Altera para '<' + # Altera todo o texto a partir da posição do cursor até o próximo '<' + d$ # Apaga tudo da posição do cursor até o final da linha +``` + +## Alguns atalhos e dicas + + <!--TODO: Adicionar mais!--> +``` + > # Adiciona um bloco de indentação + < # Remove um bloco de indentação + :earlier 15m # Reverte o documento para como ele estava há 15 minutos atrás + :later 15m # Reverte o comando acima + ddp # Troca linhas consecutivas de posição, dd e depois p + . # Repete a última ação +``` + +## Macros + +Macros, basicamente, são ações graváveis. +Quando você começa a gravar uma macro, ele salva **toda** ação e comando +que você usar, até que você pare de gravar. Ao executar uma macro, ele aplica +exatamente a mesma sequencia de ações e comandos na seleção atual. + +``` + qa # Inicia a gravação de uma macro chamado 'a' + q # Para a gravação + @a # Executa a macro +``` + +### Configurando o ~/.vimrc + +O arquivo .vimrc pode ser usado para configurar o Vim no seu início. + +Exemplo de arquivo ~/.vimrc + +``` +" Exemplo de ~/.vimrc +" 2015.10 + +" Obrigatório para rodar apenas no Vim (Vi Improved) +set nocompatible + +" Determina o tipo de arquivo pelo nome para habilitar indentação automática, etc +filetype indent plugin on + +" Habilita sintaxe colorida +syntax on + +" Ativa um 'auto-completar' melhor para a linha de comando +set wildmenu + +" Faz as buscas não diferenciarem maiúsculas-minúsculas (case insensitive) +" Exceto quando você usar letras maiúsculas +set ignorecase +set smartcase + +" Quando criar uma nova linha e a indentação por tipo de arquivo estiver +" desabilitada, mantem a mesma indentação da linha atual +set autoindent + +" Mostra o número das linhas à esquerda +set number + +" Opções de indentação, aqui você pode mudar como preferir + +" Número de espaços visíveis por TAB +set tabstop=4 + +" Número de espaços por TAB ao editar um arquivo +set softtabstop=4 + +" Número de espaços usados nas funções de indentação (>> e <<) +set shiftwidth=4 + +" Converte TABs em espaços +set expandtab + +" Habilita indentação/alinhamento inteligente +set smarttab +``` + +### Referências + +[Vim | Home](http://www.vim.org/index.php) (EN) + +`$ vimtutor pt` + +[Vim: um tutorial/cartilha](https://danielmiessler.com/study/vim/) (EN) + +[O que são as partes sombrias do Vim que sua mãe nunca te explicou? (tópico no Stack Overflow)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) (EN) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) (EN) diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown index 76cca567..b94ab609 100644 --- a/pt-br/visualbasic-pt.html.markdown +++ b/pt-br/visualbasic-pt.html.markdown @@ -15,9 +15,9 @@ module Module1 Sub Main () ' Uma visão geral de console de aplicativos do Visual Basic antes de - ' mergulharmos mais profundamente na linguagem + ' mergulharmos mais profundamente na linguagem. ' Aspas simples começam comentários. - ' Para Navegar este tutorial dentro do compilador do Visual Basic, + ' Para navegar neste tutorial dentro do compilador do Visual Basic, ' eu criei um sistema de navegação. ' Este sistema de navegação vai ser explicado conforme avançarmos no ' tutorial, e você vai entender o que isso significa. @@ -93,16 +93,16 @@ module Module1 Private Sub HelloWorldInput () Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes" ' Variáveis - 'Os dados inseridos por um usuário precisa ser armazenada . + 'Os dados inseridos por um usuário precisam ser armazenados. ' As variáveis também começar com um Dim e terminar com um Como VariableType . - ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa + ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa ' Responder ao que é dito. Nome de usuário Dim As String " Nós usamos string como string é uma variável de texto baseado . Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome. - username = Console.ReadLine () ' armazena o nome usuários. - Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome ' + username = Console.ReadLine () ' armazena o nome do usuário. + Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >". Console.ReadLine () ' Outsputs acima. ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta. " Outras variáveis incluem Integer e usamos inteiro para números inteiros. diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown new file mode 100644 index 00000000..989bae05 --- /dev/null +++ b/pt-br/whip-pt.html.markdown @@ -0,0 +1,247 @@ +--- +language: whip +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Saurabh Sandav", "http://github.com/SaurabhSandav"] +author: Tenor Biel +author_url: http://github.com/L8D +translators: + - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"] +lang: pt-br +filename: whip-pt.lisp +--- + +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. + +```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 +nao_é_uma_lista +(uma lista) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 1. Números, texto e operadores + +; Whip tem um tipo numérico (que é um double de 64 bits IEE 754, do JavaScript) +3 ; => 3 +1.5 ; => 1.5 + +; Funções são chamadas se elas são o primeiro elemento em uma lista +(funcao_chamada argumentos) + +; A maioria das operações são feitas com funções +; Todas as funções aritméticas básicas são bem diretas +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 +; até mesmo o módulo +(% 9 4) ; => 1 +; Divisão não inteira ao estilo JavaScript. +(/ 5 2) ; => 2.5 + +; Aninhamento de listas funciona como esperado. +(* 2 (+ 1 3)) ; => 8 + +; Há um tipo boleano. +true +false + +; Textos são criados com ". +"Hello, world" + +; Caracteres são criados com '. +'a' + +; Para negação usa-se a função 'not'. +(not true) ; => false +(not false) ; => true + +; Mas a maioria das funções não-haskell tem atalhos +; o não atalho é um '!'. +(! (! true)) ; => true + +; Igualdade é `equal` ou `=`. +(= 1 1) ; => true +(equal 2 1) ; => false + +; Por exemplo, inigualdade pode ser verificada combinando as funções +;`not` e `equal`. +(! (= 2 1)) ; => true + +; Mais comparações +(< 1 10) ; => true +(> 1 10) ; => false +; e suas contra partes para texto. +(lesser 1 10) ; => true +(greater 1 10) ; => false + +; Texto pode ser concatenado com +. +(+ "Hello " "world!") ; => "Hello world!" + +; Você pode usar as características comparativas do JavaScript. +(< 'a' 'b') ; => true +; ... e coerção de tipos +(= '5' 5) + +; As funções `at` ou `@` acessarão caracteres de um texto, começando em 0. +(at 0 'a') ; => 'a' +(@ 3 "foobar") ; => 'b' + +; Também existem as variáveis `null` e `undefined`. +null ; usada para indicar a ausência de algum valor +undefined ; usada para indicar que um valor não foi informado + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 2. Variáveis, matrizes e dicionários + +; Variáveis são declaradas com as funções `def` ou `let`. +; Variáveis que não tiveram valor atribuído serão `undefined`. +(def some_var 5) +; `def` deixará a variável no contexto global. +; `let` deixará a variável no contexto local, e tem uma sintaxe estranha. +(let ((a_var 5)) (+ a_var 5)) ; => 10 +(+ a_var 5) ; = undefined + 5 => undefined + +; Matrizes são listas de valores de qualquer tipo. +; Elas basicamente são listas sem funções no início +(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 +de pares chave-valor. +{"key1" "value1" "key2" 2 3 3} + +; Chaves podem ser apenas identificadores, números ou texto. +(def my_dict {my_key "my_value" "my other key" 4}) +; Mas em Whip, dicionários são parceados como: valor, espaço, valor; +; com mais espaço entre cada. Então isso significa que +{"key" "value" +"another key" +1234 +} +é avaliado da mesma forma que +{"key" "value" "another key" 1234} + +; Dicionários podem ser acessados usando a função `at` +; (como em texto e listas) +(@ "my other key" my_dict) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 3. Lógica e controle de fluxo + +; A função `if` é muito simples, ainda que muito diferente do que em muitas +linguagens imperativas. +(if true "returned if first arg is true" "returned if first arg is false") +; => "returned if first arg is true" + +; E por conta do legado operador ternário +; `?` é o atalho não utilizado para `if`. +(? false true false) ; => false + +; `both` é uma declaração lógica `and`, e `either` é o `or` lógico. +(both true true) ; => true +(both true false) ; => false +(either true false) ; => true +(either false false) ; => false +; E seus atalhos são +; & => both +; ^ => either +(& true true) ; => true +(^ false true) ; => true + +;;;;;;;;; +; Lambdas + +; Lambdas em Whip são declaradas com as funções `lambda` ou `->`. +; E funções são na verdade lambdas com nomes. +(def my_function (-> (x y) (+ (+ x y) 10))) +; | | | | +; | | | valor retornado (com escopo contento argumentos) +; | | argumentos +; | declaração de funções lambda +; | +; nome do lambda a ser declarado + +(my_function 10 10) ; = (+ (+ 10 10) 10) => 30 + +; Obviamente, todos os lambdas por definição são anônimos e +; tecnicamente sempre usados anonimamente. Redundância. +((lambda (x) x) 10) ; => 10 + +;;;;;;;;;;;;;;;; +; Comprehensions + +; `range` or `..` geram uma lista dos números para +; cada número entre seus dois argumentos. +(range 1 5) ; => (1 2 3 4 5) +(.. 0 2) ; => (0 1 2) + +; `map` aplica seu primeiro argumento (que deve ser um lambda/função) +; a cada item dos argumentos seguintes (que precisa ser uma lista) +(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4) + +; Reduce +(reduce + (.. 1 5)) +; equivalente a +((+ (+ (+ 1 2) 3) 4) 5) + +; Nota: map e reduce não possuem atalhos + +; `slice` ou `\` é similar ao .slice() do JavaScript +; mas veja que ele pega uma lista como primeiro argumento, não o último. +(slice (.. 1 5) 2) ; => (3 4 5) +(\ (.. 0 100) -5) ; => (96 97 98 99 100) + +; `append` ou `<<` são auto explicativos +(append 4 (1 2 3)) ; => (1 2 3 4) +(<< "bar" ("foo")) ; => ("foo" "bar") + +; Length é auto explicativo. +(length (1 2 3)) ; => 3 +(_ "foobar") ; => 6 + +;;;;;;;;;;;;;;; +; Delicadezas Haskell + +; Primeiro item de uma lista +(head (1 2 3)) ; => 1 +; Pega do segundo ao último elemento de uma lista +(tail (1 2 3)) ; => (2 3) +; Último item de uma lista +(last (1 2 3)) ; => 3 +; Contrário de `tail` +(init (1 2 3)) ; => (1 2) +; Pega do primeiro até o elemento especificado da lista +(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 +(min (1 2 3 4)) ; 1 +; Maior valor em uma lista +(max (1 2 3 4)) ; 4 +; Verifica se o valor está em uma lista ou objeto +(elem 1 (1 2 3)) ; true +(elem "foo" {"foo" "bar"}) ; true +(elem "bar" {"foo" "bar"}) ; false +; Inverte a ordem de uma lista +(reverse (1 2 3 4)) ; => (4 3 2 1) +; Verifica se o valor é par ou ímpar +(even 1) ; => false +(odd 1) ; => true +; Separa um texto cortando por espaço em branco +(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese") +; Junta lista de textos +(unwords ("foo" "bar")) ; => "foobar" +; Sucessor e predecessor +(pred 21) ; => 20 +(succ 20) ; => 21 +``` + +Para mais informação, verifique o [repositório](http://github.com/L8D/whip) diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown index 40ddbc3a..f347f8ef 100644 --- a/pt-br/xml-pt.html.markdown +++ b/pt-br/xml-pt.html.markdown @@ -1,8 +1,8 @@ --- language: xml -filename: learnxml.xml +filename: learnxml-pt.xml contributors: - - ["João Farias", "https://github.com/JoaoGFarias"] + - ["João Farias", "https://github.com/JoaoGFarias"] translators: - ["Miguel Araújo", "https://github.com/miguelarauj1o"] lang: pt-br @@ -130,4 +130,4 @@ com a adição de definição DTD.--> <preco>30.00</preco> </livro> </livraria> -```
\ No newline at end of file +``` diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown new file mode 100644 index 00000000..341ae675 --- /dev/null +++ b/pt-br/yaml-pt.html.markdown @@ -0,0 +1,142 @@ +--- +language: yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +translators: + - ["Rodrigo Russo", "https://github.com/rodrigozrusso"] +filename: learnyaml-pt.yaml +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. + +```yaml +# Commentários em YAML são como este. + +################### +# TIPOS ESCALARES # +################### + +# Nosso objeto raiz (que continua por todo o documento) será um mapa, +# o que equivale a um dicionário, hash ou objeto em outras linguagens. +chave: valor +outra_chave: Outro valor vai aqui. +u_valor_numerico: 100 +notacao_cientifica: 1e+12 +boleano: true +valor_nulo: null +chave com espaco: valor +# Observe que strings não precisam de aspas. Porém, elas podem ter. +porem: "Uma string, entre aspas." +"Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave." + +# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |), +# ou em um 'bloco compacto' (utilizando '>'). +bloco_literal: | + Todo esse bloco de texto será o valor da chave 'bloco_literal', + preservando a quebra de com linhas. + + O literal continua até de-dented, e a primeira identação é + removida. + + Quaisquer linhas que são 'mais identadas' mantém o resto de suas identações - + estas linhas serão identadas com 4 espaços. +estilo_compacto: > + Todo esse bloco de texto será o valor de 'estilo_compacto', mas esta + vez, todas as novas linhas serão substituídas com espaço simples. + + Linhas em branco, como acima, são convertidas em um carater de nova linha. + + Linhas 'mais-indentadas' mantém suas novas linhas também - + este texto irá aparecer em duas linhas. + +#################### +# TIPOS DE COLEÇÃO # +#################### + +# Texto aninhado é conseguido através de identação. +um_mapa_aninhado: + chave: valor + outra_chave: Outro valor + outro_mapa_aninhado: + ola: ola + +# Mapas não tem que ter chaves com string. +0.25: uma chave com valor flutuante + +# As chaves podem ser também objetos multi linhas, utilizando ? para indicar o começo de uma chave. +? | + Esta é uma chave + que tem várias linhas +: e este é o seu valor + +# também permite tipos de coleção de chaves, mas muitas linguagens de programação +# vão reclamar. + +# Sequências (equivalente a listas ou arrays) semelhante à isso: +uma_sequencia: + - Item 1 + - Item 2 + - 0.5 # sequencias podem conter tipos diferentes. + - Item 4 + - chave: valor + outra_chave: outro_valor + - + - Esta é uma sequencia + - dentro de outra sequencia + +# Como YAML é um super conjunto de JSON, você também pode escrever mapas JSON de estilo e +# sequencias: +mapa_json: {"chave": "valor"} +json_seq: [3, 2, 1, "decolar"] + +########################## +# RECURSOS EXTRA DO YAML # +########################## + +# YAML também tem um recurso útil chamado "âncoras", que permitem que você facilmente duplique +# conteúdo em seu documento. Ambas estas chaves terão o mesmo valor: +conteudo_ancora: & nome_ancora Essa string irá aparecer como o valor de duas chaves. +outra_ancora: * nome_ancora + +# YAML também tem tags, que você pode usar para declarar explicitamente os tipos. +string_explicita: !! str 0,5 +# Alguns analisadores implementam tags específicas de linguagem, como este para Python de +# Tipo de número complexo. +numero_complexo_em_python: !! python / complex 1 + 2j + +#################### +# YAML TIPOS EXTRA # +#################### + +# Strings e números não são os únicos que escalares YAML pode entender. +# Data e 'data e hora' literais no formato ISO também são analisados. +datetime: 2001-12-15T02: 59: 43.1Z +datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5 +Data: 2002/12/14 + +# A tag !!binary indica que a string é na verdade um base64-encoded (condificado) +# representação de um blob binário. +gif_file: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML também tem um tipo de conjunto, o que se parece com isso: +set: + ? item1 + ? item2 + ? item3 + +# Como Python, são apenas conjuntos de mapas com valors nulos; o acima é equivalente a: +set2: + item1: nulo + item2: nulo + item3: nulo +``` |