diff options
Diffstat (limited to 'pt-br')
39 files changed, 3603 insertions, 597 deletions
diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown index 40c7cd09..886cb253 100644 --- a/pt-br/amd-pt.html.markdown +++ b/pt-br/amd-pt.html.markdown @@ -19,6 +19,7 @@ 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: @@ -122,6 +123,7 @@ define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){ return AlgumaClasse; }); ``` + Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize `requirejs.config(configObj)` em seu `main.js`: @@ -141,6 +143,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo 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 @@ -162,16 +165,19 @@ Muitas pessoas preferem usar AMD para sanar a organização do código durante o `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 */ ({ @@ -188,6 +194,7 @@ Para o nosso exemplo acima a configuração pode ser essa: ``` Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`: + ```html <script src="require.js" data-main="app/main-built"></script> ``` diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown index b12c0693..9fca5af0 100644 --- a/pt-br/asciidoc-pt.html.markdown +++ b/pt-br/asciidoc-pt.html.markdown @@ -5,7 +5,7 @@ contributors: translators: - ["David Lima", "https://github.com/davelima"] lang: pt-br -filename: asciidoc-pt.md +filename: asciidoc-pt.adoc --- AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown index 70d0a01c..02bffc41 100644 --- a/pt-br/awk-pt.html.markdown +++ b/pt-br/awk-pt.html.markdown @@ -202,7 +202,7 @@ function string_functions( localvar, arr) { # 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" + 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 @@ -370,8 +370,10 @@ END { } ``` + 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. +* [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/bc-pt.html.markdown b/pt-br/bc-pt.html.markdown new file mode 100644 index 00000000..2a412806 --- /dev/null +++ b/pt-br/bc-pt.html.markdown @@ -0,0 +1,104 @@ +--- +language: bc +contributors: + - ["Btup"] +translators: + - ["David Lima", "https://github.com/davelima"] +lang: pt-br +filename: learnbc-pt.bc +--- +```c +/*Este é um comentário +multi-linhas*/ +# Este é um comentário de uma única linha! (em bc GNU). + + /*1. Variáveis e estruturas de controle*/ +num = 45 /*Todas as variáveis apenas salvam dados do tipo double, e + você não pode salvar strings diretamente em constantes.*/ +num 45; /*Você pode adicionar ponto-e-vírgula após cada linha. + Isto é opcional*/ +/*Blocos são denotados usando os operadores {} (similar ao C):*/ +while(num < 50) { + num += 1 /*equivalente a num=num+1. + a = a op b é equivalente a a op= b.*/ +} +/*E existem os operadores ++ (incrementar) e -- (decrementar).*/ +/* Existem 3 tipos especiais de variáveis: +scale: define a escala de números double. +ibase: define a base de da entrada. +obase: define a base da saída. +*/ +/*Cláusulas If:*/ +hora = read() /*Lê a entrada de um número*/ + +if(hora < 12) { /*Os operadores são idênticos ao C.*/ + print "Bom dia\n" /*"print" imprime strings ou variáveis + separados por vírgula (,).*/ +} else if(hora == 12) { + print "Olá\n" + /*Para escapar strings, inicie a string com \. + Para deixar o escape de strings mais claros, + aqui está uma lista simplificada das strings escapadas + que funcionarão com bc: + \b: backspace + \c: carriage return (enter) + \n: newline (nova linha) + \t: tab + \\: backslash (barra inertida)*/ +} else { + /*Variáveis são globais por padrão.*/ + istoEGlobal = 5 + /*Para tornar uma variável local, use a palavra-chave "auto" em uma função.*/ +} + +/*Todas as variáveis por padrão tem o valor 0*/ +num = variavelEmBranco /*num é igual a 0.*/ + +/*Assim como no C, "0" é considerado "false"*/ +if(!num) {print "false\n"} + +/*Diferente do C, bc não tem o operador ?:. Por exemplo, +este bloco de código causaria um erro: +a = (num) ? 1 : 0 +Entretanto, você pode simular da seguinte forma: +a = (num) && (1) || (0) /*&& é "E", || é "OU"*/ +*/ + +/*Loops For*/ +num = 0 +for(i = 1; i <= 100; i++) {/*Similar ao loop For do C.*/ + num += i +} + + /*2.Funções e arrays*/ +define fac(n) { /*para definir uma função, use "define".*/ + if(n == 1 || n == 0) { + return 1 /*retorna um valor*/ + } + return n * fac(n - 1) /*recursão é permitido*/ +} + +/*Closures e funções anônimas não são permitidas*/ + +num = fac(4) /*24*/ + +/*Exemplo de variáveis locais:*/ +define x(n) { + auto x + x = 1 + return n + x +} +x(3) /*4*/ +print x /*A variável "x" não será acessível de fora da função*/ +/*Arrays são equivalentes aos arrays em C.*/ +for(i = 0; i <= 3; i++) { + a[i] = 1 +} +/*Para acessar um array, faça assim:*/ +print a[0], " ", a[1], " ", a[2], " ", a[3], "\n" +quit /*Adicione essa linha no final do código +para garantir que o programa encerre. Essa linha é opcional.*/ +``` +Aproveite bem essa simples calculadora! (Ou essa linguagem de programação, para ser exato.) + +Este programa inteiro foi escrito em GNU bc. Para rodá-lo, use ```bc learnbc-pt.bc``` diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 42a29991..ca289001 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-pt.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] @@ -363,7 +363,7 @@ void OwnedDog::print() const { Dog::print(); // Chame a função de impressão na classe Dog base de std::cout << "Dog is owned by " << owner << "\n"; - // Prints "Dog is <name> and weights <weight>" + // Imprime "Dog is <name> and weights <weight>" // "Dog is owned by <owner>" } diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index 4e55f068..22a86376 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -1,6 +1,6 @@ --- -language: c -filename: learnc.c +language: C +filename: learnc-pt.c contributors: - ["Adam Bard", "http://adambard.com/"] - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] @@ -10,7 +10,6 @@ translators: - ["Cássio Böck", "https://github.com/cassiobsilva"] - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"] lang: pt-br -filename: c-pt.el --- Ah, C. Ainda é **a** linguagem de computação de alta performance. @@ -385,7 +384,6 @@ int main() { // 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): - // Exceptions: when the array is the argument of the `&` (address-of) operator: int arr[10]; int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`! // É do tipo "ponteiro para array" (de `int`s). diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown index e40b8fe7..15ad930a 100644 --- a/pt-br/clojure-pt.html.markdown +++ b/pt-br/clojure-pt.html.markdown @@ -561,7 +561,7 @@ Caso queira aprender mais: [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core) * 4clojure possui alguns problemas e desafios interessantes para quem quiser treinar clojure ou programação funcional: -[http://www.4clojure.com/](http://www.4clojure.com/) +[https://4clojure.oxal.org/](https://4clojure.oxal.org/) * clojure-doc.org tem um bom número de artigos para iniciantes: [http://clojure-doc.org/](http://clojure-doc.org/) diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 384ca325..87e5b3a4 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C# filename: csharp-pt.cs contributors: - ["Robson Alves", "http://robsonalves.net/"] @@ -153,7 +153,7 @@ on a new line! ""Wow!"", the masses cried"; intArray[1] = 1; // Listas - // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis + // Listas são usadas frequentemente tanto quanto matriz por serem mais flexíveis // O formato de declarar uma lista é o seguinte: // List<tipodado> <var nome> = new List<tipodado>(); List<int> intList = new List<int>(); diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown index e6dea5b8..e4f55276 100644 --- a/pt-br/css-pt.html.markdown +++ b/pt-br/css-pt.html.markdown @@ -290,9 +290,9 @@ A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em t ## Leitura adicional -* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, e o 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 +* [SASS](http://sass-lang.com/) e [Less](http://lesscss.org/) para CSS pré-processamento * [CSS-Tricks](https://css-tricks.com) diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown new file mode 100644 index 00000000..ae4bab22 --- /dev/null +++ b/pt-br/d-pt.html.markdown @@ -0,0 +1,262 @@ +--- +language: D +filename: learnd-pt.d +contributors: + - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"] +translators: + - ["Julio Vanzelli", "https://github.com/JulioVanzelli"] +lang: pt-br +--- + +```d +// Você sabe o que está por vir... +module hello; + +import std.stdio; + +// args é opcional +void main(string[] args) { + writeln("Hello, World!"); +} +``` + +Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido +sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral, +linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até +abstrações expressivas de alto nível. + +D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por +[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e +[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu). +Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos! + +```d +import std.stdio; + +void main() { + + // Condicionais e loops funcionam como esperado. + for(int i = 0; i < 10000; i++) { + writeln(i); + } + + // 'auto' pode ser usado para inferir tipos. + auto n = 1; + + // literais numéricos podem usar '_' como um separador de dígitos para maior clareza. + while(n < 10_000) { + n += n; + } + + do { + n -= (n / 2); + } while(n > 0); + + // Por e enquanto são bons, mas em D-land preferimos loops 'foreach'. + // O '..' cria um intervalo contínuo, incluindo o primeiro valor + // mas excluindo o último. + foreach(n; 1..1_000_000) { + if(n % 2 == 0) + writeln(n); + } + + // Há também 'foreach_reverse' quando você deseja fazer um loop para trás. + foreach_reverse(n; 1..int.max) { + if(n % 2 == 1) { + writeln(n); + } else { + writeln("No!"); + } + } +} +``` + +Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões +são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso, +podemos usar modelos para parametrizar tudo isso em tipos e valores! + +```d +// Aqui, 'T' é um parâmetro de tipo. Pense '<T>' em C++/C#/Java. +struct LinkedList(T) { + T data = null; + + // Usar '!' para instanciar um tipo parametrizado. Mais uma vez, pense '<T>'. + LinkedList!(T)* next; +} + +class BinTree(T) { + T data = null; + + // Se houver apenas um parâmetro de modelo, podemos omitir os parênteses. + BinTree!T left; + BinTree!T right; +} + +enum Day { + Sunday, + Monday, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, +} + +// Use o alias para criar abreviações para tipos. +alias IntList = LinkedList!int; +alias NumTree = BinTree!double; + +// Também podemos criar modelos de funções! +T max(T)(T a, T b) { + if(a < b) + return b; + + return a; +} + +// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' +// e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'. +void swap(T)(ref T a, ref T b) { + auto temp = a; + + a = b; + b = temp; +} + +// Com os modelos, também podemos parametrizar valores, não apenas tipos. +class Matrix(uint m, uint n, T = int) { + T[m] rows; + T[n] columns; +} + +auto mat = new Matrix!(3, 3); // O tipo 'T' foi padronizado como 'int'. + +``` + +Falando em aulas, vamos falar sobre propriedades por um segundo. Uma propriedade +é aproximadamente uma função que pode agir como um valor I, para que possamos +ter a sintaxe das estruturas POD (`structure.x = 7`) com a semântica de +métodos getter e setter (`object.setX (7)`)! + +```d +// Considere uma classe parametrizada nos tipos 'T' e 'U'. +class MyClass(T, U) { + T _data; + U _other; +} + +// E os métodos "getter" e "setter", assim: +class MyClass(T, U) { + T _data; + U _other; + + // Os construtores sempre são chamados de 'this'. + this(T t, U u) { + // This will call the setter methods below. + data = t; + other = u; + } + + // getters + @property T data() { + return _data; + } + + @property U other() { + return _other; + } + + // setters + @property void data(T t) { + _data = t; + } + + @property void other(U u) { + _other = u; + } +} + +// E nós os usamos desta maneira: +void main() { + auto mc = new MyClass!(int, string)(7, "seven"); + + // Importe o módulo 'stdio' da biblioteca padrão para gravar no + // console (as importações podem ser locais para um escopo). + import std.stdio; + + // Ligue para os getters para buscar os valores. + writefln("Earlier: data = %d, str = %s", mc.data, mc.other); + + // Ligue para os setters para atribuir novos valores. + mc.data = 8; + mc.other = "eight"; + + // Ligue para os getters novamente para buscar os novos valores. + writefln("Later: data = %d, str = %s", mc.data, mc.other); +} +``` + +Com propriedades, podemos adicionar qualquer quantidade de lógica para +nossos métodos getter e setter, e mantenha a sintaxe limpa de +acessando membros diretamente! + +Outras guloseimas orientadas a objetos à nossa disposição, +incluem interfaces, classes abstratas, +e métodos de substituição. D faz herança como Java: +Estenda uma classe, implemente quantas interfaces você desejar. + +Vimos as instalações OOP de D, mas vamos mudar de marcha. D oferece +programação funcional com funções de primeira classe, `pura` +funções e dados imutáveis. Além disso, todos os seus favoritos +algoritmos funcionais (mapear, filtrar, reduzir e amigos) podem ser +encontrado no maravilhoso módulo `std.algorithm`! + +```d +import std.algorithm : map, filter, reduce; +import std.range : iota; // cria uma gama exclusiva de final + +void main() { + // Queremos imprimir a soma de uma lista de quadrados de ints pares + // de 1 a 100. Fácil! + + // Basta passar expressões lambda como parâmetros de modelo! + // Você pode passar qualquer função que desejar, mas as lambdas são convenientes aqui. + auto num = iota(1, 101).filter!(x => x % 2 == 0) + .map!(y => y ^^ 2) + .reduce!((a, b) => a + b); + + writeln(num); +} +``` + +Observe como conseguimos construir um bom pipeline haskelliano para calcular num? +Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS). +Com o UFCS, podemos optar por escrever uma chamada de função como método +ou chamada de função grátis! Walter escreveu um bom artigo sobre isso +[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) +Em resumo, você pode chamar funções cujo primeiro parâmetro +é de algum tipo A em qualquer expressão do tipo A como método. + +Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco! + +```d +// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos +// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos +// fazer isso simultaneamente, aproveitando o número de núcleos que temos +// disponível. + +import std.stdio; +import std.parallelism : parallel; +import std.math : sqrt; + +void main() { + // Crie sua grande variedade + auto arr = new double[1_000_000]; + + // Use um índice, acesse todos os elementos da matriz por referência (porque vamos + // mudar cada elemento) e apenas chame paralelo na matriz! + foreach(i, ref elem; parallel(arr)) { + elem = sqrt(i + 1.0); + } +} +``` diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown index e9d72850..6aff1ac3 100644 --- a/pt-br/dart-pt.html.markdown +++ b/pt-br/dart-pt.html.markdown @@ -3,15 +3,16 @@ language: dart filename: learndart-pt.dart contributors: - ["Joao Pedrosa", "https://github.com/jpedrosa/"] + - ["Hélio Oliveira", "https://github.com/insign/"] translators: - ["Junior Damacena", "https://github.com/jdamacena/"] lang: pt-br --- Dart é uma novata no reino das linguagens de programação. -Ela empresta muito de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o Browser. +Ela absorve muitas teorias de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o navegador. -A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos. +As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à função de [detecção automática](https://dart.dev/guides/language/type-system#type-inference). ```dart import "dart:collection"; diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown index 4ba78f52..18441ff7 100644 --- a/pt-br/elixir-pt.html.markdown +++ b/pt-br/elixir-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: elixir +language: Elixir contributors: - ["Joao Marques", "http://github.com/mrshankly"] - ["Dzianis Dashkevich", "https://github.com/dskecse"] @@ -20,7 +20,7 @@ e muitos outros recursos. # 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`. +# 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. @@ -51,7 +51,7 @@ elem({1, 2, 3}, 0) #=> 1 head #=> 1 tail #=> [2,3] -# Em elixir, bem como em Erlang, o sinal `=` denota pattern match, +# 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 @@ -85,7 +85,7 @@ linhas. <<?a, ?b, ?c>> #=> "abc" [?a, ?b, ?c] #=> 'abc' -# `?a` em elixir retorna o valor ASCII para a letra `a` +# `?a` em Elixir retorna o valor ASCII para a letra `a` ?a #=> 97 # Para concatenar listas use `++`, para binários use `<>` @@ -98,7 +98,7 @@ linhas. # 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] +[menor, maior] #=> [1, 10] ## --------------------------- ## -- Operadores @@ -110,7 +110,7 @@ menor..maior = 1..10 # Pattern matching pode ser usada em ranges também 5 * 2 #=> 10 10 / 2 #=> 5.0 -# Em elixir o operador `/` sempre retorna um float. +# Em Elixir o operador `/` sempre retorna um float. # Para divisão de inteiros use `div` div(10, 2) #=> 5 @@ -167,7 +167,7 @@ else "Isso será" end -# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela. +# Lembra do pattern 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 @@ -296,7 +296,7 @@ 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 +# Devido à imutabilidade, recursão é uma grande parte do Elixir defmodule Recursion do def sum_list([head | tail], acc) do sum_list(tail, acc + head) @@ -309,7 +309,7 @@ end Recursion.sum_list([1,2,3], 0) #=> 6 -# Módulos do elixir suportam atributos, hpa atributos embutidos e você +# Módulos do Elixir suportam atributos, hpa atributos embutidos e você # pode também adicionar os seus próprios. defmodule MyMod do @moduledoc """ @@ -361,7 +361,7 @@ end ## --------------------------- # 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, +# 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 diff --git a/pt-br/emacs-pt.html.markdown b/pt-br/emacs-pt.html.markdown new file mode 100644 index 00000000..7a86a119 --- /dev/null +++ b/pt-br/emacs-pt.html.markdown @@ -0,0 +1,60 @@ +--- +category: tool +tool: emacs +filename: emacs.txt +contributors: + - ["Joseph Riad", "https://github.com/Joseph-Riad"] +translators: + - ["André de Santa Gabriel", "https://github.com/andredesanta"] +lang: pt-br +--- + +O Emacs começou sua vida como (https://www.gnu.org/software/emacs/emacs-paper.html) e cresceu +ao longo dos anos em um ecossistema completo. Muitas tarefas, geralmente +relegado a um conjunto diversificado de ferramentas pode ser realizado de dentro +Emacs em uma interface consistente e familiar. Exemplos incluem +gerenciamento de diretório, visualização de documentos PDF, edição de arquivos via SSH, gerenciamento de +repos git. Em suma, o Emacs é seu para fazer +o que você quiser: o espectro de usuários varia daqueles que o usam para +editar arquivos de texto para puristas extremos que o usam para substituir virtualmente seu +sistema operacional. + +O Emacs é extensível através de um dialeto especializado do Lisp conhecido como Emacs +Lisp (Elisp), que possui muitas macros voltadas para a edição de texto e +gerenciamento de buffers de texto. Qualquer tecla (combinação) usada no Emacs está vinculada +para uma função Emacs Lisp e pode ser remapeado para qualquer outra função, +incluindo aqueles que você escreve +você mesmo. + +# Conceitos básicos de Emacs + +Aqui, discuto alguns conceitos e terminologia básicos do Emacs que podem ser +confusos para os recém-chegados (especialmente para as pessoas acostumadas à terminologia do Vim): + + - O texto que o Emacs está editando é conhecido como **buffer** + + - Um buffer não corresponde necessariamente a um arquivo real no disco. Pode ser apenas texto na memória. + + - Quando um buffer corresponde a um arquivo no disco, dizemos que o buffer está **visitando** esse arquivo. + + - O Emacs normalmente possui muitos buffers abertos ao mesmo tempo. + + - A exibição do Emacs pode ser dividida em diferentes **windows**. + + - Uma janela do sistema operacional para o Emacs é chamada de **frame**. Assim, quando o manual do Emacs fala sobre a abertura de um novo frame, esse essencialmente significa abrir uma nova janela do SO contendo uma (outra) instância do Emacs. + + - Os conceitos convencionalmente conhecidos como recortar e colar são referido como **killing** e **yanking**, respectivamente no Emacs. + + - A posição atual do cursor é chamada de **point** no Emacs. Tecnicamente, **point** é definido como a posição imediatamente antes do caractere onde o cursor está atualmente. + + - Finalmente, cada buffer pode ter vários **modes** associados: o **major mode** e possivelmente vários **minor modes**. + + - O **major mode** define o principal comportamento do Emacs no buffer atualmente selecionado. Isso pode ser pensado como o tipo de arquivo. Por exemplo, se você estiver editando um arquivo Python, os principais modes é (por padrão) `python-mode`, que faz com que o Emacs destaque a sintaxe Python e idente automaticamente seus blocos de código conforme exigido sintaticamente pelo seu código Python. + + - **Minor modes** definem mudanças sutis no comportamento e várias alterações menores Os modos podem estar ativos ao mesmo tempo no mesmo buffer. Um exemplo menor modo é o modo flyspell, que destaca automaticamente os erros de ortografia no seu buffer. + +# Recursos adicionais + + - [The GNU Emacs Manual](https://www.gnu.org/software/emacs/manual/emacs.html) + - [Emacs Stack Exchange](https://emacs.stackexchange.com/) + - [Emacs Wiki](https://www.emacswiki.org/emacs/EmacsWiki) diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown index e59ba901..2cc1c337 100644 --- a/pt-br/git-pt.html.markdown +++ b/pt-br/git-pt.html.markdown @@ -11,6 +11,7 @@ contributors: translators: - ["Suzane Sant Ana", "http://github.com/suuuzi"] - ["Bruno Volcov", "http://github.com/volcov"] + - ["Marcel Ribeiro-Dantas", "http://github.com/mribeirodantas"] --- Git é um sistema distribuido de gestão para código fonte e controle de versões. @@ -67,7 +68,8 @@ referências e outros. ### *Working Tree* (componente do repositório) -A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto. +A *Working Tree* é basicamente a listagem dos diretórios e arquivos do +repositório. É chamada também de diretório do projeto. ### *Index* (componente do diretório .git) @@ -77,28 +79,37 @@ maior controle sobre o que é registado no repositório git. ### *Commit* -Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto. -Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações -serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado -para outros repositórios ou não! +Um *commit** de git é um registo de um conjunto de alterações ou manipulações +nos arquivos do projeto. Por exemplo, ao adicionar cinco arquivos e remover +outros 2, estas alterações serão gravadas em um *commit* (ou registro). Este +*commit* pode então ser enviado para outros repositórios, caso você queira. ### *Branch* -Um *branch* é essencialmente uma referência que aponta para o último *commit* +Uma *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) +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 -uma *HEAD* activa. -*head* é uma referência que aponta para qualquer *commit*. Um repositório pode -ter um número indefinido de *heads* +*HEAD* é a referência que aponta para a *branch* em uso. Um repositório só tem +uma *HEAD* activa. *head* é uma referência que aponta para qualquer *commit*. Um +repositório pode ter um número indefinido de *heads*. + +### Estados no Git + +* Modificado (Modified): Ocorreram mudanças em ao menos um arquivo mas essas +mudanças ainda não foram registradas na base de dados do Git +* Preparado (Staged): Marca o arquivo como preparado para ser adicionado ao +próximo commit +* Consolidado (Committed): As mudanças foram registradas na base de dados do +Git ### Recursos conceituais (EN) @@ -109,8 +120,8 @@ ter um número indefinido de *heads* ### *init* -Cria um repositório Git vazio. As definições, informação guardada e outros do -repositório git são guardados em uma pasta chamada ".git". +Cria um repositório Git vazio. As configurações do repositório, e outras +informações são guardadas em uma pasta dentro do repositório com o nome ".git". ```bash $ git init @@ -118,23 +129,24 @@ $ git init ### *config* -Permite configurar as definições, sejam as definições do repositório, sistema -ou configurações globais. +Permite configurar o git, seja com respeito a definições deste repositório, +do sistema ou configurações globais para todos os repositórios. ```bash -# Imprime e define algumas variáveis de configuração básicas (global) -$ git config --global user.email -$ git config --global user.name - +# Define e imprime algumas variáveis de configuração básicas (global) $ git config --global user.email "MyEmail@Zoho.com" $ git config --global user.name "My Name" + +$ git config --global user.email +$ git config --global user.name ``` [Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config) ### help -Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica. +Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da +semântica. ```bash # Ver rapidamente os comandos disponiveis @@ -148,16 +160,32 @@ $ git help -a $ git help add $ git help commit $ git help init +# ou git <comando_aqui> --help +$ git add --help +$ git commit --help +$ git init --help +``` + +### Ignorando arquivos + +É possível intencionalmente ignorar arquivos e pastas. Costuma-se utilizar o +arquivo .gitignore para fazer o git ignorar a existência de arquivos e pastas +geralmente utilizados para arquivos privados ou temporários que, de outro modo, +seriam compartilhados com todos que tem acesso ao repositório. + +```bash +$ echo "temp/" >> .gitignore +$ echo "chave_privada" >> .gitignore ``` ### status -Apresenta as diferenças entre o arquivo *index* (a versão corrente -do repositório) e o *commit* da *HEAD* atual. +Apresenta as diferenças entre o arquivo *index* (a versão corrente do +repositório) e o *commit* da *HEAD* atual. ```bash -# Apresenta o *branch*, arquivos não monitorados, alterações e outras +# Apresenta a *branch*, arquivos não monitorados, alterações e outras # diferenças $ git status @@ -173,35 +201,42 @@ incluidos nos commits! ```bash # adiciona um arquivo no diretório do projeto atual -$ git add HelloWorld.java +$ git add OlaMundo.java -# adiciona um arquivo num sub-diretório -$ git add /path/to/file/HelloWorld.c +# adiciona um arquivo em um sub-diretório +$ git add /caminho/para/arquivo/OlaMundo.java # permite usar expressões regulares! $ git add ./*.java + +# Você também pode adicionar tudo no seu diretório de trabalho como alterações +prontas para o próximo commit. +$ git add -A ``` +Esse comando apenas adiciona os arquivos no estado de preparados para o próximo +commit, mas não realiza o commit de fato. + ### branch -Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este +Gerencia as *branches*. É possível ver, editar, criar e apagar branches com este comando. ```bash # listar *branches* existentes e remotos $ git branch -a -# criar um novo *branch* +# criar uma nova *branch* $ git branch myNewBranch -# apagar um *branch* +# apagar uma *branch* $ git branch -d myBranch -# alterar o nome de um *branch* +# alterar o nome de uma *branch* # git branch -m <oldname> <newname> $ git branch -m myBranchName myNewBranchName -# editar a descrição de um *branch* +# editar a descrição de uma *branch* $ git branch myBranchName --edit-description ``` @@ -212,18 +247,22 @@ 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 ``` @@ -231,14 +270,16 @@ $ git push origin --tags ### checkout Atualiza todos os arquivos no diretório do projeto para que fiquem iguais -à versão do index ou do *branch* especificado. +à versão do index ou da *branch* especificado. ```bash -# Checkout de um repositório - por padrão para o branch master +# Checkout de um repositório - por padrão para a branch master $ git checkout -# Checkout de um branch especifico + +# Checkout de uma branch especifica $ git checkout branchName -# Cria um novo branch e faz checkout para ele. + +# Cria uma nova branch e faz checkout para ela. # Equivalente a: "git branch <name>; git checkout <name>" $ git checkout -b newBranch ``` @@ -246,22 +287,41 @@ $ git checkout -b newBranch ### clone Clona ou copia um repositório existente para um novo diretório. Também -adiciona *branches* de monitoramento remoto para cada *branch* no repositório -clonado o que permite enviar alterações para um *branch* remoto. +adiciona *branches* no repositório clonado para cada *branch* no repositório +remoto o que permite enviar alterações para uma *branch* no repositório remoto. ```bash # Clona learnxinyminutes-docs $ git clone https://github.com/adambard/learnxinyminutes-docs.git + +# Clone superficial - É mais rápido, mas puxa apenas o último commit +$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git + +# Clona apenas uma branch em específica +$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch ``` ### commit -Guarda o conteudo atual do index num novo *commit*. Este *commit* contém +Guarda o conteúdo atual do index em um novo *commit*. Este *commit* contém as alterações feitas e a mensagem criada pelo usuário. ```bash -# commit com uma mensagem -$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +# Realiza um commit com uma mensagem +$ git commit -m "Adicione a função multipliqueNumeros() em OlaMundo.c" + +# Assine um commit com sua chave GPG. Antes disso, você precisa ter +# configurado a opção user.signkey do git com o comando: +# git config --global user.signinkey ID_CHAVE_AQUI +$ git commit -S -m "mensagem do commit aqui" + +# Automaticamente adicione como preparados arquivos modificados ou apagados e +# então realize um commit: +$ git commit -a -m "Modified foo.php and removed bar.php" + +# Altere o último commit (Esse comando cria um novo commit com o conteúdo do +# commit anterior mais suas novas alterações e sobrescreve o último commit) +$ git commit --amend -m "Correct message" ``` ### diff @@ -282,7 +342,7 @@ $ git diff HEAD ### grep -Permite procurar facilmente num repositório +Permite procurar facilmente em um repositório. Configurações opcionais: @@ -313,74 +373,158 @@ Apresenta commits do repositório. # Apresenta todos os commits $ git log -# Apresenta X commits -$ git log -n 10 +# Apresenta apenas mensagem do commit e referência +$ git log --oneline # Apresenta apenas commits de merge $ git log --merges + +# Apresenta todos os commits representados por um gráfico em ASCII +$ git log --graph ``` ### merge -"Merge" junta as alterações de commits externos com o *branch* atual. +"Merge" junta as alterações de commits externos com a *branch* atual. ```bash -# Junta o branch especificado com o atual +# Junta a branch especificada com o atual $ git merge branchName -# Para gerar sempre um commit ao juntar os branches +# Para gerar sempre um commit ao juntar as branches $ git merge --no-ff branchName ``` ### mv -Alterar o nome ou mover um arquivo. +Altera o nome ou move um arquivo. ```bash # Alterar o nome de um arquivo -$ git mv HelloWorld.c HelloNewWorld.c +$ git mv OlaMundo.c OlaNovoMundo.c # Mover um arquivo -$ git mv HelloWorld.c ./new/path/HelloWorld.c +$ git mv OlaMundo.c ./novo/caminho/OlaMundo.c -# Forçar a alteração de nome ou mudança local -# "existingFile" já existe no directório, será sobrescrito. +# Forçar a alteração de nome ou mudança de local +# Se o arquivo já existir no diretório, será sobrescrito. $ git mv -f myFile existingFile ``` ### pull -Puxa alterações de um repositório e as junta com outro branch +Puxa alterações de um repositório e as junta com outra branch ```bash # Atualiza o repositório local, juntando as novas alterações # do repositório remoto 'origin' e branch 'master' # git pull <remote> <branch> -# git pull => aplica a predefinição => git pull origin master $ git pull origin master -# Juntar alterações do branch remote e fazer rebase commits do branch +# Por padrão, o git irá realizar o pull na branch atual fazendo um merge +# com as alterações novas na branch remota +$ git pull + +# Juntar alterações da branch remote e fazer rebase commits da branch # no repositório local, como: "git pull <remote> <branch>, git rebase <branch>" $ git pull origin master --rebase ``` ### push -Enviar e juntar alterações de um branch para o seu branch correspondente -num repositório remoto. +Enviar e juntar alterações de uma branch para a sua branch correspondente +em um repositório remoto. ```bash # Envia e junta as alterações de um repositório local -# para um remoto denominado "origin" no branch "master". +# para um remoto denominado "origin" na branch "master". # git push <remote> <branch> -# git push => aplica a predefinição => git push origin master $ git push origin master + +# Por padrão, o git push irá enviar e realizar merge das mudanças da sua branch +# local com a branch remota +$ git push + +# Para associar a branch local com uma branch específica remota, adicione a +# flag -u +$ git push -u origin master + +# Agora, sempre que você realizar um push daquela branch local, use o atalho: +$ git push ``` +### stash + +O objetivo desse comando do git é pegar o estado "sujo" do seu diretório de +trabalho, que não está pronto (staged), e salvá-lo em um outro lugar para que +você possa trabalhar no seu repositório do zero, mas sem perder as mudanças que +fez. Em qualquer outro momento que você quiser, você pode trazer de volta as +alterações que você tirou dali com o comando stash. + +Digamos que você tem feito algumas alterações no seu repositório, mas agora +você quer realizar um pull do repositório remoto. Como você tem alterações não +commitadas no seu diretório (ele está "sujo"), você não irá conseguir realizar +o `git pull` com sucesso. Mas você pode executar o `git stash` para salvar +essas alterações e conseguir realizar o pull. Depois, você traz de volta. + +```bash +$ git stash +Saved working directory and index state \ + "WIP on master: 049d078 added the index file" + HEAD is now at 049d078 added the index file + (To restore them type "git stash apply") +``` + +Agora você irá conseguir realizar o pull! + +```bash +git pull +``` +`...changes apply...` + +Verifique se está tudo OK com o `git status` + +```bash +$ git status +# On branch master +nothing to commit, working directory clean +``` + +É possível verificar as alterações que você guardou com cada uso do comando +`git stash` com o `git stash list`. Como os usos desse comando são guardados +como em uma pilha, os usos mais recentes estarão no topo. + +```bash +$ git stash list +stash@{0}: WIP on master: 049d078 added the index file +stash@{1}: WIP on master: c264051 Revert "added file_size" +stash@{2}: WIP on master: 21d80a5 added number to log +``` + +Agora vamos trazer o que havíamos salvado com o `git stash` de volta para o +diretório de trabalho. + +```bash +$ git stash pop +# On branch master +# Changes not staged for commit: +# (use "git add <file>..." to update what will be committed) +# +# modified: index.html +# modified: lib/simplegit.rb +# +``` + +`git stash apply` faz a mesma coisa + +Agora podemos voltar a trabalhar no que havíamos deixado de lado! + +[Additional Reading.](http://git-scm.com/book/en/v1/Git-Tools-Stashing) + ### rebase (cautela!) -Pega em todas as alterações que foram registadas num branch e volta a -aplicá-las em outro branch. +Pega em todas as alterações que foram registadas em uma branch e volta a +aplicá-las em outra branch. *Não deve ser feito rebase de commits que foram enviados para um repositório público* @@ -407,31 +551,79 @@ $ git reset # sobrescreve o projeto atual $ git reset --hard -# Move a head do branch atual para o commit especificado, sem alterar o projeto. +# Move a head da branch atual para o commit especificado, sem alterar o projeto. # todas as alterações ainda existem no projeto $ git reset 31f2bb1 -# Inverte a head do branch atual para o commit especificado +# Inverte a head da branch atual para o commit especificado # fazendo com que este esteja em sintonia com o diretório do projeto -# Remove alterações não registadas e todos os commits após o commit especificado +# Remove alterações não registradas e todos os commits após o commit +# especificado $ git reset --hard 31f2bb1 ``` +### reflog (cuidado!) + +O reflog irá listar a maior parte dos comandos que você realizou no git em um +determinado intervalo de tempo. O intervalo padrão é de 90 dias. + +Isso te dá a oportunidade de reverter qualquer comando que você realizou no git +e que tenha tido consequências indesejadas (por exemplo, se um rebase quebrou +sua aplicação). + +Você pode fazer assim: + +1. `git reflog` para listar todos os comandos utilizados no git para o rebase + +``` +38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog +38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators +4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown +34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666) +ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748) +2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d +``` +2. Selecione para onde você quer resetar. No nosso exemplo, seria o commit +`2e6c386`, ou `HEAD@{5}` +3. 'git reset --hard HEAD@{5}' esse comando irá resetar o seu repositório para +aquele ponto (5 commits atrás). +4. Agora você pode recomeçar o rebase ou apenas deixar como está. + +[Leitura complementar](https://git-scm.com/docs/git-reflog) + +### revert + +O comando revert pode ser utilizado para desfazer um commit. Não deve ser +confundido com o comando reset que restabelece o estado do repositório para um +momento anterior. O revert irá criar um novo commit com alterações inversas a +de um outro commit especificado, portanto revertendo aquelas alterações. + +```bash +# Revertendo um commit específico +$ git revert <commit> +``` + ### rm -O oposto de git add, git rm remove arquivos do branch atual. +O oposto de git add, git rm remove arquivos da branch atual. ```bash -# remove HelloWorld.c -$ git rm HelloWorld.c +# remove OlaMundo.c +$ git rm OlaMundo.c -# Remove um arquivo de um sub-directório -$ git rm /pather/to/the/file/HelloWorld.c +# Remove um arquivo de um sub-diretório +$ git rm /caminho/para/o/arquivo/OlaMundo.c ``` -## Informação complementar (EN) +## Leitura complementar + +* [Configurar o Git (GitHub Docs)](https://docs.github.com/pt/get-started/quickstart/set-up-git) + +* [Learn Git Branching - the most visual and interactive way to learn Git on the web](http://learngitbranching.js.org/) -* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) +* [Udemy Git Tutorial: A Comprehensive Guide](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/) + +* [Git Immersion - A Guided tour that walks through the fundamentals of git](http://gitimmersion.com/) * [git-scm - Video Tutorials](http://git-scm.com/videos) @@ -441,4 +633,10 @@ $ git rm /pather/to/the/file/HelloWorld.c * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) -* [GitGuys](http://www.gitguys.com/) +* [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html) + +* [Pro Git (em Português)](https://www.git-scm.com/book/pt-br/v2) + +* [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners) + +* [The New Boston tutorial to Git covering basic commands and workflow](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAKWClAD_iKpNC0bGHxGhcx) diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown index 31473ee1..ce10e079 100644 --- a/pt-br/go-pt.html.markdown +++ b/pt-br/go-pt.html.markdown @@ -28,7 +28,7 @@ Go vem com uma biblioteca padrão exaustiva e uma comunidade entusiasta. várias linhas */ // A cláusula package aparece no início de cada arquivo. -// Main é um nome especial declarando um executável ao invés de uma biblioteca. +// main é um nome especial declarando um executável ao invés de uma biblioteca. package main // A cláusula Import declara os pacotes referenciados neste arquivo. @@ -77,7 +77,7 @@ pode incluir quebras de linha.` // mesmo tipo string // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8. g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode - f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754) + f := 3.14159 // float64, número de vírgula flutuante de 64bit (IEEE-754) c := 3 + 4i // complex128, representado internamente com dois float64s // Declaração de variáveis, com inicialização. @@ -295,17 +295,17 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { ## Leitura Recomendada -A principal fonte de informação é o [web site oficial Go](http://golang.org/). +A principal fonte de informação é o [web site oficial Go](https://go.dev/). Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito. A própria especificação da linguagem é altamente recomendada. É fácil de ler e incrivelmente curta (em relação ao que é habitual hoje em dia). Na lista de leitura para os aprendizes de Go deve constar o [código fonte da -biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é +biblioteca padrão](https://go.dev/src/). Exaustivamente documentado, é a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da sua escrita idiomática. Ou então clique no nome de uma função na [documentação] -(http://golang.org/pkg/) e veja o código fonte aparecer! +(https://go.dev/pkg/) e veja o código fonte aparecer! Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/). Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown index 3acfce21..dff3f2e1 100644 --- a/pt-br/groovy-pt.html.markdown +++ b/pt-br/groovy-pt.html.markdown @@ -5,7 +5,8 @@ filename: learngroovy-pt.groovy contributors: - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"] translators: - - ["João Farias", "https://github.com/JoaoGFarias"] + - ["João Farias", "https://github.com/joaogfarias"] + - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"] lang: pt-br --- @@ -201,8 +202,16 @@ if(x==1) { //Groovy também suporta o operador ternário def y = 10 -def x = (y > 1) ? "functionou" : "falhou" -assert x == "functionou" +def x = (y > 1) ? "funcionou" : "falhou" +assert x == "funcionou" + +//E suporta o 'The Elvis Operator' também! +//Em vez de usar o operador ternário: + +displayName = nome.name ? nome.name : 'Anonimo' + +//Podemos escrever: +displayName = nome.name ?: 'Anonimo' //Loop 'for' //Itera sobre um intervalo (range) diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown index 58586522..919c0f4f 100644 --- a/pt-br/latex-pt.html.markdown +++ b/pt-br/latex-pt.html.markdown @@ -8,6 +8,7 @@ contributors: - ["Svetlana Golubeva", "https://attillax.github.io/"] translators: - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"] + - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"] lang: pt-br filename: learn-latex-pt.tex --- @@ -16,10 +17,10 @@ filename: learn-latex-pt.tex % Todas as linhas de comentários começam com % % Não existem comentários multilinhas -$ LaTeX não é um programa processador de textos "Visual" como +% LaTeX não é um programa processador de textos "Visual" como % MS Word ou OpenOffice Writer -$ Todo comando LaTeX começa com uma barra invertida (\) +% Todo comando LaTeX começa com uma barra invertida (\) % Documentos LaTeX começam com a definição do tipo que será % compilado % Os tipos de documento podem ser livro, relatório, apresentação, etc. @@ -37,14 +38,11 @@ $ Todo comando LaTeX começa com uma barra invertida (\) \usepackage{float} \usepackage{hyperref} -% Para poder usar caracteres acentuados, use o seguinte pacote: -\usepackage[utf8]{inputenc} - % Podemos definir algumas outras propriedades do documento também! \author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\ Svetlana Golubeva} \date{\today} -\title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!} +\title{Aprenda \LaTeX{} em Y Minutos!} % Agora estamos prontos para começar o documento % Tudo antes dessa linha é chamado "preâmbulo". @@ -52,6 +50,7 @@ Svetlana Golubeva} % Se informarmos os campos author (autores), date (data), "title" (título), % LaTeX poderá cria uma página inicial para nós. \maketitle + % Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso, % o documento deve ser compilado duas vezes, para que tudo apareça na ordem % correta. @@ -69,7 +68,7 @@ Svetlana Golubeva} % Esse comando está disponível para os documentos do tipo artigo (article) % e relatório (report). \begin{abstract} - Documentação do \LaTeX \hspace{1pt} escrita em \LaTeX! Nada original! + Documentação do \LaTeX{} escrita em \LaTeX! Nada original! \end{abstract} % Comandos para seções são intuitivos. @@ -93,11 +92,17 @@ Muito melhor agora. Afinal nem todas as seções precisam ser numeradas! \section{Algumas notas sobre texto} -%\section{Espaçamento % É necessário mais informação sobre intervalos de espaço. -\LaTeX \hspace{1pt} geralmente é muito bom sobre colocar texto onde ele deve +%\section{Espaçamento} % É necessário mais informação sobre intervalos de espaço. +\LaTeX{} geralmente é muito bom sobre colocar texto onde ele deve ser posto. Se uma linha \\ deve \\ ser \\ quebrada \\ adicione \textbackslash\textbackslash -\hspace{1pt} ao código de seu documento. \\ +\hspace{1pt} ao código de seu documento. + +Separe parágrafos por linhas vazias. + +Você precisa adicionar um til após abreviações (se não forem seguidas de vírgula) +para um espaço sem quebra, senão o espaçamento após o ponto será muito largo: +E.g., i.e., etc.~são exemplos de abreviações. \section{Listas} Listas são uma das coisas mais fáceis de criar no \LaTeX! Preciso fazer compras @@ -112,21 +117,21 @@ amanhã, então façamos uma lista de compras. Não é um item da lista, mas faz parte do bloco enumerate. - \end{enumerate} % Todos os blocos devem ter um final (end{}). +\end{enumerate} % Todos os blocos devem ter um final (end{}). \section{Matemática} -Um dos usos iniciais para \LaTeX \hspace{1pt} foi a produção de artigos +Um dos usos iniciais para \LaTeX{} foi a produção de artigos acadêmicos e técnicos. Usualmente nos campos da matemática e ciência. Assim, é -necessários que consigamos incluir alguns símbolos especiais em nosso texto! \\ +necessários que consigamos incluir alguns símbolos especiais em nosso texto! A matemática tem muitos símbolos, além dos quais se pode encontrar no teclado; símbolos para relações e conjuntos, setas, operadores, e letras gregas, apenas -para mencionar alguns.\\ +para mencionar alguns. Conjuntos e relações são essenciais em muitos textos de pesquisa em matemática. Aqui está como você pode indicar como todo x que pertence -a X, $\forall$ x $\in$ X. \\ +a X, $\forall$ x $\in$ X. % Perceba que é necessário adicionar os sinais $ antes e depois dos símbolos. % Isso é porque quando escrevendo, estamos em modo texto. % Mas os símbolos de matemática só existem no modo matemática. @@ -138,15 +143,14 @@ a X, $\forall$ x $\in$ X. \\ \[a^2 + b^2 = c^2 \] Minha letra grega favorita é $\xi$. Eu também gosto da $\beta$, $\gamma$ e $\sigma$. -Eu ainda não encontrei uma letra grega que o \LaTeX \hspace{1pt} não tenha!\\ +Eu ainda não encontrei uma letra grega que o \LaTeX{} não tenha!\\ Operadores são parte essencial de um documento sobre matemática: funções trigonométricas ($\sin$, $\cos$, $\tan$), logaritmo e exponencial ($\log$, $\exp$), -limites ($\lim$), etc. -possuem comandos pré-definidos em LaTex. +limites ($\lim$), etc.~possuem comandos pré-definidos em LaTex. Vamos escrever uma equação para ver como se faz: -$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\ +$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ Frações (numerador/denominador) podem ser escritas dessa forma: @@ -183,8 +187,10 @@ Somatórios e Integrais são escritas com os comandos sum e int: \section{Figuras} -Insiramos uma Figura. O local para colocar a figura pode ser difícil -de determinar. Eu tenho sempre que verificar as opções toda vez. +Insiramos uma Figura. O local para colocar a figura pode ser difícil de determinar. +Operações básicas são [t] para o topo, [b] para base, [h] para aqui (aproximadamente). +Eu tenho sempre que verificar as opções toda vez. +% Veja https://en.wikibooks.org/wiki/LaTeX/Floats,_Figures_and_Captions para mais detalhes \begin{figure}[H] % H aqui é uma opção para o local da figura. \centering % centra a figura na página @@ -201,36 +207,45 @@ Também podemos incluir tabelas da mesma forma que figuras. \begin{table}[H] \caption{Título para a Tabela.} % os argumentos {} abaixo descrevem como cada linha da tabela é desenhada. - % Aqui também, Preciso ver isso. Toda. E. Cada. Vez. + % O básico é simples: uma letra para cada coluna, para controlar o alinhamento: + % Operações básicas são: c, l, r e p para centro, esquerda, direita e parágrafo + % opcionalmente, você pode adicionar um | para linha vertical + % Veja https://en.wikibooks.org/wiki/LaTeX/Tables para mais detalhes \begin{tabular}{c|cc} - Número & Sobrenome & Primeiro Nome \\ % Colunas são separadas por & + Número & Primeiro Nome & Sobrenome \\ % Colunas são separadas por & \hline % uma linha horizontal 1 & Biggus & Dickus \\ 2 & Monty & Python \end{tabular} + % Vai ficar mais ou menos assim: + % Número | Primeiro Nome Sobrenome + % -------|--------------------------- % por causa do \hline + % 1 | Biggus Dickus + % 2 | Monty Python \end{table} -\section{Fazendo o \LaTeX \hspace{1pt} não compilar algo (o código fonte)} +\section{Fazendo o \LaTeX{} não compilar algo (o código fonte)} Digamos que precisamos incluir algum código dentro do nosso -documento \LaTeX \hspace{1pt}, para isso precisamos com o \LaTeX \hspace{1pt} +documento \LaTeX{}, para isso precisamos com o \LaTeX{} não tente interpretar esse texto e que apenas inclua ele no documento. Fazemos isso com o bloco verbatim. % Existem outros pacotes (por exemplo, minty, lstlisting, etc.) % mas verbatim é o básico \begin{verbatim} - print("Hello World!") + print("Olá mundo!") a%b; % olha só! Podemos usar os sinais % no bloco verbatim. - random = 4; #decided by fair random dice roll + random = 4; #decidido por um lançamento honesto de dado + Veja https://www.explainxkcd.com/wiki/index.php/221:_Random_Number \end{verbatim} \section{Compilando} Imagino que agora você esteja pensando como compilar esse fantástico documento -e visualizar a gloriosa glória que é um pdf gerado por \LaTeX \hspace{1pt} pdf. +e visualizar a gloriosa glória que é um pdf gerado por \LaTeX{} pdf. (sim, esse documento é compilável). \\ -Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos: +Finalizando o documento usando \LaTeX{} consiste nos seguintes passos: \begin{enumerate} \item Escrever o documento em texto puro (o ``código fonte''). \item Compilar o código fonte para gerar um pdf. @@ -240,7 +255,7 @@ Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos \end{verbatim} \end{enumerate} -Existem editores de \LaTeX \hspace{1pt} que combinam os passos 1 e 2 no mesmo +Existem editores de \LaTeX{} que combinam os passos 1 e 2 no mesmo sistema de software. Assim, você pode ver o passo 1, mas não o passo 2 por completo. Passo 2 estará acontecendo escondido\footnote{Por exemplo, quando usar referências (como Equação~\ref{eq:pythagoras}), pode ser necessário executar o @@ -267,6 +282,27 @@ Existem dois tipos principais de links: URL visíveis \\ Esse pacote também produz uma lista de thumbnails no documento pdf gerado e ativa os links na tabela de conteúdo. +\section{Escrevendo em ASCII ou outras codificações} + +Por padrão, historicamente LaTeX aceita entradas que são puro ASCII (128), +mas não ASCII extendido, o que significa sem acentos (à, è etc.) e símbolos não latinos. + +É fácil inserir acentos e símbolos latinos básicos através de atalhos de barra invertida +como \,c, \'e, \`A, \ae e \oe etc. % Para ç, é, À, etc +% Veja https://en.wikibooks.org/wiki/LaTeX/Special_Characters#Escaped_codes para mais detalhes + +Para escrever diretamente em UTF-8 quando compilando com pdflatex, use +\begin{verbatim} + \usepackage[utf8]{inputenc} +\end{verbatim} +A fonte selecionada precisa suportar os glifos usados em seu documento. Você precisa adicionar +\begin{verbatim} + \usepackage[T1]{fontenc} +\end{verbatim} + +Desde LuaTeX e XeLaTeX, suporte para UTF-8 vem embutido por padrão, tornando a vida muito +mais fácil para escrever em alfabetos não latinos. + \section{End} Por enquanto é isso! @@ -276,7 +312,7 @@ Por enquanto é isso! \begin{thebibliography}{1} % como em outras listas, o comando \bibitem pode ser usado para itens da lista % cada entrada pode ser citada diretamente no corpo do texto - \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em + \bibitem{latexwiki} The amazing \LaTeX{} wikibook: {\em https://en.wikibooks.org/wiki/LaTeX} \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com} \end{thebibliography} @@ -289,3 +325,6 @@ https://en.wikibooks.org/wiki/LaTeX} * The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX) * An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/) +* A quick guide for learning LaTeX: [Learn LaTeX in 30 minutes](https://www.overleaf.com/learn/latex/Learn_LaTeX_in_30_minutes) +* An interactive platform to learn LaTeX (installationfree) [learnlatex.org/](https://www.learnlatex.org/) +* Stack Exchange's question and answer site about TeX, LaTeX, ConTeXt, etc. [tex.stackexchange.com](https://tex.stackexchange.com/) diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown index 0c75da26..4aaf3a1e 100644 --- a/pt-br/lua-pt.html.markdown +++ b/pt-br/lua-pt.html.markdown @@ -2,7 +2,7 @@ language: Lua contributors: - ["Tyler Neylon", "http://tylerneylon.com/"] -filename: learnlua.lua +filename: learnlua-pt.lua translators: - ["Iaan Mesquita", "https://github.com/ianitow"] lang: pt-br diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown index cbdebde7..d908435a 100644 --- a/pt-br/make-pt.html.markdown +++ b/pt-br/make-pt.html.markdown @@ -1,243 +1,245 @@ ----
-category: tool
-tool: make
-contributors:
- - ["Robert Steed", "https://github.com/robochat"]
- - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
-filename: Makefile
-
-lang: pt-br
----
-
-Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
-
-Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
-
-```make
-
-# Comentários podem ser escritos assim.
-
-# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
-# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
-
-# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
-
-#-----------------------------------------------------------------------
-# Noções básicas
-#-----------------------------------------------------------------------
-
-# Regras são do formato
-# alvo: <pré-requisito>
-# onde os pré-requisitos são opcionais.
-
-# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
-arquivo0.txt:
- echo "foo" > arquivo0.txt
- # Mesmo os comentários nestas seções da 'receita' são passados para o shell.
- # Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
-
-# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
-arquivo1.txt: arquivo0.txt
- cat arquivo0.txt > arquivo1.txt
- # se as mesmas regras de citação do shell.
- @cat arquivo0.txt >> arquivo1.txt
- # @ pára o comando de ser ecoado para stdout.
- -@echo 'hello'
- # - significa que make continuará em caso de erro.
- # Experimentar `make arquivo1.txt` na linha de comando.
-
-# Uma regra pode ter vários alvos e vários pré-requisitos
-arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
- touch arquivo2.txt
- touch arquivo3.txt
-
-# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
-# receitas não contam e podem ser usadas para adicionar novas dependências.
-
-#-----------------------------------------------------------------------
-# Alvos falsos
-#-----------------------------------------------------------------------
-
-# Um alvo falso. Qualquer alvo que não seja um arquivo.
-# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
-all: maker process
-
-# Podemos declarar as coisas fora de ordem.
-maker:
- touch ex0.txt ex1.txt
-
-# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
-.PHONY: all maker process
-# Este é um alvo especial. Existem vários outros.
-
-# Uma regra com dependência de um alvo falso sempre será executada
-ex0.txt ex1.txt: maker
-
-# Alvos falsos comuns são: todos fazem instalação limpa ...
-
-#-----------------------------------------------------------------------
-# Variáveis Automáticas e Curingas
-#-----------------------------------------------------------------------
-
-process: Arquivo*.txt # Usando um curinga para corresponder nomes de arquivos
- @echo $^ # $^ é uma variável que contém a lista de pré-requisitos
- @echo $@ # imprime o nome do alvo
- #(fpara várias regras alvo, $@ é o que causou a execução da regra)
- @echo $< # o primeiro pré-requisito listado
- @echo $? # somente as dependências que estão desatualizadas
- @echo $+ # todas as dependências, incluindo duplicadas (ao contrário do normal)
- #@echo $| # todos os pré-requisitos 'somente pedidos'
-
-# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
-process: ex1.txt arquivo0.txt
-# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
-
-#-----------------------------------------------------------------------
-# Padrões
-#-----------------------------------------------------------------------
-
-# Pode ensinar make a converter certos arquivos em outros arquivos.
-
-%.png: %.svg
- inkscape --export-png $^
-
-# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
-
-# Os caminhos de diretório são normalmente ignorados quando as regras de
-# padrões são correspondentes. Mas make tentará usar a regra mais
-# apropriada disponível.
-small/%.png: %.svg
- inkscape --export-png --export-dpi 30 $^
-
-# make utilizará a última versão para uma regra de padrão que encontrar.
-%.png: %.svg
- @echo esta regra é escolhida
-
-# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
-%.png: %.ps
- @echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
-
-# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
-# como transformar arquivos *.c em arquivos *.o.
-
-# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
-.png.ps:
- @echo essa regra é semelhante a uma regra de padrão.
-
-# make sobre a regra de sufixo
-.SUFFIXES: .png
-
-#-----------------------------------------------------------------------
-# Variáveis
-#-----------------------------------------------------------------------
-# aka. macros
-
-# As variáveis são basicamente todos os tipos de string
-
-name = Ted
-name2="Sarah"
-
-echo:
- @echo $(name)
- @echo ${name2}
- @echo $name # Isso não funcionará, tratado como $ (n)ame.
- @echo $(name3) # Variáveis desconhecidas são tratadas como strings vazias.
-
-# Existem 4 lugares para definir variáveis.
-# Em ordem de prioridade, do maior para o menor:
-# 1: argumentos de linha de comando
-# 2: Makefile
-# 3: variáveis de ambiente do shell - faça importações automaticamente.
-# 4: make tem algumas variáveis predefinidas
-
-name4 ?= Jean
-# Somente defina a variável se a variável de ambiente ainda não estiver definida.
-
-override name5 = David
-# Pára os argumentos da linha de comando de alterar essa variável.
-
-name4 +=grey
-# Anexar valores à variável (inclui um espaço).
-
-# Valores variáveis específicos de padrões (extensão GNU).
-echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
- # e também dentro de suas recursivas dependências
- # (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
-
-# Algumas variáveis definidas automaticamente pelo make
-echo_inbuilt:
- echo $(CC)
- echo ${CXX}
- echo $(FC)
- echo ${CFLAGS}
- echo $(CPPFLAGS)
- echo ${CXXFLAGS}
- echo $(LDFLAGS)
- echo ${LDLIBS}
-
-#-----------------------------------------------------------------------
-# Variáveis 2
-#-----------------------------------------------------------------------
-
-# O primeiro tipo de variáveis é avaliado a cada vez que elas são usadas.
-# TIsso pode ser caro, então existe um segundo tipo de variável que é
-# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
-
-var := hello
-var2 ::= $(var) hello
-#:= e ::= são equivalentes.
-
-# Essas variáveis são avaliadas procedimentalmente (na ordem em que
-# aparecem), quebrando assim o resto da línguagem!
-
-# Isso não funciona
-var3 ::= $(var4) and good luck
-var4 ::= good night
-
-#-----------------------------------------------------------------------
-# Funções
-#-----------------------------------------------------------------------
-
-# make tem muitas funções disponíveis.
-
-sourcefiles = $(wildcard *.c */*.c)
-objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
-
-# O formato é $(func arg0,arg1,arg2...)
-
-# Alguns exemplos
-ls: * src/*
- @echo $(filter %.txt, $^)
- @echo $(notdir $^)
- @echo $(join $(dir $^),$(notdir $^))
-
-#-----------------------------------------------------------------------
-# Diretivas
-#-----------------------------------------------------------------------
-
-# Inclua outros makefiles, úteis para código específico da plataforma
-include foo.mk
-
-sport = tennis
-# Compilação condicional
-report:
-ifeq ($(sport),tennis)
- @echo 'game, set, match'
-else
- @echo "They think it's all over; it is now"
-endif
-
-# Há também ifneq, ifdef, ifndef
-
-foo = true
-
-ifdef $(foo)
-bar = 'hello'
-endif
-```
-
-### More Resources
-
-+ [documentação gnu make](https://www.gnu.org/software/make/manual/)
-+ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
-+ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
+--- +category: tool +tool: make +contributors: + - ["Robert Steed", "https://github.com/robochat"] + - ["Stephan Fuhrmann", "https://github.com/sfuhrm"] +translators: + - ["Rogério Gomes Rio", "https://github.com/rogerlista"] +filename: Makefile-pt + +lang: pt-br +--- + +Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas. + +Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux. + +```make + +# Comentários podem ser escritos assim. + +# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`. +# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`. + +# Aviso - use somente TABS para identar em Makefiles, nunca espaços! + +#----------------------------------------------------------------------- +# Noções básicas +#----------------------------------------------------------------------- + +# Regras são do formato +# alvo: <pré-requisito> +# onde os pré-requisitos são opcionais. + +# Uma regra - esta regra só será executada se o arquivo0.txt não existir. +arquivo0.txt: + echo "foo" > arquivo0.txt + # Mesmo os comentários nestas seções da 'receita' são passados para o shell. + # Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão. + +# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt. +arquivo1.txt: arquivo0.txt + cat arquivo0.txt > arquivo1.txt + # se as mesmas regras de citação do shell. + @cat arquivo0.txt >> arquivo1.txt + # @ pára o comando de ser ecoado para stdout. + -@echo 'hello' + # - significa que make continuará em caso de erro. + # Experimentar `make arquivo1.txt` na linha de comando. + +# Uma regra pode ter vários alvos e vários pré-requisitos +arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt + touch arquivo2.txt + touch arquivo3.txt + +# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar +# receitas não contam e podem ser usadas para adicionar novas dependências. + +#----------------------------------------------------------------------- +# Alvos falsos +#----------------------------------------------------------------------- + +# Um alvo falso. Qualquer alvo que não seja um arquivo. +# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo. +all: maker process + +# Podemos declarar as coisas fora de ordem. +maker: + touch ex0.txt ex1.txt + +# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome +.PHONY: all maker process +# Este é um alvo especial. Existem vários outros. + +# Uma regra com dependência de um alvo falso sempre será executada +ex0.txt ex1.txt: maker + +# Alvos falsos comuns são: todos fazem instalação limpa ... + +#----------------------------------------------------------------------- +# Variáveis Automáticas e Curingas +#----------------------------------------------------------------------- + +process: Arquivo*.txt # Usando um curinga para corresponder nomes de arquivos + @echo $^ # $^ é uma variável que contém a lista de pré-requisitos + @echo $@ # imprime o nome do alvo + #(fpara várias regras alvo, $@ é o que causou a execução da regra) + @echo $< # o primeiro pré-requisito listado + @echo $? # somente as dependências que estão desatualizadas + @echo $+ # todas as dependências, incluindo duplicadas (ao contrário do normal) + #@echo $| # todos os pré-requisitos 'somente pedidos' + +# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los +process: ex1.txt arquivo0.txt +# ex1.txt será encontrado, mas arquivo0.txt será desduplicado. + +#----------------------------------------------------------------------- +# Padrões +#----------------------------------------------------------------------- + +# Pode ensinar make a converter certos arquivos em outros arquivos. + +%.png: %.svg + inkscape --export-png $^ + +# As regras padrões só farão qualquer coisa se decidirem criar o alvo. + +# Os caminhos de diretório são normalmente ignorados quando as regras de +# padrões são correspondentes. Mas make tentará usar a regra mais +# apropriada disponível. +small/%.png: %.svg + inkscape --export-png --export-dpi 30 $^ + +# make utilizará a última versão para uma regra de padrão que encontrar. +%.png: %.svg + @echo esta regra é escolhida + +# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo +%.png: %.ps + @echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes + +# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe +# como transformar arquivos *.c em arquivos *.o. + +# Makefiles antigos podem usar regras de sufixo em vez de regras padrões +.png.ps: + @echo essa regra é semelhante a uma regra de padrão. + +# make sobre a regra de sufixo +.SUFFIXES: .png + +#----------------------------------------------------------------------- +# Variáveis +#----------------------------------------------------------------------- +# aka. macros + +# As variáveis são basicamente todos os tipos de string + +name = Ted +name2="Sarah" + +echo: + @echo $(name) + @echo ${name2} + @echo $name # Isso não funcionará, tratado como $ (n)ame. + @echo $(name3) # Variáveis desconhecidas são tratadas como strings vazias. + +# Existem 4 lugares para definir variáveis. +# Em ordem de prioridade, do maior para o menor: +# 1: argumentos de linha de comando +# 2: Makefile +# 3: variáveis de ambiente do shell - faça importações automaticamente. +# 4: make tem algumas variáveis predefinidas + +name4 ?= Jean +# Somente defina a variável se a variável de ambiente ainda não estiver definida. + +override name5 = David +# Pára os argumentos da linha de comando de alterar essa variável. + +name4 +=grey +# Anexar valores à variável (inclui um espaço). + +# Valores variáveis específicos de padrões (extensão GNU). +echo: name2 = Sara # Verdadeiro dentro da regra de correspondência + # e também dentro de suas recursivas dependências + # (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!) + +# Algumas variáveis definidas automaticamente pelo make +echo_inbuilt: + echo $(CC) + echo ${CXX} + echo $(FC) + echo ${CFLAGS} + echo $(CPPFLAGS) + echo ${CXXFLAGS} + echo $(LDFLAGS) + echo ${LDLIBS} + +#----------------------------------------------------------------------- +# Variáveis 2 +#----------------------------------------------------------------------- + +# O primeiro tipo de variáveis é avaliado a cada vez que elas são usadas. +# TIsso pode ser caro, então existe um segundo tipo de variável que é +# avaliado apenas uma vez. (Esta é uma extensão do GNU make) + +var := hello +var2 ::= $(var) hello +#:= e ::= são equivalentes. + +# Essas variáveis são avaliadas procedimentalmente (na ordem em que +# aparecem), quebrando assim o resto da línguagem! + +# Isso não funciona +var3 ::= $(var4) and good luck +var4 ::= good night + +#----------------------------------------------------------------------- +# Funções +#----------------------------------------------------------------------- + +# make tem muitas funções disponíveis. + +sourcefiles = $(wildcard *.c */*.c) +objectfiles = $(patsubst %.c,%.o,$(sourcefiles)) + +# O formato é $(func arg0,arg1,arg2...) + +# Alguns exemplos +ls: * src/* + @echo $(filter %.txt, $^) + @echo $(notdir $^) + @echo $(join $(dir $^),$(notdir $^)) + +#----------------------------------------------------------------------- +# Diretivas +#----------------------------------------------------------------------- + +# Inclua outros makefiles, úteis para código específico da plataforma +include foo.mk + +sport = tennis +# Compilação condicional +report: +ifeq ($(sport),tennis) + @echo 'game, set, match' +else + @echo "They think it's all over; it is now" +endif + +# Há também ifneq, ifdef, ifndef + +foo = true + +ifdef $(foo) +bar = 'hello' +endif +``` + +### More Resources + ++ [documentação gnu make](https://www.gnu.org/software/make/manual/) ++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/) ++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html) diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown index dc50cac1..fca864bb 100644 --- a/pt-br/markdown-pt.html.markdown +++ b/pt-br/markdown-pt.html.markdown @@ -6,36 +6,56 @@ translators: - ["Miguel Araújo", "https://github.com/miguelarauj1o"] - ["Gabriele Luz", "https://github.com/gabrieleluz"] - ["Monique Baptista", "https://github.com/bfmonique"] + - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"] -lang: pt-br +lang: pt-br filename: learnmarkdown-pt.md --- -Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e -escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também). - -Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e -puxar o projeto (pull request) +O Markdown foi lançado por John Gruber em 2004. Criado para ser uma sintaxe +fácil de ler e escrever e que é facilmente convertida em HTML (hoje, suporta +outros formatos também). + +O Markdown varia em termos de implementação de um parser para outro. Esse guia +irá tentar deixar explícito quando os recursos são universais ou quando são +específicos para um parser em específico. + +- [Elementos HTML](#elementos-html) +- [Cabeçalhos](#cabeçalhos) +- [Estilos de texto simples](#estilos-de-texto-simples) +- [Parágrafos](#parágrafos) +- [Listas](#listas) +- [Blocos de código](#blocos-de-código) +- [Linha Horizontal](#linha-horizontal) +- [Links](#links) + - [Tabela de conteúdo](#tabela-de-conteúdo) +- [Imagens](#imagens) +- [Miscelânea](#miscelânea) + - [Auto-links](#auto-links) + - [Auto-links para e-mails](#auto-links-com-e-mails) + - [Escapando caracteres](#escapando-caracteres) + - [Teclas do teclado](#teclas-do-teclado) + - [Tabelas](#tabelas) +- [Markdownlint](#markdownlint) +- [Leitura complementar](#leitura-complementar) ## Elementos HTML -Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é +O Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é um arquivo Markdown válido. -```md -<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é -um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML -em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador -de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você -não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.--> - -<!--A maneira como o Markdown é analisado varia de software para software. -Este guia vai tentar esclarecer quando as características são universais, ou quando eles são específicos para um determinado interpretador --> +```md +<!--Isso significa que nós podemos usar elementos HTML em Markdown, como o +elemento de comentário, e eles não serão afetados pelo analisador de +remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, +você não pode usar sintaxe de remarcação dentro do conteúdo desse elemento.--> +``` ## Cabeçalhos Você pode criar elementos HTML `<h1>` até `<h6>` facilmente antecedendo o texto -que deseja estar nesse elemento por um número de hashes (#) +que deseja estar nesse elemento por um número de cerquilhas (#). +```md # Isto é um cabeçalho <h1> ## Isto é um cabeçalho <h2> ### Isto é um cabeçalho <h3> @@ -44,7 +64,7 @@ que deseja estar nesse elemento por um número de hashes (#) ###### Isto é um cabeçalho <h6> ``` -Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 +Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2. ```md Isto é um cabeçalho h1 @@ -55,21 +75,22 @@ Isto é um cabeçalho h2 ``` ## Estilos de texto simples -O texto pode ser facilmente denominado como marcação itálico, negrito ou tachado usando: + +O texto pode ser facilmente estilizado como itálico ou negrito usando Markdown. ```md *Este texto está em itálico* _E este também está._ **Este texto está em negrito** -__E este também está._ +__E este também está.__ ***Este texto está em negrito e itálico.*** **_E este também está_** -*--Danouse! Este também__* +*__Danou-se! Este também__* ``` -Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown +No GitHub Flavored Markdown, que é usado para processar arquivos Markdown GitHub, nós também temos: ```md @@ -77,43 +98,46 @@ GitHub, nós também temos: ``` ## Parágrafos -Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por +Os parágrafos estão em uma ou várias linhas adjacentes de texto separadas por uma ou múltiplas linhas em branco. ```md Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal? Agora, eu estou no parágrafo 2. -... Ainda continuo no parágrafo 2! :) +Ainda continuo no parágrafo 2! + -Eu estou no parágrafo três. +Eu estou no parágrafo três! ``` Se você quiser inserir uma tag HTML `<br />`, você pode acabar com um parágrafo -com dois ou mais espaços e, em seguida, começar um novo parágrafo +com dois ou mais espaços e, em seguida, começar um novo parágrafo. ```md -Termino com dois espaços (destacar-me para vê-los). +Termino com dois espaços (selecione essa linha para vê-los). Há um <br /> acima de mim! ``` - -Bloco de citações são fáceis e feito com o caractere >. +Blocos de citações são fáceis e feitos com o caractere >. ```md > Este é um bloco de citação. Você pode -> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode -> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, -> desde que eles começam com um `>`. - +> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você +> pode deixar suas linhas ficarem muito longas e quebrarem por conta própria. +> Não faz diferença, desde que elas comecem com um `>`. > Você também pode usar mais de um nível >> De recuo? +> O quão legal é isso? + ``` ## Listas -As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens + +As listas não ordenadas podem ser feitas usando asteriscos, sinais de positivo +ou hífens. ```md * Item @@ -141,18 +165,18 @@ Listas ordenadas são feitas com um número seguido por um ponto. 3. Item três ``` -<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os -itens em ordem, mas isso pode não ser uma boa idéia --> - +Você não precisa sequer rotular os itens corretamente e o Markdown ainda +assim deixará os itens em ordem, mas isso pode não ser uma boa idéia. ```md 1. Item um 1. Item dois 1. Item três ``` + (Isto é processado da mesma forma que o exemplo acima) -Você também pode usar sublistas +Você também pode usar sublistas. ```md 1. Item um @@ -163,63 +187,59 @@ Você também pode usar sublistas 4. Item quatro ``` -Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) de HTML +Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) do +HTML. ```md -As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas -- [ ] Primeira tarefa a completar +As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas. +- [ ] Primeira tarefa a completar. - [ ] Segunda tarefa a completar -A caixa de seleção abaixo será exibida como uma checkbox HTML marcada +A caixa de seleção abaixo será exibida como uma checkbox HTML marcada. - [x] Essa tarefa foi completa - ``` - ## Blocos de código -Você pode indicar um bloco de código (que utiliza o elemento `<code>`) pelo recuo -uma linha com quatro espaços ou uma guia -```md - Isto é código - É assim, sacou? - -``` -Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo -dentro do seu código +Você pode indicar um bloco de código (que utiliza o elemento `<code>`) através +de indentação com quatro espaços ou uma tabulação. ```md - my_array.each do |item| - puts item - end - ``` + Isto é código + É assim, sacou? +``` -Código embutido pode ser criada usando o caractere de crase `` ` `` +Você pode também adicionar mais tabulações (ou adicionar mais quatro espaços +adicionais) para indentação no seu código. ```md -John não sabia nem o que o função `goto()` fazia! + my_array.each do |item| + puts item + end ``` -Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código +Código embutido pode ser criado usando o caractere de crase `` ` ``. + ```md - ``` ruby - def foobar - puts "Hello world!" - end - ``` +John não sabia nem o que a função `go_to()` fazia! ``` -======= -\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ``` -ruby! --> + +No GitHub Flavored Markdown, você pode usar uma sintaxe especial para código. + +````md +```ruby def foobar - puts "Hello world!" + puts "Olá mundo!" end -\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` --> +``` +```` -O texto acima não requer recuo, além disso o GitHub vai usar a sintaxe highlight da linguagem que você especificar após a \`\`\`. +O texto acima não requer indentação, além disso o GitHub vai usar o destaque +de sintaxe da linguagem qeu você especificar após a tag <code>```</code>. ## Linha Horizontal -Linhas horizontais são facilmente adicionados com três ou mais asteriscos ou hífens, -com ou sem espaços. + +Linhas horizontais são facilmente adicionadas com três ou mais asteriscos ou +hífens, com ou sem espaços. ```md *** @@ -229,17 +249,19 @@ com ou sem espaços. ``` ## Links -Uma das melhores coisas sobre a marcação é o quão fácil é fazer ligações. Colocar -o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () + +Uma das melhores coisas sobre o Mardkwon é o quão fácil é criar links. +Coloque o texto a ser exibido entre colchetes [] seguido pela url entre +parênteses () ```md -[Click aqui!](http://test.com/) +[Clique aqui!](http://test.com/) ``` -Você também pode adicionar um título link usando aspas dentro dos parênteses +Você também pode adicionar um título ao link usando aspas dentro dos parênteses. ```md -[Click aqui!](http://test.com/ "Link para Test.com") +[Cliqueaqui!](http://test.com/ "Link para Test.com") ``` Caminhos relativos funcionam também. @@ -248,46 +270,69 @@ Caminhos relativos funcionam também. [Ir para música](/música/). ``` -Markdown também suporta ligações de estilo de referência +O Markdown também suporta links para referências no texto. ```md -[Clique neste link] [link1] para mais informações sobre isso! -[Além disso, verifique este link] [foobar] se você quiser. +[Clique nesse link][link1] para mais informações! +[Também cheque esse link][foobar] se você quiser. [link1]: http://test.com/ "Legal!" -[foobar]: http://foobar.biz/ "OK!" +[link2r]: http://foobar.biz/ "Certo!" ``` O título também pode estar entre aspas simples ou entre parênteses, ou omitido -inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência -pode ser qualquer um, desde que eles são únicos. +inteiramente. As referências podem estar em qualquer lugar no documento e os +IDs de referência podem ser qualquer um, desde que eles sejam únicos. -Existe também a "nomeação implicita", que permite que você use o texto do link como o id +Existe também a "nomeação implícita", que permite que você use o texto do link +como o id: ```md -[Este] [] é um link. +[Isso][] é um link. -[este]: http://thisisalink.com/ +[Isso]: http://thisisalink.com/ ``` -Mas não são usados normalmente +Mas geralmente não são usados. + +### Tabela de conteúdo + +Alguns sabores de Markdown fazem inclusive uso de combinação de listas, links e +cabeçalhos de modo a criar uma tabela de conteúdo. Nesse caso, títulos em +cabeçalhos são precedidos de (`#`) e são usados como ids para links. Se o +cabeçalho consistir de várias palavras, elas serão conectadas por hífens (`-`), +que também substitui alguns caracteres especiais. (Embora alguns outros +carácteres especiais sejam omitidos.) + +```md +- [Cabeçalho](#cabecalho) +- [Um outro cabeçalho](#outro-cabecalho) +- [Capítulo](#capitulo) + - [Subcapítulo <h3 />](#subcapitulo-h3-) +``` + +De qualquer modo, esse é um recurso que talvez não funcione em todas as +implementações do Markdown da mesma forma. ## Imagens -As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! + +As imagens são feitas da mesma forma que os links, mas com um ponto de +exclamação na frente! ```md - + ``` E estilo de referência funciona como esperado ```md -![Este é o pairar-texto.][Myimage] +![Esse é o alt-attribute.][myimage] -[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" +[Minha imagem]: relative/urls/cool/image.jpg "se precisar de um título, está aqui" ``` ## Miscelânea + ### Auto-links ```md @@ -303,14 +348,25 @@ E estilo de referência funciona como esperado ### Escapando caracteres -Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja +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 \*. +### Teclas do teclado + +No GitHub Flavored Markdown, você pode usar a tag `<kbd>` para representar uma +tecla do teclado. + +```md +Seu computador travou? Tente apertar +<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd> +``` + ### Tabelas + Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente complicadas, mas se você realmente quer: -```md +```md | Col1 | Col2 | Col3 | | :----------- | :------: | ------------: | | esquerda-alin| Centrado | direita-alinh | @@ -325,8 +381,22 @@ Col 1 | Col2 | Col3 Ugh isso é tão feio | faça isto | parar ``` -Fim! +## Markdownlint + +De modo a simplificar o trabalho com Markdown e padronizar estilo de código, o +`Markdownlint` foi criado. Essa ferramenta está disponível como plugin para +algumas interfaces de desenvolvimento (IDEs) e pode ser utilizada como um +utilitário para garantir validade e legibilidade do Markdown. --- -Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax) -e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). + +## Leitura complementar + +Para mais informações, confira o post oficial de John Gruber sobre sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax) +e o do cheatsheet do Adam Pritchard [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). + +Se você quiser aprender mais sobre recursos de alguns sabores específicos de +Markdown, veja: + +- [GitHub flavored Markdown](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax) +- [GitLab flavored Markdown](https://docs.gitlab.com/ee/user/markdown.html) diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown index fae17bca..947e0699 100644 --- a/pt-br/matlab-pt.html.markdown +++ b/pt-br/matlab-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: Matlab +language: MATLAB contributors: - ["mendozao", "http://github.com/mendozao"] - ["jamesscottbrown", "http://jamesscottbrown.com"] @@ -120,7 +120,7 @@ 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) % 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 @@ -479,7 +479,7 @@ perms(x) % Lista todas as permutações de elementos de x % Classes -% Matlab pode suportar programação orientada a objetos. +% 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 @@ -501,7 +501,7 @@ classdef ClassePosicoesGPS % O nome da classe. 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: + % 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]); @@ -513,7 +513,7 @@ end % Podemos criar um objeto da classe usando o construtor a = ClassePosicoesGPS(45.0, 45.0) -% Propriedades da classe se comportam exatamente como estruturas Matlab +% Propriedades da classe se comportam exatamente como estruturas MATLAB a.latitude = 70.0 a.longitude = 25.0 @@ -524,15 +524,15 @@ ans = multiplicarLatPor(a,3) % 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 +% 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 +## 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/php-pt.html.markdown b/pt-br/php-pt.html.markdown index e55f1100..7db6a671 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: php-pt.html.markdown +filename: learnphp-pt.php --- Este documento descreve PHP 5+. diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown new file mode 100644 index 00000000..5ed2950a --- /dev/null +++ b/pt-br/processing-pt.html.markdown @@ -0,0 +1,480 @@ +--- +language: processing +filename: learnprocessing.pde +contributors: + - ["Phone Thant Ko", "http://github.com/phonethantko"] + - ["Divay Prakash", "https://github.com/divayprakash"] +translators: + - ["Kemel Zaidan", "https://github.com/kemelzaidan"] +lang: pt-br +--- + +## Introdução + +Processing é uma linguagem de programação para criação de artes digitais e +conteúdo multimídia, permitindo que não programadores aprendam os fundamentos +da programação computacional em um contexto visual. + +Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente +influenciado por ambas as sintaxes Java e Javascript. +[Veja mais aqui](https://processing.org/reference/) + +A linguagem é tipada estaticamente e também vem com o seu Ambiente de Desenvolvimento +Integrado (do inglês Integrated Development Environment - IDE) oficial para +compilar e executar os scripts. + +``` +/* --------- + Comentários + --------- +*/ + +// Comentário de linha única começa com // + +/* + Como o Processing é baseado em Java, + a sintaxe para seus comentários é a mesma do Java (como você deve ter notado + acima)! + Comentários de várias linhas são agrupados como visto aqui. +*/ + +/* --------------------------------------- + Escrevendo e executando programas em Processing + --------------------------------------- +*/ + +// No Processing, o ponto de entrada do programa é uma função chamada setup() +// com um tipo de retorno void. +// Observação! A sintaxe é muito semelhante à do C++. +void setup() { + // Isso imprime a saída clássica "Hello World!" no console quando executado. + println("Olá Mundo!"); // Mais uma linguagem com esse maldito ponto e vírgula, não é? +} + +// Normalmente, colocamos todos os códigos estáticos dentro do método setup() +// como o próprio nome sugere, uma vez que é executado apenas uma vez. +// Pode variar da definição das cores de fundo, ou o tamanho da tela. +background(color); //define a cor do fundo +size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro +// opcional para definir o renderizador +// Você verá mais sobre isso ao longo deste documento. + +// Se você deseja executar os códigos indefinidamente, eles devem ser colocados +// dentro do método draw() +// draw() deve existir caso você queira que o código seja executado +// continuamente e, obviamente, só pode haver um método draw(). +int = 0; +void draw(){ + // Este bloco de código faz um loop para sempre até parar + imprima(i); + i++; // Operador de incremento! +} + +// Agora que sabemos como escrever o script de trabalho e como executá-lo, +// continuaremos a explorar quais tipos de dados e coleções são suportados no +// Processing. + +/* ------------------------ + Tipos de dados e coleções + ------------------------ +*/ + +// De acordo com as Referências do Processing, ele suporta 8 tipos primitivos +// de dados da seguinte forma. + +boolean valorBoleano = true; // Boleano +byte valorByteDeA = 23; // Byte +char valorCharDeA = 'A'; // Caractere +color valorDeCorBrancoM = color(255, 255, 255); // Cor (especificada usando +// método color()) +color valorDeCorBrancoH = #FFFFFF; // Cor (especificada usando valor de hash) +int valor = 5; // Inteiro (Número sem decimais) +long valorLongo = 2147483648L; // "L" é adicionado ao número para marcá-lo como um longo +float valorFloat = 1,12345; // Float (números de ponto flutuante de 32 bits) +double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits) + +// NOTA! +// Embora os tipos de dados "long" e "double" funcionem na linguagem, +// funções do Processing não usam esses tipos de dados, portanto +// eles precisam ser convertidos em tipos de dados "int" e "float", +// respectivamente, usando a sintaxe (int) e (float) antes de passar para uma +// função. + +// Existem vários tipos de dados compostos que estão disponíveis por padrão para +// uso no Processing. +// Primeiramente, farei um resumo dos mais usados para economizar tempo. + +// String +// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas +// duplas. +string stringExemplo = "Olá, Processing!"; +// String também pode ser criada a partir de um array de tipos de dados char. +// Nós vamos discutir array muito em breve. +char fonte = {'H', 'E', 'L', 'L', 'O'}; +String stringDeFonte = new String(source); // HELLO +// Como em Java, strings podem ser concatenadas usando o operador "+". +print("Olá " + "Mundo!"); // Olá Mundo! + +// Array +// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os +// próprios objetos. Como os arrays são semelhantes aos objetos, eles devem +// ser criados com a palavra-chave "new". +int[] arrayInt = new int[5]; +int[] arrayIntComValores = {1, 2, 3}; // Você também pode preencher com dados. + +// Lista de Arrays +// As funções são semelhantes às do array; arraylists podem conter qualquer +// tipo de dados. A única diferença é que as listas de matrizes são +// redimensionadas dinamicamente, pois é uma forma de implementação de matriz +// redimensionável da interface "List" do Java . +ArrayList<Integer> intArrayList = new ArrayList<Integer>(); + +// Objeto +// Como é baseado em Java, o Processing suporta programação orientada a objetos. +// Isso significa que você pode basicamente definir quaisquer tipos de dados de +// sua preferência e manipulá-los para suas necessidades. +// Claro, uma classe tem que ser definida antes para o objeto que você quer. +// Formato --> NomeClasse NameInstancia +UmaClasseQualquer meuObjeto // então instancia mais tarde +//ou +UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer(); + +// O Processing surge com mais coleções (ex. - Dicionários e Listas) por +// padrão, por uma questão de simplicidade, vou deixá-los fora da discussão aqui. + +/* ------------ + Matemática + ------------ +*/ + +// Aritmética +1 + 1 // 2 +2 - 1 // 1 +2 * 3 // 6 +3/2 // 1 +3.0 / 2 // 1.5 +3.0% 2 // 1.0 + +// O Processing também vem com um conjunto de funções que simplificam operações +// matemáticas. +float f = sq(3); // f = 9.0 +float p = pow(3, 3); // p = 27.0 +int a = abs(-13); // a = 13 +int r1 = round(3.1); // r1 = 3 +int r2 = round(3.7); // r2 = 4 +float sr = sqrt(25); // sr = 5.0 + +// Vetores +// O Processing fornece uma maneira fácil de implementar vetores em seu ambiente +// usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e +// vem com um conjunto de métodos que são úteis para operações com matrizes. +// Você pode encontrar mais informações sobre a classe PVector e suas funções +// aqui. (https://processing.org/reference/PVector.html) + +// Trigonometria +// O Processing também suporta operações trigonométricas fornecendo um +// conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também +// degrees() e radians() para conversão conveniente. +// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é +// necessário converter previamente. +float um = sin(PI/2); // um = 1.0 +// Como você deve ter notado, existe um conjunto de constantes para usos +// trigonométricos; PI, HALF_PI, QUARTER_PI e assim por diante... + +/* ------------- + Controle de fluxo + ------------- +*/ + +// Declarações Condicionais +// Instruções If - A mesma sintaxe das instruções if em Java. +if (author.getAppearance().equals("quente")) { + print("Narcisismo no máximo!"); +} else { + // Você pode verificar outras condições aqui. + print("Algo está realmente errado aqui!"); +} +// Um atalho para instruções if-else também pode ser usado. +int = 3; +String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena" + +// A estrutura switch-case pode ser usada para verificar várias condições de +// forma concisa. É importante usar a instrução break. Se a instrução `break` +// não existe o programa executa todos os casos a seguir após um caso ser +// verdadeiro. +int valor = 2; +switch(valor) { + case 0: + print("Nada!"); // Isso não é executado. + break; // Salta para a próxima instrução + case 1: + print("Chegando lá..."); // Isso novamente não é executado. + break; + case 2: + print("Bravo!"); // Esta linha é executada. + break; + default: + print("Não encontrado!"); // Esta linha é executada se nosso valor for algum outro valor. + break; +} + +// Declarações iterativas +// Declarações For - Novamente, a mesma sintaxe que em Java +for(int i = 0; i < 5; i++){ + print(i); // imprime de 0 a 4 +} + +// Declarações While - Novamente, nada de novo se você estiver familiarizado com +// a sintaxe Java. +int j = 3; +while(j > 0) { + print(j); + j--; // Isso é importante para evitar que o código seja executado indefinidamente. +} + +// loop()| noLoop() | redraw() | exit() +// Estas são mais funções específicas do Processing para configurar o fluxo do +// programa. +loop(); // permite que o método draw() seja executado para sempre enquanto +noLoop(); // só permite que ele seja executado uma vez. +redraw(); // executa o método draw() mais uma vez. +exit(); // Isso para o programa. É útil para programas com draw() +// rodando continuamente. +``` + +## Desenho com Processing + +Como você já deve ter entendido o básico da linguagem, vamos agora +ver a melhor parte do Processing - DESENHAR. + +``` +/* ------ + Formas + ------ +*/ + +// Formas 2D + +// Ponto +point(x, y); // No espaço 2D +point(x, y, z); // No espaço 3D +// Desenha um ponto no espaço de coordenadas. + +// Linha +line(x1, y1, x2, y2); // No espaço 2D +line(x1, y1, z1, x2, y2, z2); // No espaço 3D +// Desenha uma linha conectando dois pontos definidos por (x1, y1) e (x2, y2). + +// Triângulo +triangle(x1, y1, x2, y2, x3, y3); +// Desenha um triângulo conectando três pontos definidos por parâmetros de coordenadas. + +// Retângulo +rect(a, b, c, d, [r]); // Com parâmetro opcional definindo o raio de todos os cantos +rect(a, b, c, d, [te, td, bd, be]); // Com conjunto opcional de parâmetros definindo +// raio de cada canto +// Desenha um retângulo com {a, b} como coordenada superior esquerda e c e d como largura +// e altura respectivamente. + +// Quad +quad(x, y, x2, y2, x3, y3, x4, y4); +// Desenha um quadrilátero com parâmetros que definem as coordenadas de cada canto +// ponto. + +// Elipse +ellipse(x, y, largura, altura); +// Desenha um eclipse no ponto {x, y} com largura e altura especificadas. + +// Arco +arc(x, y, largura, altura, inicio, fim, [modo]); +// Enquanto os primeiros quatro parâmetros são autoexplicativos, +// início e fim definem os ângulos que o arco começa e termina (em radianos). +// O parâmetro opcional [mode] define o preenchimento; +// PIE dá o contorno de torta, CHORD dá o contorno reto e OPEN é como +// CHORD porém sem contorno + +// Curvas +// O Processing fornece duas implementações de curvas; usando curve() e +// bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes. +// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as +// referências: (https://processing.org/reference/curve_.html) +// (https://processing.org/reference/bezier_.html) + +// Formas 3D + +// espaço 3D +pode ser configurado definindo "P3D" para o parâmetro do renderizador no +// método size(). +size(largura, altura, P3D); +// No espaço 3D, você terá que traduzir para a coordenada específica para +// renderiza as formas 3D. + +// Caixa +box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho +box(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente + +// Esfera +sphere(raio); // Seu tamanho é definido usando o parâmetro raio +// O mecanismo por trás da renderização das esferas é implementado por +// triângulos em mosaico. Dito isso, o nível de detalhe sendo renderizado é +// controlado pela função sphereDetail(res) +// Mais informações aqui: (https://processing.org/reference/sphereDetail_.html) + +// Formas irregulares +// E se você quiser desenhar algo que não foi disponibilizado pelo Processing +// funções? +// Você pode usar beginShape(), endShape(), vertex(x,y) para definir formas por +// especificando cada ponto. Mais informações aqui: +// (https://processing.org/reference/beginShape_.html) +// Você também pode usar formas personalizadas usando a classe PShape: +// (https://processing.org/reference/PShape.html) + +/* --------------- + Transformações + --------------- +*/ + +// As transformações são particularmente úteis para acompanhar o espaço de +// coordenadas e os vértices das formas que você desenhou. Particularmente; +// métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y) +pushMatriz(); // Salva o sistema de coordenadas atual na pilha +// ... aplique todas as transformações aqui ... +popMatriz(); // Restaura o sistema de coordenadas salvo +// Usando-os, o sistema de coordenadas pode ser preservado e visualizado sem +// causar qualquer conflito. + +// Traduzir +translate(x,y); // Traduz para o ponto{x, y} ou seja - configurando a origem para esse ponto +translate(x, y, z); // Contraparte 3D da função + +// Rotacionar +rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo +// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: +// rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo) + +// Escala +scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o. + +/* -------------------- + Estilo e texturas + -------------------- +*/ + +// Cores +// Como discuti anteriormente, a cor de fundo pode ser configurada usando a +// função background(). Você pode definir a cor de um objeto de antemão e depois +// passar para a função como um argumento. +color c = cor(255, 255, 255); // BRANCO! +// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado +// para HSB usando colorMode(). Leia mais aqui: +// (https://processing.org/reference/colorMode_.html) +background(c); // Até agora, a cor de fundo deve ser branca. +// Você pode usar a função fill() para selecionar a cor para preencher as formas. +// Tem que ser configurado antes de você começar a desenhar formas para que as +// cores fiquem aplicadas. +fill(color(0, 0, 0)); +// Se você quiser apenas colorir os contornos das formas, você pode usar +// função stroke(). +stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparência +// definido para um valor menor. + +// Imagens +// O Processing pode renderizar imagens e usá-las de várias maneiras. +// Principalmente armazenado como Tipo de dados PImage. +filter(sombreador); // O Processing suporta várias funções de filtro para manipulação de imagens. +texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas. +``` + +Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma +documentação curta, então vou deixá-los aqui. Se você se interessar, por favor verifique as referências. + +``` +// Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas +// para que você possa estender a funcionalidade do Processing para outros horizontes. + +/* ------- + Importações + ------- +*/ + +// As possibilidades do Processing pode ser estendidas ainda mais quando +// importamos bibliotecas e pacotes em nossos esboços. +// A instrução de importação pode ser escrita como abaixo na parte superior +// do código-fonte. +import processing.algumacoisa.*; +``` + +## VAC? + +Vamos ao código? Vamos sujar as mãos! + +Vamos ver um exemplo do openprocessing para visualizar o quanto o Processing é +capaz de fazer com poucas linhas de código. + +Copie o código abaixo em seu IDE do Processing e veja a mágica. + +``` +// Isenção de responsabilidade: eu não escrevi este programa porque atualmente +// estou ocupado com meu estágio e este sketch é adaptado do openprocessing pois +// mostra algo legal com um código simples. +// Recuperado de: (https://www.openprocessing.org/sketch/559769) + +float theta; +float a; +float col; +float num; + +void setup() { + size(600,600); +} + +void draw() { + background(#F2F2F2); + translate(width/2, height/2); + theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6); + + float num=6; + for (int i=0; i<num; i++) { + a =350; + rotate(TWO_PI/num); + branch(a); + } + +} + +void branch(float len) { + col=map(len, 0, 90, 150, 255); + fill(col, 0, 74); + stroke (col, 0, 74); + line(0, 0, 0, -len); + ellipse(0, -len, 3, 3); + len *= 0.7; + + if (len>30) { + pushMatrix(); + translate(0, -30); + rotate(theta); + branch(len); + popMatrix(); + + pushMatrix(); + translate(0, -30); + rotate(-theta); + branch(len); + popMatrix(); + + } +} +``` + +A linguagem Processing é fácil de aprender e é particularmente útil para criar +conteúdo (mesmo em 3D) sem ter que digitar muitos códigos. É tão simples +que você pode ler o código e ter uma ideia aproximada do fluxo do programa. + +No entanto, isso não se aplica quando você introduz bibliotecas externas, pacotes +e até mesmo suas próprias aulas. (Confie em mim! Projetos em processing podem ficar realmente monstruosos...) + +## Alguns recursos úteis + + - [Site do Processing](http://processing.org) + - [Sketches em Processing](http://openprocessing.org) diff --git a/pt-br/pug-pt.html.markdown b/pt-br/pug-pt.html.markdown new file mode 100644 index 00000000..52eda86a --- /dev/null +++ b/pt-br/pug-pt.html.markdown @@ -0,0 +1,211 @@ +--- +language: Pug +contributors: + - ["Michael Warner", "https://github.com/MichaelJGW"] +filename: index-pt.pug +translators: + - ["Adaías Magdiel", "https://adaiasmagdiel.com/"] +lang: pt-br +--- + +## Começando com Pug + +Pug é uma pequena linguagem que compila para HTML. Possui uma sintaxe limpa +com algumas funcionalidades adicionais, como declarações if e loops. Também pode ser utilizada +como uma linguagem de templates no lado do servidor para tecnologias como o Node.js. + +### The Language +```pug + +//- Comentário de uma linha + +//- Comentário de + várias linhas + +//- ---TAGS--- +//- Básico +div +//- <div></div> +h1 +//- <h1></h1> +minha-propriaTag +//- <minha-propriaTag></minha-propriaTag> + +//- Tags irmãs +div +div +//- <div></div> + <div></div> + +//- Tags aninhadas +div + div +//- <div> + <div></div> + </div> + +//- Textos +h1 Olá, pessoas +//- <h1>Olá, pessoas</h1> + +//- Texto de várias linhas +div. + Oi, + tudo bem? +//- <div> + Oi, + tudo bem? + </div> + +//- ---ATRIBUTOS--- +div(class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled) +//- <div class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled></div> + +//- Abreviações +span.minha-class +//- <span class="minha-class"></span> +.minha-class +//- <div class="minha-class"></div> +div#meu-id +//- <div id="meu-id"></div> +div#meu-id.minha-class +//- <div class="minha-class" id="meu-id"></div> + + +//- ---JAVASCRIPT--- +- const lang = "pug"; + +//- Javascript em várias linhas +- + const lang = "pug"; + const awesome = true; + +//- Classes com Javascript +- const myClass = ['class1', 'class2', 'class3'] +div(class=myClass) +//- <div class="class1 class2 class3"></div> + +//- Estilos com Javascript +- const myStyles = {'color':'white', 'background-color':'blue'} +div(styles=myStyles) +//- <div styles="{"color":"white","background-color":"blue"}"></div> + +//- Atributos com Javascript +- const myAttributes = {"src": "photo.png", "alt": "My Photo"} +img&attributes(myAttributes) +//- <img src="photo.png" alt="My Photo"> +- let disabled = false +input(type="text" disabled=disabled) +//- <input type="text"> +- disabled = true +input(type="text" disabled=disabled) +//- <input type="text" disabled> + +//- Templates com Javascript +- const name = "Bob"; +h1 Olá, #{name} +h1= name +//- <h1>Olá, Bob</h1> +//- <h1>Bob</h1> + +//- ---LOOPS--- + +//- 'each' e 'for' tem a mesma função, aqui nós usaremos apenas 'each'. + +each value, i in [1,2,3] + p=value +//- + <p>1</p> + <p>2</p> + <p>3</p> + +each value, index in [1,2,3] + p=value + '-' + index +//- + <p>1-0</p> + <p>2-1</p> + <p>3-2</p> + +each value in [] + p=value +//- + +each value in [] + p=value +else + p Sem valores + +//- <p>Sem valores</p> + +//- ---CONDICIONAIS--- + +- const number = 5 +if number < 5 + p o número é menor do que 5 +else if number > 5 + p o número é maior do que 5 +else + p o número é 5 +//- <p>o número é 5</p> + +- const orderStatus = "Aguardando"; +case orderStatus + when "Aguardando" + p.warn Seu pedido está em espera + when "Completado" + p.success Seu pedido foi completado. + when -1 + p.error Ocorreu algum erro + default + p Nenhum registro de pedido encontrado +//- <p class="warn">Seu pedido está em espera</p> + +//- --INCLUINDO CONTEÚDOS-- +//- Caminho do arquivo -> "includes/nav.pug" +h1 Indústrias ACME +nav + a(href="index.html") Início + a(href="about.html") Sobre Nós + +//- Caminho do arquivo -> "index.pug" +html + body + include includes/nav.pug +//- + <html> + <body> + <h1>Indústrias ACME</h1> + <nav><a href="index.html">Início</a><a href="about.html">Sobre Nós</a></nav> + </body> + </html> + +//- Importando Javascript e CSS +script + include scripts/index.js +style + include styles/theme.css + +//- ---MIXIN--- +mixin basic + div Olá ++basic +//- <div>Olá</div> + +mixin comment(nome, comentario) + div + span.comment-name= nome + div.comment-text= comentario ++comment("Gil", "Tudo é divino, tudo é maravilhoso") +//- + <div> + <span class="comment-name">Gil</span> + <div class="comment-text">Tudo é divino, tudo é maravilhoso</div> + </div> + +``` + + +### Saiba Mais +- [Site Oficial](https://pugjs.org/) +- [Documentação](https://pugjs.org/api/getting-started.html) +- [Repositório no GitHub](https://github.com/pugjs/pug) diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown index 40fe82d5..42f744e2 100644 --- a/pt-br/pyqt-pt.html.markdown +++ b/pt-br/pyqt-pt.html.markdown @@ -24,7 +24,7 @@ o pyqt! ```python import sys from PyQt4 import QtGui - + def window(): # Cria um objeto para a aplicação app = QtGui.QApplication(sys.argv) @@ -54,7 +54,7 @@ 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 +```python import sys from PyQt4.QtGui import * from PyQt4.QtCore import * @@ -73,7 +73,7 @@ def window(): 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(): diff --git a/pt-br/pythonstatcomp-pt.html.markdown b/pt-br/pythonstatcomp-pt.html.markdown new file mode 100644 index 00000000..aa532eb4 --- /dev/null +++ b/pt-br/pythonstatcomp-pt.html.markdown @@ -0,0 +1,249 @@ +--- +category: tool +tool: Statistical Computing with Python +contributors: + - ["e99n09", "https://github.com/e99n09"] +translators: + - ["waltercjunior", "https://github.com/waltercjunior"] +filename: pythonstatcomp-pt.py +lang: pt-br +--- + +Este é um tutorial sobre como fazer algumas tarefas típicas de programação estatística usando Python. +É destinado basicamente à pessoas familizarizadas com Python e experientes com programação estatística em linguagens como R, +Stata, SAS, SPSS ou MATLAB. + +```python + + + +# 0. Preparando-se ==== + +""" Para começar, instale o seguinte : jupyther, numpy, scipy, pandas, + matplotlib, seaborn, requests. + Certifique-se de executar este tutorial utilizando o Jupyther notebook para + que você utilize os gráficos embarcados e ter uma fácil consulta à + documentação. + O comando para abrir é simplesmente '`jupyter notebook`, quando abrir então + clique em 'New -> Python'. +""" + +# 1. Aquisição de dados ==== + +""" A única razão das pessoas optarem por Python no lugar de R é que pretendem + interagir com o ambiente web, copiando páginas diretamente ou solicitando + dados utilizando uma API. Você pode fazer estas coisas em R, mas no + contexto de um projeto já usando Python, há uma vantagem em se ater uma + linguágem única. +""" + +import requests # para requisições HTTP (web scraping, APIs) +import os + +# web scraping +r = requests.get("https://github.com/adambard/learnxinyminutes-docs") +r.status_code # se retornou código 200, a requisição foi bem sucedida +r.text # código fonte bruto da página +print(r.text) # formatado bonitinho +# salve a o código fonte d apágina em um arquivo: +os.getcwd() # verifique qual é o diretório de trabalho +with open("learnxinyminutes.html", "wb") as f: + f.write(r.text.encode("UTF-8")) + +# Baixar um arquivo csv +fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/" +fn = "pets.csv" +r = requests.get(fp + fn) +print(r.text) +with open(fn, "wb") as f: + f.write(r.text.encode("UTF-8")) + +""" para mais informações sobre o módulo de solicitações, incluindo API's, veja em + http://docs.python-requests.org/en/latest/user/quickstart/ +""" + +# 2. Lendo um arquivo formato CSV ==== + +""" Um pacote de pandas da Wes McKinney lhe dá um objeto 'DataFrame' em Python. + Se você já usou R, já deve estar familiarizado com a ideia de "data.frame". +""" + +import pandas as pd +import numpy as np +import scipy as sp +pets = pd.read_csv(fn) +pets +# name age weight species +# 0 fluffy 3 14 cat +# 1 vesuvius 6 23 fish +# 2 rex 5 34 dog + +""" Usuários R: observe que o Python, como a maioria das linguagens de programação + influenciada pelo C, a indexação começa de 0. Em R, começa a indexar em 1 + devido à influência do Fortran. +""" + +# duas maneiras diferentes de imprimir uma coluna +pets.age +pets["age"] + +pets.head(2) # imprima as 2 primeiras linhas +pets.tail(1) # imprima a última linha + +pets.name[1] # 'vesuvius' +pets.species[0] # 'cat' +pets["weight"][2] # 34 + +# Em R, você esperaria obter 3 linhas fazendo isso, mas aqui você obtem 2: +pets.age[0:2] +# 0 3 +# 1 6 + +sum(pets.age) * 2 # 28 +max(pets.weight) - min(pets.weight) # 20 + +""" Se você está fazendo alguma álgebra linear séria e processamento de + números você pode desejar apenas arrays, não DataFrames. DataFrames são + ideais para combinar colunas de diferentes tipos de dados. +""" + +# 3. Gráficos ==== + +import matplotlib as mpl +import matplotlib.pyplot as plt +%matplotlib inline + +# Para fazer a visualiação de dados em Python, use matplotlib + +plt.hist(pets.age); + +plt.boxplot(pets.weight); + +plt.scatter(pets.age, pets.weight) +plt.xlabel("age") +plt.ylabel("weight"); + +# seaborn utiliza a biblioteca do matplotlib e torna os enredos mais bonitos + +import seaborn as sns + +plt.scatter(pets.age, pets.weight) +plt.xlabel("age") +plt.ylabel("weight"); + +# também existem algumas funções de plotagem específicas do seaborn +# observe como o seaborn automaticamenteo o eixto x neste gráfico de barras +sns.barplot(pets["age"]) + +# Veteranos em R ainda podem usar o ggplot +from ggplot import * +ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets") +# fonte: https://pypi.python.org/pypi/ggplot + +# há até um d3.js veja em: https://github.com/mikedewar/d3py + +# 4. Limpeza de dados simples e análise exploratória ==== + +""" Aqui está um exemplo mais complicado que demonstra dados básicos + fluxo de trabalho de limpeza levando à criação de algumas parcelas + e a execução de uma regressão linear. + O conjunto de dados foi transcrito da Wikipedia à mão. Contém + todos os sagrados imperadores romanos e os marcos importantes em suas vidas + (birth, death, coronation, etc.). + O objetivo da análise será explorar se um relacionamento existe + entre o ano de nascimento (birth year) e a expectativa de vida (lifespam) + do imperador. + Fonte de dados: https://en.wikipedia.org/wiki/Holy_Roman_Emperor +""" + +# carregue alguns dados dos sagrados imperadores romanos +url = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/hre.csv" +r = requests.get(url) +fp = "hre.csv" +with open(fp, "wb") as f: + f.write(r.text.encode("UTF-8")) + +hre = pd.read_csv(fp) + +hre.head() +""" + Ix Dynasty Name Birth Death +0 NaN Carolingian Charles I 2 April 742 28 January 814 +1 NaN Carolingian Louis I 778 20 June 840 +2 NaN Carolingian Lothair I 795 29 September 855 +3 NaN Carolingian Louis II 825 12 August 875 +4 NaN Carolingian Charles II 13 June 823 6 October 877 + + Coronation 1 Coronation 2 Ceased to be Emperor +0 25 December 800 NaN 28 January 814 +1 11 September 813 5 October 816 20 June 840 +2 5 April 823 NaN 29 September 855 +3 Easter 850 18 May 872 12 August 875 +4 29 December 875 NaN 6 October 877 +""" + +# limpar as colunas Birth e Death + +import re # módulo para expressões regulares + +rx = re.compile(r'\d+$') # conincidir com os códigos finais + +""" Esta função aplia a expressão reguar a uma coluna de entrada (here Birth, + Death), nivela a lista resultante, converte-a em uma lista de objetos, e + finalmente converte o tipo do objeto da lista de String para inteiro. para + mais informações sobre o que as diferentes partes do código fazer, veja em: + - https://docs.python.org/2/howto/regex.html + - http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list + - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html +""" + +from functools import reduce + +def extractYear(v): + return(pd.Series(reduce(lambda x, y: x + y, map(rx.findall, v), [])).astype(int)) + +hre["BirthY"] = extractYear(hre.Birth) +hre["DeathY"] = extractYear(hre.Death) + +# faça uma coluna infomrnado a idade estimada ("EstAge") +hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int) + +# gráfico de dispersão simples, sem linha de tendência, cor representa dinastia +sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False) + +# use o scipy para executar uma regrassão linear +from scipy import stats +(slope, intercept, rval, pval, stderr) = stats.linregress(hre.BirthY, hre.EstAge) +# código fonte: http://wiki.scipy.org/Cookbook/LinearRegression + +# varifique o declive (slope) +slope # 0.0057672618839073328 + +# varifique o valor R^2: +rval**2 # 0.020363950027333586 + +# varifique o valor p-value +pval # 0.34971812581498452 + +# use o seaborn para fazer um gráfico de dispersão e traçar a linha de tendência de regrassão linear +sns.lmplot("BirthY", "EstAge", data=hre) + +""" Para mais informações sobre o seaborn, veja + - http://web.stanford.edu/~mwaskom/software/seaborn/ + - https://github.com/mwaskom/seaborn + Para mais informações sobre o SciPy, veja + - http://wiki.scipy.org/SciPy + - http://wiki.scipy.org/Cookbook/ + Para ver uma versão da análise dos sagrados imperadores romanos usando R, consulte + - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R +""" + +``` + +Se você quiser saber mais, obtenha o Python para análise de dados de Wes McKinney. É um excelente recurso e usei-o como referência ao escrever este tutorial. + +Você também pode encontrar muitos tutoriais interativos de IPython sobre assuntos específicos de seus interesses, como Cam Davidson-Pilon's <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Programação Probabilística e Métodos Bayesianos para Hackers">Programação Probabilística e Métodos Bayesianos para Hackers</a>. + +Mais alguns módulos para pesquisar: + - análise de texto e processamento de linguagem natural: nltk, http://www.nltk.org + - análise de rede social: igraph, http://igraph.org/python/ diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown index 99579c35..f4211e09 100644 --- a/pt-br/qt-pt.html.markdown +++ b/pt-br/qt-pt.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-pt.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] diff --git a/pt-br/r-pt.html.markdown b/pt-br/r-pt.html.markdown new file mode 100644 index 00000000..5c9304ec --- /dev/null +++ b/pt-br/r-pt.html.markdown @@ -0,0 +1,786 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] + - ["kalinn", "http://github.com/kalinn"] +translators: + - ["Marcel Ribeiro-Dantas", "http://github.com/mribeirodantas"] +lang: pt-br +filename: learnr-pt.r +--- + +R é uma linguagem de programação estatística. Ela tem muitas bibliotecas para carregar e limpar conjuntos de dados, executar análises estatísticas e produzir gráficos. Você também pode executar comandos do `R` dentro de um documento LaTeX. + +```r + +# Comentários começam com o símbolo de Cerquilha, também conhecido como +# jogo da velha + +# Não existe um símbolo especial para comentários em várias linhas +# mas você pode escrever várias linhas de comentários adicionando a +# cerquilha (#) ao início de cada uma delas. + +# No Windows e Linux, você pode usar CTRL-ENTER para executar uma linha. +# No MacOS, o equivalente é COMMAND-ENTER + + + +############################################################################# +# Coisas que você pode fazer sem entender nada sobre programação +############################################################################# + +# Nesta seção, mostramos algumas das coisas legais que você pode fazer em +# R sem entender nada de programação. Não se preocupe em entender tudo o +# que o código faz. Apenas aproveite! + +data() # navegue pelos conjuntos de dados pré-carregados +data(rivers) # carregue este: "Comprimentos dos principais rios norte-americanos" +ls() # observe que "rivers" apareceu na área de trabalho (workspace) +head(rivers) # dê uma espiada no conjunto de dados +# 735 320 325 392 524 450 + +length(rivers) # quantos rios foram medidos? +# 141 +summary(rivers) # consulte um sumário de estatísticas básicas +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + +# faça um diagrama de ramos e folhas (uma visualização de dados semelhante a um histograma) +stem(rivers) + +# A vírgula está 2 dígito(s) à direita do símbolo | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + +stem(log(rivers)) # Observe que os dados não são normais nem log-normais! +# Tome isso, fundamentalistas da curva normal! + +# O ponto decimal está 1 dígito(s) à esquerda do símbolo | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# faça um histograma: +hist(rivers, col="#333333", border="white", breaks=25) # brinque com estes parâmetros +hist(log(rivers), col="#333333", border="white", breaks=25) # você fará mais gráficos mais tarde + +# Aqui está outro conjunto de dados que vem pré-carregado. O R tem toneladas deles. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Ano", + main="Número de descobertas importantes por ano") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Ano", + main="Número de descobertas importantes por ano") + +# Em vez de deixar a ordenação padrão (por ano), +# também podemos ordenar para ver o que é mais comum: +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) +# +# O ponto decimal está no símbolo | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + +# Role um dado algumas vezes +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# Seus números serão diferentes dos meus, a menos que definamos a mesma semente aleatória com o set.seed + +# Obtenha 9 números de forma aleatória a partir de uma distribuição normal +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +################################################## +# Tipos de dados e aritmética básica +################################################## + +# Agora para a parte orientada a programação do tutorial. +# Nesta seção você conhecerá os tipos de dados importantes do R: +# integers, numerics, characters, logicals, e factors. +# Existem outros, mas estes são o mínimo que você precisa para +# iniciar. + +# INTEGERS +# Os inteiros de armazenamento longo são escritos com L +5L # 5 +class(5L) # "integer" +# (Experimente ?class para obter mais informações sobre a função class().) +# Em R, todo e qualquer valor, como 5L, é considerado um vetor de comprimento 1 +length(5L) # 1 +# Você pode ter um vetor inteiro com comprimento > 1 também: +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + +# NUMERICS +# Um "numeric" é um número de ponto flutuante de precisão dupla +5 # 5 +class(5) # "numeric" +# De novo, tudo em R é um vetor; +# você pode fazer um vetor numérico com mais de um elemento +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# Você também pode usar a notação científica +5e4 # 50000 +6.02e23 # Número de Avogadro +1.6e-35 # Comprimento de Planck +# Você também pode ter números infinitamente grandes ou pequenos +class(Inf) # "numeric" +class(-Inf) # "numeric" +# Você pode usar "Inf", por exemplo, em integrate(dnorm, 3, Inf) +# isso evita as tabelas de escores-Z. + +# ARITMÉTICA BÁSICA +# Você pode fazer aritmética com números +# Fazer aritmética com uma mistura de números inteiros (integers) e com +# ponto flutuante (numeric) resulta em um numeric +10L + 66L # 76 # integer mais integer resulta em integer +53.2 - 4 # 49.2 # numeric menos numeric resulta em numeric +2.0 * 2L # 4 # numeric vezes integer resulta em numeric +3L / 4 # 0.75 # integer dividido por numeric resulta em numeric +3 %% 2 # 1 # o resto de dois numeric é um outro numeric +# Aritmética ilegal produz um "não-é-um-número" (do inglês Not-a-Number): +0 / 0 # NaN +class(NaN) # "numeric" +# Você pode fazer aritmética em dois vetores com comprimento maior que 1, +# desde que o comprimento do vetor maior seja um múltiplo inteiro do menor +c(1,2,3) + c(1,2,3) # 2 4 6 +# Como um único número é um vetor de comprimento um, escalares são aplicados +# elemento a elemento com relação a vetores +(4 * c(1,2,3) - 2) / 2 # 1 3 5 +# Exceto para escalares, tenha cuidado ao realizar aritmética em vetores com +# comprimentos diferentes. Embora possa ser feito, +c(1,2,3,1,2,3) * c(1,2) # 1 4 3 2 2 6 +# ter comprimentos iguais é uma prática melhor e mais fácil de ler +c(1,2,3,1,2,3) * c(1,2,1,2,1,2) + +# CHARACTERS +# Não há diferença entre strings e caracteres em R +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# São ambos vetores de caracteres de comprimento 1 +# Aqui está um mais longo: +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# Você pode utilizar expressões regulares (regex) em vetores de caracteres: +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# R tem vários vetores de caracteres embutidos: +letters +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + +# LOGICALS +# Em R, um "logical" é um booleano +class(TRUE) # "logical" +class(FALSE) # "logical" +# O comportamento deles é normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# Dados ausentes (NA) são logical, também +class(NA) # "logical" +# Use | e & para operações lógicas. +# OR +TRUE | FALSE # TRUE +# AND +TRUE & FALSE # FALSE +# Aplicar | e & a vetores retorna operações lógicas elemento a elemento +c(TRUE,FALSE,FALSE) | c(FALSE,TRUE,FALSE) # TRUE TRUE FALSE +c(TRUE,FALSE,TRUE) & c(FALSE,TRUE,TRUE) # FALSE FALSE TRUE +# Você pode testar se x é TRUE +isTRUE(TRUE) # TRUE +# Aqui obtemos um vetor logical com muitos elementos: +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE + +# FACTORS +# A classe factor é para dados categóricos +# Os fatores podem ser ordenados (como as avaliações de crianças) ou +# não ordenados (como as cores) +factor(c("azul", "azul", "verde", NA, "azul")) +# azul azul verde <NA> azul +# Levels: azul verde +# Os "levels" são os valores que os dados categóricos podem assumir +# Observe que os dados ausentes não entram nos levels +levels(factor(c("verde", "verde", "azul", NA, "azul"))) # "azul" "verde" +# Se um vetor de factor tem comprimento 1, seus levels também terão comprimento 1 +length(factor("green")) # 1 +length(levels(factor("green"))) # 1 +# Os fatores são comumente vistos em data frames, uma estrutura de dados que abordaremos +# mais tarde +data(infert) # "Infertilidade após aborto espontâneo e induzido" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + +# NULL +# "NULL" é um valor estranho; use-o para "apagar" um vetor +class(NULL) # NULL +parakeet = c("bico", "penas", "asas", "olhos") +parakeet +# [1] "bico" "penas" "asas" "olhos" +parakeet <- NULL +parakeet +# NULL + +# COERÇÃO DE TIPO +# Coerção de tipo é quando você força um valor a assumir um tipo diferente +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# Se você colocar elementos de diferentes tipos em um vetor, coerções estranhas acontecem: +c(TRUE, 4) # 1 4 +c("cachorro", TRUE, 4) # "cachorro" "TRUE" "4" +as.numeric("Bilbo") +# [1] NA +# Warning message: +# NAs introduced by coercion + +# Observe também: esses são apenas os tipos de dados básicos +# Existem muitos outros tipos de dados, como datas, séries temporais, etc. + + + +################################################## +# Variáveis, laços, expressões condicionais +################################################## + +# Uma variável é como uma caixa na qual você armazena um valor para uso posterior. +# Chamamos isso de "atribuir" o valor à variável. +# Ter variáveis nos permite escrever laços, funções e instruções com condição + +# VARIÁVEIS +# Existem muitas maneiras de atribuir valores: +x = 5 # é possível fazer assim +y <- "1" # mas é preferível fazer assim +TRUE -> z # isso funciona, mas é estranho + +# LAÇOS +# Nós temos laços com for +for (i in 1:4) { + print(i) +} +# [1] 1 +# [1] 2 +# [1] 3 +# [1] 4 +# Nós temos laços com while +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} +# 10...9...8...7...6...5... +# Tenha em mente que os laços for e while são executados lentamente em R +# Operações em vetores inteiros (por exemplo, uma linha inteira, uma coluna inteira) +# ou funções do tipo apply() (discutiremos mais tarde) são mais indicadas + +# IF/ELSE +# Novamente, bastante padrão +if (4 > 3) { + print("4 é maior que 3") +} else { + print("4 não é maior que 3") +} +# [1] "4 é maior que 3" + +# FUNÇÕES +# Definidas assim: +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) # adicione um pouco de ruído (controlado) + return(x) +} +# Chamada como qualquer outra função R: +jiggle(5) # 5±ε. Após set.seed(2716057), jiggle(5)==5.005043 + + + +########################################################################### +# Estruturas de dados: Vetores, matrizes, data frames e arranjos (arrays) +########################################################################### + +# UNIDIMENSIONAL + +# Vamos começar do início, e com algo que você já sabe: vetores. +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# Consultamos elementos específicos utilizando colchetes +# (Observe que R começa a contar a partir de 1) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 +# Também podemos pesquisar os índices de componentes específicos, +which(vec %% 2 == 0) # 1 3 +# pegue apenas as primeiras ou últimas entradas no vetor, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ou descubra se um determinado valor está no vetor +any(vec == 10) # TRUE +# Se um índice for além do comprimento de um vetor, você obterá NA: +vec[6] # NA +# Você pode encontrar o comprimento do seu vetor com length() +length(vec) # 4 +# Você pode realizar operações em vetores inteiros ou subconjuntos de vetores +vec * 4 # 32 36 40 44 +vec[2:3] * 5 # 45 50 +any(vec[2:3] == 8) # FALSE +# e R tem muitas funções internas para sumarizar vetores +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Mais alguns recursos embutidos: +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +# BIDIMENSIONAL (ELEMENTOS DA MESMA CLASSE) + +# Você pode fazer uma matriz com entradas do mesmo tipo assim: +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Ao contrário de um vetor, a classe de uma matriz é "matrix" independente do que ela contém +class(mat) # "matrix" +# Consulte a primeira linha +mat[1,] # 1 4 +# Execute uma operação na primeira coluna +3 * mat[,1] # 3 6 9 +# Consulte uma célula específica +mat[3,2] # 6 + +# Transponha toda a matriz +t(mat) +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# Multiplicação de matrizes +mat %*% t(mat) +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + +# cbind() une vetores em colunas para formar uma matriz +mat2 <- cbind(1:4, c("cachorro", "gato", "passaro", "cachorro")) +mat2 +# [,1] [,2] +# [1,] "1" "cachorro" +# [2,] "2" "gato" +# [3,] "3" "passaro" +# [4,] "4" "cachorro" +class(mat2) # matrix +# Mais uma vez, observe o que aconteceu! +# Como as matrizes devem conter todas as entradas da mesma classe, +# tudo foi convertido para a classe character +c(class(mat2[,1]), class(mat2[,2])) + +# rbind() une vetores linha a linha para fazer uma matriz +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# Ah, tudo da mesma classe. Sem coerções. Muito melhor. + +# BIDIMENSIONAL (CLASSES DIFERENTES) + +# Para colunas de tipos diferentes, use um data frame +# Esta estrutura de dados é tão útil para programação estatística, +# que uma versão dela foi adicionada ao Python através do pacote "pandas". + +estudantes <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(estudantes) <- c("nome", "ano", "casa") # nomeie as colunas +class(estudantes) # "data.frame" +estudantes +# nome ano casa +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(estudantes$ano) # "numeric" +class(estudantes[,3]) # "factor" +# encontre as dimensões +nrow(estudantes) # 6 +ncol(estudantes) # 3 +dim(estudantes) # 6 3 +# A função data.frame() converte vetores de caracteres em vetores de fator +# por padrão; desligue isso definindo stringsAsFactors = FALSE quando +# você criar um data frame +?data.frame + +# Existem muitas maneiras particulares de consultar partes de um data frame, +# todas sutilmente diferentes +estudantes$ano # 3 2 2 1 0 -1 +estudantes[,2] # 3 2 2 1 0 -1 +estudantes[,"ano"] # 3 2 2 1 0 -1 + +# Uma versão extendida da estrutura data.frame é a data.table +# Se você estiver trabalhando com dados enormes ou em painel, ou precisar mesclar +# alguns conjuntos de dados, data.table pode ser uma boa escolha. Aqui está um tour +# relâmpago: +install.packages("data.table") # baixe o pacote a partir do CRAN +require(data.table) # carregue ele +estudantes <- as.data.table(estudantes) +estudantes # observe a saída ligeiramente diferente +# nome ano casa +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +estudantes[nome=="Ginny"] # Consulte estudantes com o nome == "Ginny" +# nome ano casa +# 1: Ginny -1 G +estudantes[ano==2] # Consulte estudantes com o ano == 2 +# nome ano casa +# 1: Fred 2 G +# 2: George 2 G +# data.table facilita a fusão de dois conjuntos de dados +# vamos fazer outro data.table para mesclar com os alunos +fundadores <- data.table(casa=c("G","H","R","S"), + fundador=c("Godric","Helga","Rowena","Salazar")) +fundadores +# casa fundador +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(estudantes, casa) +setkey(fundadores, casa) +estudantes <- fundadores[estudantes] # mescle os dois conjuntos de dados com base na "casa" +setnames(estudantes, c("casa","nomeFundadorCasa","nomeEstudante","ano")) +estudantes[,order(c("nome","ano","casa","nomeFundadorCasa")), with=F] +# nomeEstudante ano casa nomeFundadorCasa +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# O data.table torna as tabelas de sumário fáceis +estudantes[,sum(ano),by=casa] +# casa V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# Para remover uma coluna de um data.frame ou data.table, +# atribua a ela o valor NULL +estudantes$nomeFundadorCasa <- NULL +estudantes +# nomeEstudante ano casa +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Remova uma linha consultando parte dos dados +# Usando data.table: +estudantes[nomeEstudante != "Draco"] +# casa estudanteNome ano +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# Usando data.frame: +estudantes <- as.data.frame(estudantes) +estudantes[estudantes$casa != "G",] +# casa nomeFundadorCasa nomeEstudante ano +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + +# MULTIDIMENSIONAL (TODOS OS ELEMENTOS DE UM TIPO) + +# Arranjos (arrays) criam tabelas n-dimensionais +# Todos os elementos devem ser do mesmo tipo +# Você pode fazer uma tabela bidimensional (como uma matriz) +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# Você pode usar array para fazer matrizes tridimensionais também +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +# LISTAS (MULTIDIMENSIONAIS, POSSIVELMENTE IMPERFEITAS, DE DIFERENTES TIPOS) + +# Finalmente, R tem listas (de vetores) +lista1 <- list(tempo = 1:40) +lista1$preco = c(rnorm(40,.5*lista1$tempo,4)) # aleatória +lista1 +# Você pode obter itens na lista assim +lista1$tempo # um modo +lista1[["tempo"]] # um outro modo +lista1[[1]] # e ainda um outro modo +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# Você pode obter itens de uma lista como qualquer outro vetor +lista1$preco[4] + +# Listas não são a estrutura de dados mais eficiente para se trabalhar em R; +# a menos que você tenha um bom motivo, você deve se ater a data.frames +# As listas geralmente são retornadas por funções que realizam regressões lineares + +################################################## +# A família de funções apply() +################################################## + +# Lembra de mat? +mat +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Use apply(X, MARGIN, FUN) para aplicar a função FUN a uma matriz X +# sobre linhas (MARGIN = 1) ou colunas (MARGIN = 2) +# Ou seja, R faz FUN para cada linha (ou coluna) de X, muito mais rápido que um +# laço for ou while faria +apply(mat, MAR = 2, jiggle) +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# Outras funções: ?lappy, ?sapply + +# Não as deixe te intimidar; todos concordam que essas funções são bem confusas + +# O pacote plyr visa substituir (e melhorar!) a família *apply(). +install.packages("plyr") +require(plyr) +?plyr + + + +######################### +# Carregando dados +######################### + +# "pets.csv" é um arquivo hospedado na internet +# (mas também poderia tranquilamente ser um arquivo no seu computador) +require(RCurl) +pets <- read.csv(textConnection(getURL("https://learnxinyminutes.com/docs/pets.csv"))) +pets +head(pets, 2) # primeiras duas linhas +tail(pets, 1) # última linha + +# Para salvar um data frame ou matriz como um arquivo .csv: +write.csv(pets, "pets2.csv") # para criar um novo arquivo .csv +# Define o diretório de trabalho com setwd(), confirme em qual você está com getwd() + +# Experimente ?read.csv e ?write.csv para obter mais informações + + + +######################### +# Análise estatística +######################### + +# Regressão linear! +modeloLinear <- lm(preco ~ tempo, data = lista1) +modeloLinear # imprime na tela o resultado da regressão +# Call: +# lm(formula = preco ~ tempo, data = lista1) +# +# Coefficients: +# (Intercept) tempo +# 0.1453 0.4943 +summary(modeloLinear) # saída mais detalhada da regressão +# Call: +# lm(formula = preco ~ tempo, data = lista1) +# +# Residuals: +# Min 1Q Median 3Q Max +# -8.3134 -3.0131 -0.3606 2.8016 10.3992 +# +# Coefficients: +# Estimate Std. Error t value Pr(>|t|) +# (Intercept) 0.14527 1.50084 0.097 0.923 +# tempo 0.49435 0.06379 7.749 2.44e-09 *** +# --- +# Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 +# +# Residual standard error: 4.657 on 38 degrees of freedom +# Multiple R-squared: 0.6124, Adjusted R-squared: 0.6022 +# F-statistic: 60.05 on 1 and 38 DF, p-value: 2.44e-09 +coef(modeloLinear) # extrai os parâmetros estimados +# (Intercept) tempo +# 0.1452662 0.4943490 +summary(modeloLinear)$coefficients # um outro meio de extrair os resultados +# Estimate Std. Error t value Pr(>|t|) +# (Intercept) 0.1452662 1.50084246 0.09678975 9.234021e-01 +# tempo 0.4943490 0.06379348 7.74920901 2.440008e-09 +summary(modeloLinear)$coefficients[,4] # the p-values +# (Intercept) tempo +# 9.234021e-01 2.440008e-09 + +# MODELOS LINEARES GERAIS +# Regressão logística +set.seed(1) +lista1$sucesso = rbinom(length(lista1$tempo), 1, .5) # binário aleatório +modeloLg <- glm(sucesso ~ tempo, data = lista1, + family=binomial(link="logit")) +modeloLg # imprime na tela o resultado da regressão logística +# Call: glm(formula = sucesso ~ tempo, +# family = binomial(link = "logit"), data = lista1) +# +# Coefficients: +# (Intercept) tempo +# 0.17018 -0.01321 +# +# Degrees of Freedom: 39 Total (i.e. Null); 38 Residual +# Null Deviance: 55.35 +# Residual Deviance: 55.12 AIC: 59.12 +summary(modeloLg) # saída mais detalhada da regressão +# Call: +# glm(formula = sucesso ~ tempo, +# family = binomial(link = "logit"), data = lista1) + +# Deviance Residuals: +# Min 1Q Median 3Q Max +# -1.245 -1.118 -1.035 1.202 1.327 +# +# Coefficients: +# Estimate Std. Error z value Pr(>|z|) +# (Intercept) 0.17018 0.64621 0.263 0.792 +# tempo -0.01321 0.02757 -0.479 0.632 +# +# (Dispersion parameter for binomial family taken to be 1) +# +# Null deviance: 55.352 on 39 degrees of freedom +# Residual deviance: 55.121 on 38 degrees of freedom +# AIC: 59.121 +# +# Number of Fisher Scoring iterations: 3 + + +######################### +# Gráficos +######################### + +# FUNÇÕES DE PLOTAGEM INTEGRADAS +# Gráficos de dispersão! +plot(lista1$tempo, lista1$preco, main = "dados falsos") +# Trace a linha de regressão em um gráfico existente! +abline(modeloLinear, col = "red") +# Obtenha uma variedade de diagnósticos legais +plot(modeloLinear) +# Histogramas! +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# Gráficos de barras! +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + +# GGPLOT2 +# Mas estes não são nem os mais bonitos dos gráficos no R +# Experimente o pacote ggplot2 para gráficos diferentes e mais bonitos +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(estudantes, aes(x=casa)) +pp + geom_bar() +ll <- as.data.table(lista1) +pp <- ggplot(ll, aes(x=tempo,preco)) +pp + geom_point() +# ggplot2 tem uma excelente documentação (disponível em http://docs.ggplot2.org/current/) + + + +``` + +## Como faço para obter R? + +* Obtenha o R e uma interface gráfica para o R em [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) é uma outra interface gráfica diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown index b2bab214..1080baa4 100644 --- a/pt-br/rust-pt.html.markdown +++ b/pt-br/rust-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: rust +language: Rust filename: rust-pt.rs contributors: - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"] @@ -234,7 +234,7 @@ fn main() { // `for` laços de repetição/iteração let array = [1, 2, 3]; - for i in array.iter() { + for i in array { println!("{}", i); } @@ -329,4 +329,3 @@ 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 index 28df3c59..e5175857 100644 --- a/pt-br/sass-pt.html.markdown +++ b/pt-br/sass-pt.html.markdown @@ -4,6 +4,7 @@ filename: learnsass-pt.scss contributors: - ["Laura Kyle", "https://github.com/LauraNK"] - ["Sean Corrales", "https://github.com/droidenator"] + - ["Thalles Augusto", "https://github.com/Theslladev"] translators: - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"] - ["Cássio Böck", "https://github.com/cassiobsilva"] @@ -16,7 +17,7 @@ Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os d 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. +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 facilmente. ```scss @@ -249,7 +250,7 @@ ul { /* '&' será substituído pelo selector pai (parent). */ /* 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. +Essas práticas também recomendam não mais de 3 níveis de profundidade quando nidificação. Por exemplo: */ @@ -379,7 +380,7 @@ body { /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem ser úteis para calcular os valores diretamente no seu arquivos Sass em vez - de usar valores que você já calculados manualmente. O exemplo abaixo é + de usar valores que você já calcula manualmente. O exemplo abaixo é de um projeto simples de duas colunas. */ $content-area: 960px; diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown index eb821474..0fadf58d 100644 --- a/pt-br/self-pt.html.markdown +++ b/pt-br/self-pt.html.markdown @@ -117,6 +117,7 @@ Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente. ``` Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos: + ``` "retorna 0" [|x| diff --git a/pt-br/set-theory-pt.html.markdown b/pt-br/set-theory-pt.html.markdown new file mode 100644 index 00000000..58fd7979 --- /dev/null +++ b/pt-br/set-theory-pt.html.markdown @@ -0,0 +1,129 @@ +--- +category: Algorithms & Data Structures +name: Set theory +lang: pt-br +contributors: + - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"] +translators: + - ["Bárbara Luz", "https://github.com/barbluz"] +--- + +Teoria de conjuntos é uma área da matemática que estuda conjuntos, suas operações e propriedades. +- Um conjunto é uma coleção de itens disjuntos. + +## Símbolos básicos + +### Operações +- a operação de união `∪`, significa "ou" +- a operação de interseção `∩`, que significa "e" +- a operação de exclusão `\`, significa "sem" ou "menos" +- a operação de conjunto complementar `'`, que significa "o inverso de" +- a operação de produto cartesiano `×`,que significa "o produto cartesiano de" + +### Outros símbolos +- `:` ou `|`, símbolos que significam "tal que" +- o símbolo de pertencimento `∈`, que significa "pertence a" +- o símbolo `⊆`, que significa "subconjunto de" (neste caso, o subconjunto pode ser igual ao conjunto) +- o símbolo `⊂`, que significa "subconjunto próprio" (neste caso, o subconjunto não pode ser igual ao conjunto) + +### Conjuntos canônicos +- `∅`, o conjunto vazio, isto é, o conjunto que não possui itens +- `ℕ`, o conjunto de todos os números naturais +- `ℤ`, o conjunto de todos os números inteiros +- `ℚ`, o conjunto de todos os números racionais +- `ℝ`, o conjunto de todos os números reais + +Existem algumas ressalvas sobre os conjuntos canônicos: +- Apesar de o conjunto vazio não conter itens, o conjunto vazio é subconjunto de si mesmo (e portanto de todos os outros conjuntos) +- Matemáticos geralmente não concordam sobre o zero ser um número natural e os livros tipicamente explicitam se o autor considera ou não o zero como um número natural + + +### Cardinalidade +A cardinalidade (ou tamanho) de um conjunto é determinado pela quantidade de itens no conjunto. O operador de cardinalidade é `|...|` + +Por exemplo, se `S = {1, 2, 4}`, então `|S| = 3`. + +### O Conjunto Vazio +- o conjunto vazio pode ser contruído em notação de conjuntos utilizando condições impossíveis, como por exemplo: `∅ = { x : x ≠ x }`, ou `∅ = { x : x ∈ N, x < 0 }` +- o conjunto vazio é sempre único (ou seja, existe um e apenas um conjunto vazio) +- o conjunto vazio é subconjunto de todos os conjuntos +- a cardinalidade do conjunto vazio é `0`, ou seja, `|∅| = 0`. + +## Representando conjuntos + +### Definição Literal +Um conjunto pode ser contruído literalmente fornecendo uma lista completa dos itens contigos no conjunto. Por exemplo `S = { a, b, c, d }` + +Listas longas podem ser encurtadas com reticências, desde que o contexto seja claro. Por exemplo, `E = { 2, 4, 6, 8, ... }` é claramente o conjunto de todos os números pares, contendo um número infinito de objetos, embora só tenhamos escrito explicitamente quatro deles. + +### Definição por compreensão +Conjuntos também podem ser descritos de uma maneira mais descritiva, baseando-se em sujeito e predicado, de forma tal que `S = {sujeito : predicado}`. Por exemplo: + +``` +A = { x : x é uma vogal } = { a, e, i, o, u } (lê-se x, tal que x é uma vogal) +B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } +C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... } +``` + +Ou pode-se também aplicar uma função ao sujeito, ex: +``` +D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... } +``` + +## Relações + +### Pertencimento +- Se um valor `a` está contido num conjunto `A`, então dizemos que `a` pertence a `A` e denotamos por `a ∈ A` +- Se o valor `a` não está contido no conjunto `A`, então dizemos que `a` não pertence a `A` e denotamos por `a ∉ A` + +### Igualdade +- Se dois conjuntos contém os mesmos itens, então dizemos que os conjuntos são iguals, ex. `A = B` +- A ordenação não importa quando vamos avaliar a igualdade, ex: `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }` +- Conjuntos são disjuntos, o que significa que os elementos não podem ser repetidos, ex: `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }` +- Dois conjuntos `A` e `B` são iguais se, e somente se, `A ⊆ B` e `B ⊆ A` + +### Conjuntos especiais +O Conjunto das Partes +- Seja `A` um conjunto qualquer. O conjunto que contém todos os possíveis subconjuntos de `A` é chamado "conjunto das partes" e é denotado como `P(A)`. Se o conjunto `A` contém `n` elementos, então o conjunto das partes conterá `2^n` elementos. +``` +P(A) = { x : x ⊆ A } +``` + +## Operações entre dois conjuntos + +### União +Dados dois conjuntos `A` e `B`, a união entre esses dois conjuntos são os itens que aparecem em `A` ou em `B`, denotado por `A ∪ B`. + +``` +A ∪ B = { x : x ∈ A ∪ x ∈ B } +``` + +### Interseção +Dados dois conjuntos `A` e `B`, a interseção entre esses dois conjuntos são os itens que aparecem em `A` e em `B`, denotado por `A ∩ B`. + +``` +A ∩ B = { x : x ∈ A, x ∈ B } +``` + +### Diferença +Dados dois conjuntos `A` e `B`, o conjunto da diferença entre `A` e `B` são todos os itens de `A` que não pertencem a `B`. +``` +A \ B = { x : x ∈ A, x ∉ B } +``` + +### Diferença simétrica +Dados dois conjuntos `A` e `B`, a diferença simétrica são todos os itens entre `A` e `B` que não aparecem na interseção desses dois conjuntos. + +``` +A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) } + +A △ B = (A \ B) ∪ (B \ A) +``` + +### Produto Cartesiano +Dados dois conjuntos `A` e `B`, o produto cartesiano de `A` e `B` consiste no conjunto contendo todas as combinações dos itens de `A` e `B`. +``` +A × B = { (x, y) | x ∈ A, y ∈ B } +``` + + diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown index d4555fa7..c77ff298 100644 --- a/pt-br/solidity-pt.html.markdown +++ b/pt-br/solidity-pt.html.markdown @@ -259,7 +259,7 @@ 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 +uint[][5] x; // array com 5 arrays dinâmicos como elementos (ordem da maioria // das linguagens) // Dicionários (qualquer tipo para qualquer tipo) diff --git a/pt-br/sql-pt.html.markdown b/pt-br/sql-pt.html.markdown new file mode 100644 index 00000000..0e4631a6 --- /dev/null +++ b/pt-br/sql-pt.html.markdown @@ -0,0 +1,119 @@ +--- +language: SQL +filename: learnsql-pt.sql +contributors: + - ["Bob DuCharme", "http://bobdc.com/"] +translators: + - ["jovinoguerrero", "https://github.com/jovinoguerrero"] +lang: pt-br +--- + +A linguagem de consulta estruturada (SQL em inglês) é uma linguagem padrão ISO para criar e trabalhar com bancos de dados armazenados num conjunto de tabelas. As implementações geralmente adicionam suas próprias extensões à linguagem; [Comparação entre diferentes implementações de SQL](http://troels.arvin.dk/db/rdbms/) é uma boa referência sobre as diferenças entre os diferentes produtos. + +As implementações normalmente fornecem uma linha de comando onde se pode digitar os comandos mostrados aqui de forma interativa, e também oferecem uma maneira de executar uma série desses comandos armazenados em um arquivo de script (mostrar que é feito com o prompt interativo é um bom exemplo de algo que não é padronizado - a maioria das implementações SQL suporta as palavras-chave QUIT, EXIT ou ambas). + +Vários desses comandos de exemplo assumem que o [banco de dados de funcionários de exemplo MySQL](https://dev.mysql.com/doc/employee/en/) disponível em [github](https://github.com/datacharmer/test_db) já foi carregado. Os arquivos do GitHub são scripts de comandos, semelhantes aos comandos abaixo, que criam e carregam tabelas de dados sobre os funcionários de uma empresa fictícia. A sintaxe para executar esses scripts dependerá da implementação SQL que você está usando. Um aplicativo executado a partir do prompt do sistema operacional geralmente é o normal. + + +```sql +-- Os comentários começam com dois hífens. Cada comando é encerrado com um +-- ponto e vírgula. + +-- SQL não diferencia maiúsculas de minúsculas em palavras-chave. Os +-- comandos de exemplo mostrados aqui seguem a convenção de serem escritos +-- em maiúsculas porque torna mais fácil distingui-los dos nomes dos bancos +-- de dados, tabelas e colunas. + +-- Em seguida, um banco de dados é criado e excluído. Os nomes do banco de +-- dados e da tabela são sensíveis a maiúsculas de minúsculas. +CREATE DATABASE someDatabase; +DROP DATABASE someDatabase; + +-- Mostra numa lista todos os bancos de dados disponíveis. +SHOW DATABASES; + +-- Usa um determinado banco de dados existente. +USE employees; + +-- Seleciona todas as filas e colunas da tabela de departamentos no banco +-- de dados atual. A atividade padrão é o intérprete rolar os resultados +-- na tela. +SELECT * FROM departments; + +-- Recupera todas as filas da tabela de departamentos, mas apenas as colunas +-- dept_no e dept_name. +-- A separação de comandos em várias linhas é permitida. +SELECT dept_no, + dept_name FROM departments; + +-- Obtém todas as colunas de departments, mas é limitado a 5 filas. +SELECT * FROM departments LIMIT 5; + +-- Obtém os valores da coluna dept_name da tabela de departments quando +-- dept_name tem como valor a substring 'en'. +SELECT dept_name FROM departments WHERE dept_name LIKE '%en%'; + +-- Recupera todas as colunas da tabela de departments onde a coluna +-- dept_name começa com um 'S' e tem exatamente 4 caracteres depois dele. +SELECT * FROM departments WHERE dept_name LIKE 'S____'; + +-- Seleciona os valores dos títulos da tabela de titles, mas não mostra +-- duplicatas. +SELECT DISTINCT title FROM titles; + +-- Igual ao anterior, mas ordenado por valores de da coluna title (diferencia +-- maiúsculas de minúsculas). +SELECT DISTINCT title FROM titles ORDER BY title; + +-- Mostra o número de filas da tabela departments. +SELECT COUNT(*) FROM departments; + +-- Mostra o número de filas da tabela departments que contém 'en' como +-- substring na coluna dept_name. +SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%'; + +-- Uma união (JOIN) de informações de várias tabelas: a tabela titles mostra +-- quem tem quais cargos laborais, de acordo com seu número de funcionários, +-- e desde que data até que data. Esta informação é obtida, mas em vez do +-- número do funcionário é usada como referência cruzada a tabela employee +-- para obter o nome e sobrenome de cada funcionário (e limita os resultados +-- a 10 filas). +SELECT employees.first_name, employees.last_name, + titles.title, titles.from_date, titles.to_date +FROM titles INNER JOIN employees ON + employees.emp_no = titles.emp_no LIMIT 10; + +-- São listadas todas as tabelas de todas os bancos de dados. As implementações +-- normalmente fornecem seus próprios comandos para fazer isso com o banco de +-- dados atualmente em uso. +SELECT * FROM INFORMATION_SCHEMA.TABLES +WHERE TABLE_TYPE='BASE TABLE'; + +-- Cria uma tabela chamada tablename1, com as duas colunas mostradas, a partir +-- do banco de dados em uso. Há muitas outras opções dísponiveis para a forma +-- em que se especificam as colunas, por ex. seus tipos de dados. +CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20)); + +-- Insere uma fila de dados na tabela tablename1. É assumido que a tabela foi +-- definida para aceitar esses valores como adequados. +INSERT INTO tablename1 VALUES('Richard','Mutt'); + +-- Em tablename1, se altera o valor de fname para 'John' em todas as filas que +-- contenham um valor em lname igual a 'Mutt'. +UPDATE tablename1 SET fname='John' WHERE lname='Mutt'; + +-- Se excluem as filas da tabela tablename1 em que o valor de lname começa +-- com 'M'. +DELETE FROM tablename1 WHERE lname like 'M%'; + +-- Se excluem as filas da tabela tablename1, deixando a tabla vazia. +DELETE FROM tablename1; + +-- A tabela tablename1, é excluída completamente. +DROP TABLE tablename1; +``` + +# Leitura adicional + +* [Codecademy - SQL](https://www.codecademy.com/learn/learn-sql) A good introduction to SQL in a “learn by doing it” format. +* [Database System Concepts](https://www.db-book.com/) book’s Chapter 3 - Introduction to SQL has an in depth explanation of SQL concepts. diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown index 40c3c02c..40c3c02c 100755..100644 --- a/pt-br/stylus-pt.html.markdown +++ b/pt-br/stylus-pt.html.markdown diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown index ce3be407..e2130e0a 100644 --- a/pt-br/tmux-pt.html.markdown +++ b/pt-br/tmux-pt.html.markdown @@ -59,47 +59,49 @@ As seções tmux acopladas são controladas através de teclas de atalho. (prefi ---------------------------------------------------------------------- (C-b) = Ctrl + b # Abre a opção de receber comandos(atalhos). - (M-1) = Meta + 1 -or- Alt + 1 + (M-1) = Meta + 1 -ou- 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. + ? # 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. + ! # 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. + 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. + [ # Entra no modo cópia (Copy Mode) para copiar texto ou ver o histórico. - 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. + 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. - & # Encerra a janela atual. - x # Encerra o painel atual. + d # Separa o cliente atual. + D # Seleciona um cliente a ser separado. - Up, Down # Move para o painel acima, abaixo, a esquerda ou a direita. + & # 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: + 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-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-Up, M-Down # Altera o tamanho do painel atual em cinco células. M-Left, M-Right ``` diff --git a/pt-br/toml-pt.html.markdown b/pt-br/toml-pt.html.markdown new file mode 100644 index 00000000..bdb1decf --- /dev/null +++ b/pt-br/toml-pt.html.markdown @@ -0,0 +1,232 @@ +--- +language: toml +filename: learntoml-pt.toml +contributors: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +translators: + - ["Adaías Magdiel", "https://adaiasmagdiel.com/"] +lang: pt-br +--- + +TOML significa Tom's Obvious, Minimal Language. É uma linguagem de serialização de dados projetada para ser um formato de arquivo de configuração mínimo que é fácil de ler devido à semântica óbvia. + +É uma alternativa ao YAML e JSON. Tem como objetivo ser mais amigável para humanos do que JSON e mais simples que YAML. TOML é projetado para mapear de forma inequívoca para uma tabela de hash e deve ser fácil de converter em estruturas de dados em uma ampla variedade de linguagens. + +Cuidado, a especificação do TOML ainda passa por muitas mudanças. Até que seja marcado como 1.0, você deve assumir que é instável e agir de acordo. Este documento segue o TOML v0.4.0. + +```toml +# Comentários em TOML são feitos desta forma. + +################### +# TIPOS ESCALARES # +################### + +# Nosso objeto raiz (que continuará por todo o documento) será um mapa, +# que é equivalente a um dicionário, hash ou objeto em outras linguagens. + +# A chave, o sinal de igual e o valor precisam estar na mesma linha +# (embora alguns valores possam ser quebrados em várias linhas). +chave = "valor" +string = "Olá" +number = 42 +float = 3.14 +boolean = true +dateTime = 2002-07-16T20:32:00-03:00 +scientificNotation = 1e+12 +"chaves podem estar entre aspas" = true # Tanto " quanto ' são aceitáveis +"chaves podem conter" = "letras, números, underscores e hífens" + +# Uma chave não pode ser vazia, mas uma chave vazia entre aspas é permitido +"" = "blank" # VÁLIDO mas não é recomendado +'' = 'blank' # VÁLIDO mas não é recomendado + +########## +# String # +########## + +# Todas as strings precisam ter apenas caracteres UTF-8 válidos. +# Podemos escapar caracteres e alguns deles têm uma sequência de escape compacta. +# Por exemplo: \t adiciona uma tabulação. Leia a spec para conhecer todos. +basicString = "São cercadas por aspas. \"Sou digno de citação\". Nome\tJosé." + +multiLineString = """ +são cercadas por três aspas +em cada lado e permitem novas linhas.""" + +literalString = 'são cercadas por aspas simples. Escape de caracteres não é permitido.' + +multiLineString = ''' +são cercadas por três aspas simples em cada lado +e permitem novas linhas. Escape de caracteres também não é permitido. +A primeira quebra de linha é removida em strings brutas + Todo outro espaço em branco + é preservado. #! foi preservado? +''' + +# Para dados binários é recomendado que você use Base64, outra codificação ASCII ou UTF8. +# A manipulação dessa codificação será específico da aplicação. + +############ +# Inteiros # +############ + +## Inteiros podem começar com um +, um -, ou nada. +## Zeros à frente não são permitidos. +## Formatos em hexadecimal, octal e binário são permitidos. +## Não são permitidos valores que não podem ser expressados como uma série de dígitos. +int1 = +42 +int2 = 0 +int3 = -21 +int4 = 0xcafebabe +int5 = 0o755 +int6 = 0b11011100 +integerRange = 64 + +## Você pode usar underscores para melhorar a legibilidade. +## Cada underscore precisa estar entre, pelo menos, um dígito. +int7 = 5_349_221 +int8 = 1_2_3_4_5 # VÁLIDO, mas não é recomendado + +######### +# Float # +######### + +# Floats são inteiros seguidos por uma fração e/ou de um expoente. +flt1 = 3.1415 +flt2 = -5e6 +flt3 = 6.626E-34 + +############# +# Booleanos # +############# + +bool1 = true +bool2 = false +booleanosPrecisamEstarEmMinusculo = true + +############ +# Datetime # +############ + +date1 = 1979-05-27T07:32:00Z # Tempo UTC, seguindo especificação RFC 3339/ISO 8601 +date2 = 1979-05-26T15:32:00+08:00 # com um deslocamento segundo a RFC 3339/ISO 8601 +date3 = 1979-05-27T07:32:00 # sem deslocamento +date4 = 1979-05-27 # sem as horas e sem deslocamento + +#################### +# TIPOS DE COLEÇÃO # +#################### + +######### +# Array # +######### + +array1 = [ 1, 2, 3 ] +array2 = [ "Vírgulas", "são", "delimitadores" ] +array3 = [ "Não misture", "tipos", "diferentes" ] +array4 = [ [ 1.2, 2.4 ], ["todas as", 'strings', """são do mesmo""", '''tipo'''] ] +array5 = [ + "Espaços em branco", "são", "ignorados" +] + +########## +# Tabela # +########## + +# Tabelas (ou tabelas de hash, ou dicionários) é uma coleção de pares chave/valor. +# Eles aparecem entre colchetes em uma linha separada. +# Tabelas vazias são permitidas e simplesmente não possuem chave/valor associado. +[tabela] + +# Abaixo disso, e até a próxima tabela ou final do arquivo, estão as chaves/valores dessa tabela. +# Os pares de chave/valor dentro das tabelas não têm garantia de estar em nenhuma ordem específica. +[table-1] +chave1 = "algum texto" +chave2 = 123 + +[table-2] +chave1 = "outro texto" +chave2 = 456 + +# Pontos são proibidos em chaves simples porque são usados para indicar tabelas aninhadas. +# As regras de nomenclatura para cada parte separada por ponto são as mesmas que para chaves. +[dog."tater.man"] +type = "pug" + +# Na terra do JSON, você teria a seguinte estrutura: +# { "dog": { "tater.man": { "type": "pug" } } } + +# Espaços em branco em torno das partes separadas por pontos são ignorados, de qualquer forma, +# é sempre recomendado não utilizar espaços em branco desnecessários. +[a.b.c] # isso é o recomendado +[ d.e.f ] # mesmo que [d.e.f] +[ j . "ʞ" . 'l' ] # mesmo que [j."ʞ".'l'] + +# Você não precisa especificar todas as super-tabelas se não quiser. TOML sabe +# como lidar com isso para você. +# [x] você +# [x.y] não precisa +# [x.y.z] disso +[x.y.z.w] # para isso funcionar + +# Mesmo que uma super-tabela não tenha sido definida diretamente e não tenha definido uma +# chave específica, ainda é possível escrever nela. +[a.b] +c = 1 + +[a] +d = 2 + +# Irá gerar o seguinte JSON: +# { "a": {"b": {"c": 1}, "d": 2 } } + +# Você não pode definir uma chave ou tabela mais de uma vez. É inválido fazer isso. + +# NÃO FAÇA ISSO +[a] +b = 1 + +[a] +c = 2 + +# NEM MESMO ISSO +[a] +b = 1 + +[a.b] +c = 2 + +# O nome de todas as tabelas não pode ser vazio. +[] # INVÁLIDO +[a.] # INVÁLIDO +[a..b] # INVÁLIDO +[.b] # INVÁLIDO +[.] # INVÁLIDO + +#################### +# Tabelas em linha # +#################### + +tabelasEmLinha = { sãoFechadasCom = "{ e }", precisamEstarEmUmaLinha = true } +ponto = { x = 1, y = 2 } + +#################### +# Array de Tabelas # +#################### + +# Um array de tabelas pode ser expresso usando um nome de tabela entre colchetes duplos. +# Cada tabela com o mesmo nome entre colchetes duplos será um item no array. +# As tabelas são inseridas na ordem em que são encontradas. + +[[produtos]] +nome = "array de tabelas" +sku = 738594937 +tabelasVaziasSaoPermitidas = true + +[[produtos]] + +[[produtos]] +nome = "Unhas" +sku = 284758393 +color = "cinza" +``` diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown index 2a7205cd..dcc72c04 100644 --- a/pt-br/visualbasic-pt.html.markdown +++ b/pt-br/visualbasic-pt.html.markdown @@ -8,7 +8,7 @@ lang: pt-br filename: learnvisualbasic-pt.vb --- -``` +```visualbasic Module Module1 module Module1 @@ -28,12 +28,12 @@ module Module1 Console.WriteLine ("2. Entrada Olá Mundo" ) Console.WriteLine ("3. Cálculando números inteiros " ) Console.WriteLine ("4. Calculando números decimais " ) - Console.WriteLine ("5 . Calculadora de Trabalho " ) + Console.WriteLine ("5. Calculadora de Trabalho " ) Console.WriteLine ("6. Usando Do While Loops " ) Console.WriteLine ("7. Usando Para While Loops " ) - Console.WriteLine ("8 . Declarações condicionais " ) + Console.WriteLine ("8. Declarações condicionais " ) Console.WriteLine ("9. Selecione uma bebida" ) - Console.WriteLine ("50 . About" ) + Console.WriteLine ("50. About" ) Console.WriteLine ("Por favor, escolha um número da lista acima " ) Seleção Dim As String = Console.ReadLine Select A seleção dos casos @@ -76,7 +76,7 @@ module Module1 End Sub ' Um - Eu estou usando números para ajudar com a navegação acima quando eu voltar - ' depois de construí-lo . + ' depois de construí-lo. " Nós usamos subs privadas para separar diferentes seções do programa. Private Sub HelloWorldOutput () @@ -94,12 +94,12 @@ module Module1 Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes" ' Variáveis '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 . + ' As variáveis também começar com um Dim e terminar com um Como VariableType. ' 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 . + " 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 do usuário. Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >". @@ -124,10 +124,10 @@ module Module1 'Quatro Sub CalculatingDecimalNumbers particulares () Console.Title = " Calculando com duplo | Saiba X em Y Minutes" - ' Claro que gostaria de ser capaz de somar decimais . + ' Claro que gostaria de ser capaz de somar decimais. " Por isso, poderia mudar o acima de Integer para Double. - " Digite um número inteiro , 1,2 , 2,4 , 50,1 , 104,9 ect + " Digite um número inteiro como 1, 2, 50, 104, etc Console.Write ("Primeiro número:") Dim a As Double = Console.ReadLine Console.Write ("Segundo número:") 'Enter segundo número inteiro. @@ -141,9 +141,9 @@ module Module1 ' Cinco Private Sub WorkingCalculator () Console.Title = " A Calculadora de Trabalho | Saiba X em Y Minutes" - " No entanto, se você gostaria que a calculadora para subtrair, dividir , múltiplos e + " No entanto, se você gostaria que a calculadora para subtrair, dividir, múltiplos e ' somar. - ' Copie e cole o código acima novamente . + ' Copie e cole o código acima novamente. Console.Write ("Primeiro número:") Dim a As Double = Console.ReadLine Console.Write ("Segundo número:") 'Enter segundo número inteiro. @@ -153,7 +153,7 @@ module Module1 Dim e As Integer = a - b Dim f As Integer = a / b - " Ao adicionar as linhas abaixo , somos capazes de calcular a subtração , + " Ao adicionar as linhas abaixo, somos capazes de calcular a subtração, ' multply bem como dividir os valores de a e b Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) ) 'Queremos pad as respostas para a esquerda por três espaços. @@ -172,8 +172,8 @@ module Module1 Sub UsingDoWhileLoops particulares () ' Assim como o sub privado anterior ' Desta vez, perguntar se o usuário deseja continuar ( Sim ou Não ? ) - ' Estamos usando Do While Loop , como não temos certeza se o usuário quer usar o - 'programa mais de uma vez . + ' Estamos usando Do While Loop, como não temos certeza se o usuário quer usar o + 'programa mais de uma vez. Console.Title = " UsingDoWhileLoops | Saiba X em Y Minutes" Dim resposta As String ' Nós usamos a variável " String" como a resposta é um texto Do ' Começamos o programa com @@ -195,12 +195,12 @@ module Module1 Console.Write ( a.ToString () + "/" + b.ToString ()) Console.WriteLine (" =" + e.ToString.PadLeft (3) ) Console.ReadLine () - ' Faça a pergunta , se o usuário deseja continuar? Infelizmente, + ' Faça a pergunta, se o usuário deseja continuar? Infelizmente, "é sensível a maiúsculas. Console.Write ( "Deseja continuar? (Sim / não )") " O programa pega a variável e imprime e começa de novo. answer = Console.ReadLine - " O comando para a variável para trabalhar seria , neste caso, " sim " + " O comando para a variável para trabalhar seria, neste caso, " sim " Loop While resposta = "yes" End Sub @@ -233,7 +233,7 @@ module Module1 outro Console.WriteLine (" Olá " + nome do usuário) Console.WriteLine (" Você check-out www.learnxinyminutes.com " ) - Console.ReadLine () ' Fins e imprime a declaração acima . + Console.ReadLine () ' Fins e imprime a declaração acima. End If End Sub @@ -242,15 +242,15 @@ module Module1 Console.Title = "Se Declaração / Else | Saiba X em Y Minutes" 'Às vezes é importante ter em conta mais de duas alternativas. 'Às vezes, há um bom número de outros. - 'Quando este for o caso , mais do que uma if seria necessária . - 'Uma instrução if é ótimo para máquinas de venda automática . Quando o usuário digita um código. - ' A1 , A2, A3 , ect para selecionar um item. + 'Quando este for o caso, mais do que uma if seria necessária. + 'Uma instrução if é ótimo para máquinas de venda automática. Quando o usuário digita um código. + ' A1, A2, A3, etc para selecionar um item. 'Todas as opções podem ser combinadas em uma única if. Seleção Dim Valor String = Console.ReadLine ' para a seleção Console.WriteLine (" A1. Para Soda " ) Console.WriteLine (" A2. Para Fanta " ) - Console.WriteLine (" A3 . Para Guaraná" ) + Console.WriteLine (" A3. Para Guaraná" ) Console.WriteLine (" A4. Para Coca Diet" ) Console.ReadLine () Se a seleção = "A1" Então diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown index 21e9b4bb..b2fb2a7d 100644 --- a/pt-br/yaml-pt.html.markdown +++ b/pt-br/yaml-pt.html.markdown @@ -2,6 +2,7 @@ language: yaml contributors: - ["Leigh Brenecki", "https://github.com/adambrenecki"] + - [Suhas SG, 'https://github.com/jargnar'] translators: - ["Rodrigo Russo", "https://github.com/rodrigozrusso"] filename: learnyaml-pt.yaml @@ -14,6 +15,8 @@ legível por seres humanos. É um superconjunto de JSON, com a adição de identação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação. ```yaml +--- # início do documento + # Comentários em YAML são como este. ################### @@ -30,28 +33,32 @@ 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." +porem: 'Uma string, entre aspas.' +'Chaves podem estar entre aspas tambem.': "É útil se você quiser colocar um ':' na sua chave." +aspas simples: 'possuem ''um'' padrão de escape' +aspas duplas: "possuem vários: \", \0, \t, \u263A, \x0d\x0a == \r\n, e mais." +# Caracteres UTF-8/16/32 precisam ser codificados +Superscript dois: \u00B2 # Seqüências de várias linhas podem ser escritas 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. + 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. + O literal continua até 'des-indentar', 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. + 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. + 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 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. + Linhas 'mais-indentadas' mantém suas novas linhas também - + este texto irá aparecer em duas linhas. #################### # TIPOS DE COLEÇÃO # @@ -59,54 +66,85 @@ estilo_compacto: > # Texto aninhado é conseguido através de identação. um_mapa_aninhado: - chave: valor - outra_chave: Outro valor - outro_mapa_aninhado: - ola: ola + 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. +# As chaves podem ser complexas, como sequência de várias linhas +# Utilizando ? seguido por espaço para indicar o começo de uma chave complexa. ? | - Esta é uma chave - que tem várias linhas + 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. +# YAML também permite o mapeamento entre sequências com a sintaxe chave complexa +# Alguns analisadores de linguagem de programação podem reclamar +# Um exemplo +? - Manchester United + - Real Madrid +: [2001-01-01, 2002-02-02] # Sequências (equivalente a listas ou arrays) semelhante a 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 + - Item 1 + - Item 2 + - 0.5 # sequências podem conter tipos diferentes. + - Item 4 + - chave: valor + outra_chave: outro_valor + - + - Esta é uma sequência + - dentro de outra sequência + - - - Indicadores de sequência aninhadas + - podem ser recolhidas # Como YAML é um super conjunto de JSON, você também pode escrever mapas JSON de estilo e -# sequencias: +# sequências: mapa_json: {"chave": "valor"} json_seq: [3, 2, 1, "decolar"] +e aspas são opcionais: {chave: [3, 2, 1, decolar]} -########################## -# RECURSOS EXTRA DO YAML # -########################## +########################### +# RECURSOS EXTRAS 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 +conteudo_ancora: &nome_ancora Essa string irá aparecer como o valor de duas chaves. +outra_ancora: *nome_ancora + +# Âncoras podem ser usadas para dubplicar/herdar propriedades +base: &base + name: Todos possuem o mesmo nome + +# O regexp << é chamado Mesclar o Tipo Chave Independente-de-Idioma. É usado para +# indicar que todas as chaves de um ou mais mapas específicos devam ser inseridos +# no mapa atual. + +foo: + <<: *base + idade: 10 + +bar: + <<: *base + idade: 20 + +# foo e bar terão o mesmo nome: Todos possuem o mesmo nome # YAML também tem tags, que você pode usar para declarar explicitamente os tipos. -string_explicita: !! str 0,5 +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 +numero_complexo_em_python: !!python/complex 1+2j + +# Podemos utilizar chaves YAML complexas com tags específicas de linguagem +? !!python/tuple [5, 7] +: Fifty Seven +# Seria {(5, 7): 'Fifty Seven'} em Python #################### # YAML TIPOS EXTRA # @@ -114,27 +152,34 @@ numero_complexo_em_python: !! python / complex 1 + 2j # 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 +datetime: 2001-12-15T02:59:43.1Z +datetime_com_espaços: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 # A tag !!binary indica que a string é na verdade um base64-encoded (codificado) # 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= + 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 +conjunto: + ? item1 + ? item2 + ? item3 +ou: {item1, item2, item3} + +# Como Python, são apenas conjuntos de mapas com valores nulos; o acima é equivalente a: +conjunto2: + item1: null + item2: null + item3: null + +... # fim do documento ``` +### Mais Recursos + ++ [Site Oficial do YAML](https://yaml.org/) ++ [Validador YAML Online](http://www.yamllint.com/) |