From 5c8c0186dcb8629396e5c82335cb7e9695ed8eec Mon Sep 17 00:00:00 2001 From: Paulo Henrique Rodrigues Pinheiro Date: Thu, 19 Oct 2017 18:31:21 -0200 Subject: Translate latex to pt_BR --- pt-br/latex-pt.html.markdown | 291 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 pt-br/latex-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown new file mode 100644 index 00000000..a9ed566e --- /dev/null +++ b/pt-br/latex-pt.html.markdown @@ -0,0 +1,291 @@ +--- +language: latex +contributors: + - ["Chaitanya Krishna Ande", "http://icymist.github.io"] + - ["Colton Kohnke", "http://github.com/voltnor"] + - ["Sricharan Chiruvolu", "http://sricharan.xyz"] + - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"] + - ["Svetlana Golubeva", "https://attillax.github.io/"] +translators: + - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"] +lang: pt-br +filename: learn-latex-pt.tex +--- + +```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 +% MS Word ou OpenOffice Writer + +$ 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. +% As opções para um documento aparecem entre [] chaves. Nesse caso +% está especificado que queremos o tamanho da fonte em 12pt. +\documentclass[12pt]{article} + +% Em seguida definimos os pacotes que o documento usa. +% Se você quiser incluir gráficos, texto colorido, ou código fonte de outra +% linguagem em outro arquivo em seu documento, você precisa ampliar as +% capacidade do LaTeX. Isso é feito adicionando-se pacotes. +% Serão incluídos os pacotes float e caption para imagens e hyperref +% para links. +\usepackage{caption} +\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!} + +% Agora estamos pronto para começar o documento +% Tudo antes dessa linha é chamado "preâmbulo". +\begin{document} +% 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. +% É uma voa prática separar a tabela de conteúdo do corpo do documento. Para +% isso usa-se o comando \newpage +\newpage +\tableofcontents + +\newpage + +% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos +% predefinidos para isso. +% Isso deve aparecer em sua ordem lógica, portanto, após o topo, +% mas antes das seções principais do corpo. +% 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! +\end{abstract} + +% Comandos para seções são intuitivos. +% Todos os títulos de seção são adicionados automaticamente à tabela de conteúdo. +\section{Introdução} +Olá, meu nome é Colton e juntos estamos explorando o mundo do \LaTeX! + +\section{Outra seção} +Esse é o texto para outra seção. Penso que precisamos de uma subseção. + +\subsection{Isso é uma subseção} % Subseções também são intuitivas. +Penso que precisamos de mais uma + +\subsubsection{Pythagoras} +Muito melhor agora. +\label{subsec:pythagoras} + +% Ao usar o asterisco nós impedimos a numeração automática. +% Isso funciona para outros comandos \LaTeX também. +\section*{Essa é uma seção não numerada} +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 +ser posto. Se +uma linha \\ deve \\ ser \\ quebrada \\ adicione \textbackslash\textbackslash +\hspace{1pt} ao código de seu documento. \\ + +\section{Listas} +Listas são uma das coisas mais fáceis de criar no \LaTeX! Preciso fazer compras +amanhã, então façamos uma lista de compras. +\begin{enumerate} % Isso cria o bloco "enumerate". + % \item faz com que o enumerate incremente + \item Salada. + \item 27 melancias. + \item Uma lebre. + % pode-se também sobrescrever o número do item usando [] + \item[quantas?] Pistolas de água médias. + + Não é um item da lista, mas faz parte do bloco enumerate. + + \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 +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! \\ + +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.\\ + +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. \\ +% 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. +% Podemos entrar no modo matemática a partir do modo texto com os símbolos $. +% O oposto também pode ocorrer. Variáveis podem ser renderizadas no modo +% matemática. +% Também podemos entrar no modo matemática com \[\] + +\[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!\\ + +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. +Vamos escrever uma equação para ver como se faz: +$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\ + +Frações (numerador/denominador) podem ser escritas dessa forma: + +% 10 / 7 +$$ ^{10}/_{7} $$ + +% Frações relativamente complexas podem ser escritas como +% \frac{numerator}{denominator} +$$ \frac{n!}{k!(n - k)!} $$ \\ + +Também podemos escrever equações em um ``bloco de equação''. + +% Apresenta matemática com o 'bloco' equação +\begin{equation} % entra no modo matemática + c^2 = a^2 + b^2. + \label{eq:pythagoras} % para referência + \end{equation} % toda declaração \begin precisa de uma declaração end + +Podemos então referenciar nossa nova equação! +A equação~\ref{eq:pythagoras} é também conhecida como Teorema de Pitágoras que é +também assunto da Seção~\ref{subsec:pythagoras}. Muitas coisas podem ser +rotuladas: figuras, equações, seções, etc. + +Somatórios e Integrais são escritas com os comandos sum e int: + +% Alguns compiladores LaTeX irão reclamar se existirem linhas em branco +% em um bloco de equação. +\begin{equation} + \sum_{i=0}^{5} f_{i} +\end{equation} +\begin{equation} + \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x +\end{equation} + +\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. + +\begin{figure}[H] % H aqui é uma opção para o local da figura. + \centering % centra a figura na página + % Inclui uma figura com escala de 0.8 do tamanho da página. + %\includegraphics[width=0.8\linewidth]{right-triangle.png} + % Comentado para propósitos de compilação. Por favor, use sua imaginação. + \caption{Triângulo retângulo com lados $a$, $b$, $c$} + \label{fig:right-triangle} +\end{figure} + +\subsection{Tabelas} +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. + \begin{tabular}{c|cc} + Número & Sobrenome & Primeiro Nome \\ % Colunas são separadas por & + \hline % uma linha horizontal + 1 & Biggus & Dickus \\ + 2 & Monty & Python + \end{tabular} +\end{table} + +\section{Fazendo o \LaTeX \hspace{1pt} 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} +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!") + a%b; % olha só! Podemos usar os sinais % no bloco verbatim. + random = 4; #decided by fair random dice roll +\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. +(sim, esse documento é compilável). \\ + +Finalizando o documento usando \LaTeX \hspace{1pt} 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. + Os passos para compilar se parecem (em Linux) com: \\ + \begin{verbatim} + > pdflatex learn-latex.tex + \end{verbatim} + \end{enumerate} + +Existem editores de \LaTeX \hspace{1pt} 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 +passo 2 várias vezes, para gerar arquivos *.aux intermediários.}. +% É assim que você adiciona notas de rodapé em seus documentos! + +Você escreve toda a informação de formatação em texto puro, no passo 1. O +momento da compilação no passo 2 é responsável por produzir o documento no +formato que você definiu no passo 1. + +\section{Links} +Nós podemos inserir links em nosso documento. Para isso nós necessitamos incluir +o pacote hyperref no preâmbulo com o comando: +\begin{verbatim} + \usepackage{hyperref} +\end{verbatim} + +Existem dois tipos principais de links: URL visíveis \\ +\url{https://learnxinyminutes.com/docs/latex/}, ou +\href{https://learnxinyminutes.com/docs/latex/}{um texto alternativo} +% Você não pode adicionar espaços extras ou símbolos especiais no texto +% alternativo, pois isso causará problemas na compilação. + +Esse pacote também produz uma lista de thumbnails no documento pdf gerado e +ativa os links na tabela de conteúdo. + +\section{End} + +Por enquanto é isso! + +% Frequentemente você precisa de uma seção de referências em seu documento. +% A forma mais fácil de configurá-la é usando uma seção de bibliografia +\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 +https://en.wikibooks.org/wiki/LaTeX} + \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com} +\end{thebibliography} + +% end the document +\end{document} +``` + +## Mais sobre 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/) -- cgit v1.2.3 From fc57b35478e2ba624005fdb0138c98bb4916fbf4 Mon Sep 17 00:00:00 2001 From: Paulo Henrique Rodrigues Pinheiro Date: Mon, 23 Oct 2017 16:16:44 -0200 Subject: Translate whip to pt_BR --- pt-br/whip-pt.html.markdown | 247 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 pt-br/whip-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown new file mode 100644 index 00000000..989bae05 --- /dev/null +++ b/pt-br/whip-pt.html.markdown @@ -0,0 +1,247 @@ +--- +language: whip +contributors: + - ["Tenor Biel", "http://github.com/L8D"] + - ["Saurabh Sandav", "http://github.com/SaurabhSandav"] +author: Tenor Biel +author_url: http://github.com/L8D +translators: + - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"] +lang: pt-br +filename: whip-pt.lisp +--- + +Whip é um dialeto de Lisp feito para construir scripts e trabalhar com +conceitos mais simples. +Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata) + +Esse documento foi escrito pelo próprio autor da linguagem. Então é isso. + +```scheme +; Comentário são como em Lisp. Pontos-e-vírgulas... + +; A maioria das declarações de primeiro nível estão dentro de "listas" +; que nada mais são que coisas entre parêntesis separadas por espaços em branco +nao_é_uma_lista +(uma lista) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 1. Números, texto e operadores + +; Whip tem um tipo numérico (que é um double de 64 bits IEE 754, do JavaScript) +3 ; => 3 +1.5 ; => 1.5 + +; Funções são chamadas se elas são o primeiro elemento em uma lista +(funcao_chamada argumentos) + +; A maioria das operações são feitas com funções +; Todas as funções aritméticas básicas são bem diretas +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 +; até mesmo o módulo +(% 9 4) ; => 1 +; Divisão não inteira ao estilo JavaScript. +(/ 5 2) ; => 2.5 + +; Aninhamento de listas funciona como esperado. +(* 2 (+ 1 3)) ; => 8 + +; Há um tipo boleano. +true +false + +; Textos são criados com ". +"Hello, world" + +; Caracteres são criados com '. +'a' + +; Para negação usa-se a função 'not'. +(not true) ; => false +(not false) ; => true + +; Mas a maioria das funções não-haskell tem atalhos +; o não atalho é um '!'. +(! (! true)) ; => true + +; Igualdade é `equal` ou `=`. +(= 1 1) ; => true +(equal 2 1) ; => false + +; Por exemplo, inigualdade pode ser verificada combinando as funções +;`not` e `equal`. +(! (= 2 1)) ; => true + +; Mais comparações +(< 1 10) ; => true +(> 1 10) ; => false +; e suas contra partes para texto. +(lesser 1 10) ; => true +(greater 1 10) ; => false + +; Texto pode ser concatenado com +. +(+ "Hello " "world!") ; => "Hello world!" + +; Você pode usar as características comparativas do JavaScript. +(< 'a' 'b') ; => true +; ... e coerção de tipos +(= '5' 5) + +; As funções `at` ou `@` acessarão caracteres de um texto, começando em 0. +(at 0 'a') ; => 'a' +(@ 3 "foobar") ; => 'b' + +; Também existem as variáveis `null` e `undefined`. +null ; usada para indicar a ausência de algum valor +undefined ; usada para indicar que um valor não foi informado + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 2. Variáveis, matrizes e dicionários + +; Variáveis são declaradas com as funções `def` ou `let`. +; Variáveis que não tiveram valor atribuído serão `undefined`. +(def some_var 5) +; `def` deixará a variável no contexto global. +; `let` deixará a variável no contexto local, e tem uma sintaxe estranha. +(let ((a_var 5)) (+ a_var 5)) ; => 10 +(+ a_var 5) ; = undefined + 5 => undefined + +; Matrizes são listas de valores de qualquer tipo. +; Elas basicamente são listas sem funções no início +(1 2 3) ; => [1, 2, 3] (sintaxe JavaScript) + +; Dicionários em Whip são o equivalente a 'object' em JavaScript ou +; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada +de pares chave-valor. +{"key1" "value1" "key2" 2 3 3} + +; Chaves podem ser apenas identificadores, números ou texto. +(def my_dict {my_key "my_value" "my other key" 4}) +; Mas em Whip, dicionários são parceados como: valor, espaço, valor; +; com mais espaço entre cada. Então isso significa que +{"key" "value" +"another key" +1234 +} +é avaliado da mesma forma que +{"key" "value" "another key" 1234} + +; Dicionários podem ser acessados usando a função `at` +; (como em texto e listas) +(@ "my other key" my_dict) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 3. Lógica e controle de fluxo + +; A função `if` é muito simples, ainda que muito diferente do que em muitas +linguagens imperativas. +(if true "returned if first arg is true" "returned if first arg is false") +; => "returned if first arg is true" + +; E por conta do legado operador ternário +; `?` é o atalho não utilizado para `if`. +(? false true false) ; => false + +; `both` é uma declaração lógica `and`, e `either` é o `or` lógico. +(both true true) ; => true +(both true false) ; => false +(either true false) ; => true +(either false false) ; => false +; E seus atalhos são +; & => both +; ^ => either +(& true true) ; => true +(^ false true) ; => true + +;;;;;;;;; +; Lambdas + +; Lambdas em Whip são declaradas com as funções `lambda` ou `->`. +; E funções são na verdade lambdas com nomes. +(def my_function (-> (x y) (+ (+ x y) 10))) +; | | | | +; | | | valor retornado (com escopo contento argumentos) +; | | argumentos +; | declaração de funções lambda +; | +; nome do lambda a ser declarado + +(my_function 10 10) ; = (+ (+ 10 10) 10) => 30 + +; Obviamente, todos os lambdas por definição são anônimos e +; tecnicamente sempre usados anonimamente. Redundância. +((lambda (x) x) 10) ; => 10 + +;;;;;;;;;;;;;;;; +; Comprehensions + +; `range` or `..` geram uma lista dos números para +; cada número entre seus dois argumentos. +(range 1 5) ; => (1 2 3 4 5) +(.. 0 2) ; => (0 1 2) + +; `map` aplica seu primeiro argumento (que deve ser um lambda/função) +; a cada item dos argumentos seguintes (que precisa ser uma lista) +(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4) + +; Reduce +(reduce + (.. 1 5)) +; equivalente a +((+ (+ (+ 1 2) 3) 4) 5) + +; Nota: map e reduce não possuem atalhos + +; `slice` ou `\` é similar ao .slice() do JavaScript +; mas veja que ele pega uma lista como primeiro argumento, não o último. +(slice (.. 1 5) 2) ; => (3 4 5) +(\ (.. 0 100) -5) ; => (96 97 98 99 100) + +; `append` ou `<<` são auto explicativos +(append 4 (1 2 3)) ; => (1 2 3 4) +(<< "bar" ("foo")) ; => ("foo" "bar") + +; Length é auto explicativo. +(length (1 2 3)) ; => 3 +(_ "foobar") ; => 6 + +;;;;;;;;;;;;;;; +; Delicadezas Haskell + +; Primeiro item de uma lista +(head (1 2 3)) ; => 1 +; Pega do segundo ao último elemento de uma lista +(tail (1 2 3)) ; => (2 3) +; Último item de uma lista +(last (1 2 3)) ; => 3 +; Contrário de `tail` +(init (1 2 3)) ; => (1 2) +; Pega do primeiro até o elemento especificado da lista +(take 1 (1 2 3 4)) ; (1 2) +; Contrário de `take` +(drop 1 (1 2 3 4)) ; (3 4) +; Menos valor em uma lista +(min (1 2 3 4)) ; 1 +; Maior valor em uma lista +(max (1 2 3 4)) ; 4 +; Verifica se o valor está em uma lista ou objeto +(elem 1 (1 2 3)) ; true +(elem "foo" {"foo" "bar"}) ; true +(elem "bar" {"foo" "bar"}) ; false +; Inverte a ordem de uma lista +(reverse (1 2 3 4)) ; => (4 3 2 1) +; Verifica se o valor é par ou ímpar +(even 1) ; => false +(odd 1) ; => true +; Separa um texto cortando por espaço em branco +(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese") +; Junta lista de textos +(unwords ("foo" "bar")) ; => "foobar" +; Sucessor e predecessor +(pred 21) ; => 20 +(succ 20) ; => 21 +``` + +Para mais informação, verifique o [repositório](http://github.com/L8D/whip) -- cgit v1.2.3 From ab84fe8cf57d42b78b4a6d441ebd47acc65bd520 Mon Sep 17 00:00:00 2001 From: Antonio Roberto Furlaneto Date: Wed, 25 Oct 2017 23:27:36 -0200 Subject: [c#/pt-br] Small typos --- pt-br/csharp-pt.html.markdown | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..377ac984 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -6,23 +6,23 @@ contributors: lang: pt-br --- -C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework. +C# é uma linguagem elegante, altamente tipada e orientada a objetos que permite aos desenvolvedores criar uma variedade de aplicações seguras e robustas que são executadas no .NET Framework. -[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx) +[Leia mais aqui.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx) ```c# -// Comentário de linha única começa com // +// Comentários de linha única começam com // /* -Múltipas linhas é desta forma +Comentários de múltiplas linhas são desta forma */ /// -/// Esta é uma documentação comentário XML que pode ser usado para gerar externo -/// documentação ou fornecer ajuda de contexto dentro de um IDE +/// Este é um comentário de documentação XML que pode ser usado para gerar documentação +/// externa ou para fornecer ajuda de contexto dentro de uma IDE /// //public void MethodOrClassOrOtherWithParsableHelp() {} -// Especificar qual namespace seu código irá usar -// Os namespaces a seguir são padrões do .NET Framework Class Library +// Especifica os namespaces que o código irá usar +// Os namespaces a seguir são padrões da biblioteca de classes do .NET Framework using System; using System.Collections.Generic; using System.Dynamic; @@ -33,11 +33,11 @@ using System.IO; // Mas este aqui não é : using System.Data.Entity; -// Para que consiga utiliza-lo, você precisa adicionar novas referências +// Para que consiga utilizá-lo, você precisa adicionar novas referências // Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework` -// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos" -// Usando este código a partir de outra arquivo de origem: using Learning.CSharp; +// Namespaces são escopos definidos para organizar o código em "pacotes" ou "módulos" +// Usando este código a partir de outro arquivo de origem: using Learning.CSharp; namespace Learning.CSharp { // Cada .cs deve conter uma classe com o mesmo nome do arquivo -- cgit v1.2.3 From 5670c7381dbffa12b3d2b5e51ac9b8b1c4d9dca1 Mon Sep 17 00:00:00 2001 From: Fer Date: Thu, 26 Oct 2017 11:22:40 -0200 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..800e3097 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -823,7 +823,7 @@ on a new line! ""Wow!"", the masses cried"; } } - // Interfaces only contain signatures of the members, without the implementation. + // Interfaces contêm apenas as assinaturas dos membros, sem a implementação. interface IJumpable { void Jump(int meters); // all interface members are implicitly public -- cgit v1.2.3 From 9f7322b6208a693a013df81da6b1aadd095b78fd Mon Sep 17 00:00:00 2001 From: Fer Date: Thu, 26 Oct 2017 12:39:25 -0200 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..3f13f1aa 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -784,7 +784,7 @@ on a new line! ""Wow!"", the masses cried"; } // end class Bicycle - // PennyFarthing is a subclass of Bicycle + // PennyFarthing é uma subclasse de Bicycle class PennyFarthing : Bicycle { // (Penny Farthings are those bicycles with the big front wheel. -- cgit v1.2.3 From b5cac96eff8d92f9fb736d6e3e61d21d771f1e2a Mon Sep 17 00:00:00 2001 From: Fer Date: Thu, 26 Oct 2017 12:44:09 -0200 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..cc3885d2 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -790,7 +790,7 @@ on a new line! ""Wow!"", the masses cried"; // (Penny Farthings are those bicycles with the big front wheel. // They have no gears.) - // calling parent constructor + // chamando construtor pai public PennyFarthing(int startCadence, int startSpeed) : base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) { -- cgit v1.2.3 From ee3f34379abd8bea7274d024571b8596c6c759d4 Mon Sep 17 00:00:00 2001 From: Fer Date: Thu, 26 Oct 2017 12:47:42 -0200 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 547f4817..a1bd980b 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -762,7 +762,7 @@ on a new line! ""Wow!"", the masses cried"; } } - //Method to display the attribute values of this Object. + //Método para exibir os valores dos atributos deste objeto. public virtual string Info() { return "Gear: " + Gear + -- cgit v1.2.3 From 18eb083fb64c77b6cf4aec36686a7058f2b03fdc Mon Sep 17 00:00:00 2001 From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com> Date: Thu, 26 Oct 2017 13:42:44 -0200 Subject: [css/pt-br] Missing translation --- pt-br/css-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown index b1fbd961..956b3614 100644 --- a/pt-br/css-pt.html.markdown +++ b/pt-br/css-pt.html.markdown @@ -25,7 +25,7 @@ O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais. ```css /* Comentários aparecem dentro do slash-asterisk, tal como esta linha! - não há "comentários de uma linha"; este é o único estilo de comentário * / + Não há "comentários de uma linha"; este é o único estilo de comentário * / /* #################### ## SELETORES -- cgit v1.2.3 From 12d4277200728b24c11da63d069c30ba555ac49c Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Thu, 26 Oct 2017 13:48:09 -0200 Subject: [c++/pt-br] Small typos --- pt-br/c++-pt.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 09bfc825..cd4adde7 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -18,9 +18,9 @@ foi concebida para - suportar programação orientada a objetos - suportar programação genérica -Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais -recentes, C++ é amplamente utilizado porque compila para instruções nativas que -podem ser executadas diretamente pelo processador e oferece um controle rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os +Embora sua sintaxe possa ser mais difícil ou complexa do que as linguagens mais +recentes, C++ é amplamente utilizada porque compila para instruções nativas que +podem ser executadas diretamente pelo processador e oferece um controle rígido sobre o hardware (como C), enquanto oferece recursos de alto nível, como os genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade faz C++ uma das linguagens de programação mais utilizadas. -- cgit v1.2.3 From 469740c35f4059ece40887f881d27705a536e35f Mon Sep 17 00:00:00 2001 From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com> Date: Thu, 26 Oct 2017 13:51:16 -0200 Subject: [perl/pt-br] Missing translation --- pt-br/perl-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown index cc07a2ec..ff01c31a 100644 --- a/pt-br/perl-pt.html.markdown +++ b/pt-br/perl-pt.html.markdown @@ -52,7 +52,7 @@ my %fruta_cor = ( banana => "amarelo", ); -# Scalars, arrays and hashes são documentados mais profundamentes em perldata. +# Scalars, arrays and hashes são documentados mais profundamente em perldata. # (perldoc perldata). # Mais tipos de dados complexos podem ser construídas utilizando referências, -- cgit v1.2.3 From e787065d76fdf9eeba2747e3b5baaadd532156da Mon Sep 17 00:00:00 2001 From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com> Date: Thu, 26 Oct 2017 13:52:52 -0200 Subject: [perl/pt-br] Missing translation --- pt-br/perl-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown index cc07a2ec..19a72635 100644 --- a/pt-br/perl-pt.html.markdown +++ b/pt-br/perl-pt.html.markdown @@ -55,7 +55,7 @@ my %fruta_cor = ( # Scalars, arrays and hashes são documentados mais profundamentes em perldata. # (perldoc perldata). -# Mais tipos de dados complexos podem ser construídas utilizando referências, +# Mais tipos de dados complexos podem ser construídos utilizando referências, # o que permite que você crie listas e hashes dentro de listas e hashes. #### Condicionais e construtores de iteração -- cgit v1.2.3 From adb4fb69ad4554665d9708ca3e82b22464dbb98f Mon Sep 17 00:00:00 2001 From: lbertolazzi <33129418+lbertolazzi@users.noreply.github.com> Date: Thu, 26 Oct 2017 13:55:43 -0200 Subject: [perl/pt-br] Missing translation --- pt-br/perl-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/perl-pt.html.markdown b/pt-br/perl-pt.html.markdown index cc07a2ec..c1e6e76f 100644 --- a/pt-br/perl-pt.html.markdown +++ b/pt-br/perl-pt.html.markdown @@ -21,7 +21,7 @@ Perl 5 roda em mais de 100 plataformas, de portáteis a mainframes e é adequada # Variáveis iniciam com um sigilo, que é um símbolo que mostra o tipo. # Um nome de variável válido começa com uma letra ou sublinhado, -# seguido por qualquer número de letras, números ou sublinhados. +# seguido por qualquer quantidade de letras, números ou sublinhados. ### Perl has three main variable types: $scalar, @array, e %hash. -- cgit v1.2.3 From 1569318bdcfea0c486cd2fa6a374446fe6ae02c0 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Thu, 26 Oct 2017 14:11:13 -0200 Subject: [c++/pt-br] Small typos --- pt-br/c-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index c0cfb0ba..0dca7ab0 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -182,7 +182,7 @@ int main() { int a, b, c; a = b = c = 0; - // Aritimética é óbvia + // Aritmética é óbvia i1 + i2; // => 3 i2 - i1; // => 1 i2 * i1; // => 2 -- cgit v1.2.3 From 189336c674856a036112b9b32a6254b07aa6aa75 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Thu, 26 Oct 2017 14:21:20 -0200 Subject: [visualbasic/pt-br] Small typos --- pt-br/visualbasic-pt.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'pt-br') diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown index 76cca567..b94ab609 100644 --- a/pt-br/visualbasic-pt.html.markdown +++ b/pt-br/visualbasic-pt.html.markdown @@ -15,9 +15,9 @@ module Module1 Sub Main () ' Uma visão geral de console de aplicativos do Visual Basic antes de - ' mergulharmos mais profundamente na linguagem + ' mergulharmos mais profundamente na linguagem. ' Aspas simples começam comentários. - ' Para Navegar este tutorial dentro do compilador do Visual Basic, + ' Para navegar neste tutorial dentro do compilador do Visual Basic, ' eu criei um sistema de navegação. ' Este sistema de navegação vai ser explicado conforme avançarmos no ' tutorial, e você vai entender o que isso significa. @@ -93,16 +93,16 @@ module Module1 Private Sub HelloWorldInput () Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes" ' Variáveis - 'Os dados inseridos por um usuário precisa ser armazenada . + 'Os dados inseridos por um usuário precisam ser armazenados. ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType . - ' Neste tutorial, nós queremos saber o que o seu nome, e faça o programa + ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa ' Responder ao que é dito. Nome de usuário Dim As String " Nós usamos string como string é uma variável de texto baseado . Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome. - username = Console.ReadLine () ' armazena o nome usuários. - Console.WriteLine (" Olá " + nome do usuário) " A saída é Olá ' Seu nome ' + username = Console.ReadLine () ' armazena o nome do usuário. + Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >". Console.ReadLine () ' Outsputs acima. ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta. " Outras variáveis ​​incluem Integer e usamos inteiro para números inteiros. -- cgit v1.2.3 From c14dc8fd1d0f04b90c9e5195bb21acc88f90e05b Mon Sep 17 00:00:00 2001 From: Fer Date: Fri, 27 Oct 2017 07:55:22 -0200 Subject: Update csharp-pt.html.markdown --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 800e3097..a6e82211 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -826,7 +826,7 @@ on a new line! ""Wow!"", the masses cried"; // Interfaces contêm apenas as assinaturas dos membros, sem a implementação. interface IJumpable { - void Jump(int meters); // all interface members are implicitly public + void Jump(int meters); // todos os membros da interface são implicitamente públicos } interface IBreakable -- cgit v1.2.3 From e063c7ef3556cc3b8fc2515a8175474461c83a2d Mon Sep 17 00:00:00 2001 From: Fer Date: Fri, 27 Oct 2017 08:03:05 -0200 Subject: Update csharp-pt.html.markdown --- pt-br/csharp-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 3f13f1aa..8d34d772 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -787,8 +787,8 @@ on a new line! ""Wow!"", the masses cried"; // PennyFarthing é uma subclasse de Bicycle class PennyFarthing : Bicycle { - // (Penny Farthings are those bicycles with the big front wheel. - // They have no gears.) + // (Penny Farthings são aquelas bicicletas com uma grande roda frontal. + // Elas não tem correias.) // calling parent constructor public PennyFarthing(int startCadence, int startSpeed) : -- cgit v1.2.3 From 46fab3c0be2852661fb972555a20c9f7083ad17d Mon Sep 17 00:00:00 2001 From: milenaduo <33162200+milenaduo@users.noreply.github.com> Date: Fri, 27 Oct 2017 16:20:32 -0200 Subject: [dynamic-programming/pt-br] - Small typos --- pt-br/dynamic-programming-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 8de9bee6..b4ace9a4 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -22,7 +22,7 @@ Sempre se lembre!! ## Maneiras de Solucionar tais Problemas -1. Top-Down (De cima para baixo): Começe solucionando o problema quebrando-o em +1. Top-Down (De cima para baixo): Comece solucionando o problema quebrando-o em partes. Se você perceber que o problema já foi resolvido, então simplemente pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente -- cgit v1.2.3 From 1504f4af99ef6811158c270143e035bc6ac3eed4 Mon Sep 17 00:00:00 2001 From: milenaduo <33162200+milenaduo@users.noreply.github.com> Date: Fri, 27 Oct 2017 16:21:48 -0200 Subject: [dynamic-programming/pt-br] - Small typos --- pt-br/dynamic-programming-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 8de9bee6..a90b11ec 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -29,7 +29,7 @@ resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente referenciado como Memorização. 2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os -subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, +subproblemas são resolvidos e comece a solucionar dos problemas mais triviais, até o problema dado. Neste processo, é garantido que os subproblemas são resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica. -- cgit v1.2.3 From 01bcf645997fbea7b5b6d8e5ffb01b9d9c5fc7a6 Mon Sep 17 00:00:00 2001 From: milenaduo <33162200+milenaduo@users.noreply.github.com> Date: Fri, 27 Oct 2017 16:22:50 -0200 Subject: [dynamic-programming/pt-br] - Small typos --- pt-br/dynamic-programming-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 8de9bee6..40e6fda2 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -31,7 +31,7 @@ referenciado como Memorização. 2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, até o problema dado. Neste processo, é garantido que os subproblemas são -resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica. +resolvidos antes de resolver o problema. Isto é referenciado como Programação Dinâmica. ## Exemplo de Programação Dinâmica -- cgit v1.2.3 From 5f5dd74260efd76af39262c1608cd3c3e14f5576 Mon Sep 17 00:00:00 2001 From: milenaduo <33162200+milenaduo@users.noreply.github.com> Date: Fri, 27 Oct 2017 16:29:00 -0200 Subject: [dynamic-programming/pt-br] - Better reading --- pt-br/dynamic-programming-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 8de9bee6..45b52790 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -51,7 +51,7 @@ array antecedente e uma variável como maiorSequenciasAteAgora e seu índice ajudariam a poupar muito tempo. Um conceito similar poderia ser aplicado ao procurar o maior caminho em um grafo acíclico dirigido. ---------------------------------------------------------------------------- + ``` for i=0 to n-1 LS[i]=1 @@ -62,7 +62,7 @@ grafo acíclico dirigido. if (largest < LS[i]) ``` -### Alguns Problemas Famosos de Programação Dinâmica +## Alguns Problemas Famosos de Programação Dinâmica ``` Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code -- cgit v1.2.3 From c52ae61127b9b50f39e45876c672ed73ce4e2125 Mon Sep 17 00:00:00 2001 From: andys8 Date: Sat, 23 Dec 2017 11:57:45 +0100 Subject: [elm] Update code to access tuples --- pt-br/elm-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown index 78a4f1b7..d2469a93 100644 --- a/pt-br/elm-pt.html.markdown +++ b/pt-br/elm-pt.html.markdown @@ -76,8 +76,8 @@ List.head [] -- Nothing -- Acesse os elementos de um par com as funções first e second. -- (Este é um atalho; nós iremos para o "caminho real" em breve.) -fst ("elm", 42) -- "elm" -snd ("elm", 42) -- 42 +Tuple.first ("elm", 42) -- "elm" +Tuple.second ("elm", 42) -- 42 -- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder. -- É o único valor de seu tipo, também chamado de "Unit". -- cgit v1.2.3 From d28abc39451bf1b075945d46ab372bb30f8b59fa Mon Sep 17 00:00:00 2001 From: suuuzi Date: Sun, 31 Dec 2017 14:35:07 -0200 Subject: updating BF translation --- pt-br/bf-pt.html.markdown | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown index 52a5269e..53baa9a2 100644 --- a/pt-br/bf-pt.html.markdown +++ b/pt-br/bf-pt.html.markdown @@ -13,7 +13,9 @@ lang: pt-br Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de programação Turing-completa extremamente simples com apenas 8 comandos. -``` +Você pode experimentar brainfuck pelo seu browser com [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). + +```bf Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado. Brainfuck é representado por um vetor com 30 000 células inicializadas em zero -- cgit v1.2.3 From a26d106ed72e7d4a391e73496cc65e0f7b559111 Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Wed, 28 Feb 2018 16:12:00 +0545 Subject: Fix language name --- pt-br/bf-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown index 53baa9a2..c69995ab 100644 --- a/pt-br/bf-pt.html.markdown +++ b/pt-br/bf-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: bf +language: Brainfuck filename: learnbf-pt.bf contributors: - ["Prajit Ramachandran", "http://prajitr.github.io/"] -- cgit v1.2.3 From 5ae8ac9988522f290460e7341c303964fb4581bc Mon Sep 17 00:00:00 2001 From: Junior Damacena Date: Wed, 28 Feb 2018 11:21:47 -0300 Subject: [Dart/pt-br] Translated Dart to pt-BR (#3071) * Added PT-BR translation to Dart * Translation in progress * Translation in progress * Moving the file to the correct language folder * Translation in progress * Translation finished * Small adjustments * File renamed to follow the naming convention * Adjustments according to suggestions on the pull request --- pt-br/dart-pt.html.markdown | 508 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 508 insertions(+) create mode 100644 pt-br/dart-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown new file mode 100644 index 00000000..c127034c --- /dev/null +++ b/pt-br/dart-pt.html.markdown @@ -0,0 +1,508 @@ +--- +language: dart +filename: learndart-pt.dart +contributors: + - ["Joao Pedrosa", "https://github.com/jpedrosa/"] +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. + +A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos. + +```dart +import "dart:collection"; +import "dart:math" as DM; + +// Bem vindo ao Aprenda Dart em 15 minutos. http://www.dartlang.org/ +// Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no +// site Try Dart!, é só copiar e colar este código lá. http://try.dartlang.org/ + +// Declarações de funções e métodos são iguais. Declarações de funções +// podem ser aninhadas. A declaração é feita das seguintes formas +// nome() {} ou nome() => expressaoDeUmaLinhaSo; +// A declaração feita com a seta tem um return implícito para o resultado da +// expressão. +example1() { + example1nested1() { + example1nested2() => print("Example1 nested 1 nested 2"); + example1nested2(); + } + example1nested1(); +} + +// Funções anônimas são criadas sem um nome. +example2() { + example2nested1(fn) { + fn(); + } + example2nested1(() => print("Example2 nested 1")); +} + +// Quando uma função é declarada como parâmetro, a declaração pode incluir o número +// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos +// parâmetros que serão recebidos pela função. +example3() { + example3nested1(fn(informSomething)) { + fn("Example3 nested 1"); + } + example3planB(fn) { // Ou não declare o número de parâmetros. + fn("Example3 plan B"); + } + example3nested1((s) => print(s)); + example3planB((s) => print(s)); +} + +// Funções têm acesso à variáveis fora de seu escopo +var example4Something = "Example4 nested 1"; +example4() { + example4nested1(fn(informSomething)) { + fn(example4Something); + } + example4nested1((s) => print(s)); +} + +// Declaração de classe com um método chamado sayIt, que também tem acesso +// à variável externa, como se fosse uma função como se viu antes. +var example5method = "Example5 sayIt"; +class Example5Class { + sayIt() { + print(example5method); + } +} +example5() { + // Criar uma instância anônima de Example5Class e chamar o método sayIt + // nela. + new Example5Class().sayIt(); +} + +// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }. +// onde classBody pode incluir métodos e variáveis de instância, assim como +// métodos e variáveis de classe. +class Example6Class { + var example6InstanceVariable = "Example6 instance variable"; + sayIt() { + print(example6InstanceVariable); + } +} +example6() { + new Example6Class().sayIt(); +} + +// Métodos e variáveis de classe são declarados como "static". +class Example7Class { + static var example7ClassVariable = "Example7 class variable"; + static sayItFromClass() { + print(example7ClassVariable); + } + sayItFromInstance() { + print(example7ClassVariable); + } +} +example7() { + Example7Class.sayItFromClass(); + new Example7Class().sayItFromInstance(); +} + +// Literais são ótimos, mas há uma limitação para o que eles podem ser +// quando estão fora do corpo de uma função/método. Literais fora do escopo da classe +// ou fora da classe têm que ser constantes. Strings e números são constantes +// por padrão. Mas arrays e mapas não. Eles podem ser declarados como constantes +// usando o comando "const". +var example8A = const ["Example8 const array"], + example8M = const {"someKey": "Example8 const map"}; +example8() { + print(example8A[0]); + print(example8M["someKey"]); +} + +// Loops em Dart são criados com for () {} ou while () {}, +// um pouco mais moderno temos for (.. in ..) {}, ou funções de callbacks com muitas +// funcionalidades, começando com o forEach. +var example9A = const ["a", "b"]; +example9() { + for (var i = 0; i < example9A.length; i++) { + print("Example9 for loop '${example9A[i]}'"); + } + var i = 0; + while (i < example9A.length) { + print("Example9 while loop '${example9A[i]}'"); + i++; + } + for (var e in example9A) { + print("Example9 for-in loop '${e}'"); + } + example9A.forEach((e) => print("Example9 forEach loop '${e}'")); +} + +// Para percorrer os caracteres de uma string ou extrair uma substring. +var example10S = "ab"; +example10() { + for (var i = 0; i < example10S.length; i++) { + print("Example10 String character loop '${example10S[i]}'"); + } + for (var i = 0; i < example10S.length; i++) { + print("Example10 substring loop '${example10S.substring(i, i + 1)}'"); + } +} + +// Int e double são os dois formatos de número suportados. +example11() { + var i = 1 + 320, d = 3.2 + 0.01; + print("Example11 int ${i}"); + print("Example11 double ${d}"); +} + +// DateTime traz operações com data/hora. +example12() { + var now = new DateTime.now(); + print("Example12 now '${now}'"); + now = now.add(new Duration(days: 1)); + print("Example12 tomorrow '${now}'"); +} + +// Expressões regulares são suportadas. +example13() { + var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$"); + match(s) { + if (re.hasMatch(s)) { + print("Example13 regexp matches '${s}'"); + } else { + print("Example13 regexp doesn't match '${s}'"); + } + } + match(s1); + match(s2); +} + +// Expressões booleanas precisam retornar ou true ou false, já que +// Dart não faz a conversão implicitamente. +example14() { + var v = true; + if (v) { + print("Example14 value is true"); + } + v = null; + try { + if (v) { + // Nunca seria executada + } else { + // Nunca seria executada + } + } catch (e) { + print("Example14 null value causes an exception: '${e}'"); + } +} + +// try/catch/finally e throw são usados para tratamento de exceções. +// throw aceita qualquer objeto como parâmetro; +example15() { + try { + try { + throw "Some unexpected error."; + } catch (e) { + print("Example15 an exception: '${e}'"); + throw e; // Re-throw + } + } catch (e) { + print("Example15 catch exception being re-thrown: '${e}'"); + } finally { + print("Example15 Still run finally"); + } +} + +// Para mais eficiência ao criar strings longas dinamicamente, use o +// StringBuffer. Ou você pode também concatenar um array de strings. +example16() { + var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e; + for (e in a) { sb.write(e); } + print("Example16 dynamic string created with " + "StringBuffer '${sb.toString()}'"); + print("Example16 join string array '${a.join()}'"); +} + +// Strings podem ser concatenadas apenas colocando strings literais uma perto +// da outra, sem necessidade de nenhum outro operador. +example17() { + print("Example17 " + "concatenar " + "strings " + "é simples assim"); +} + +// Strings podem ser delimitadas por apóstrofos ou aspas e não há +// diferença entre os dois. Essa flexibilidade pode ser boa para +// evitar a necessidade de escapar conteúdos que contenham o delimitador da string. +// Por exemplo, aspas dos atributos HTMLse a string conter HTML. +example18() { + print('Example18 ' + "Don't can't I'm Etc" + ''); +} + +// Strings com três apóstrofos ou aspas podem +// ter muitas linhas e incluem os delimitadores de linha (ou seja, os enter). +example19() { + print('''Example19 +Example19 Don't can't I'm Etc +Example19 '''); +} + +// Strings têm a função de interpolação que é chamada com o caractere $. +// Com $ { [expression] }, o retorno da expressão é interpolado. +// $ seguido pelo nome de uma variável interpola o conteúdo dessa variável. +// $ pode ser escapedo assim \$. +example20() { + var s1 = "'\${s}'", s2 = "'\$s'"; + print("Example20 \$ interpolation ${s1} or $s2 works."); +} + +// A tipagem opcional permite que APIs usem anotações e também ajuda os +// IDEs na hora das refatorações, auto-complete e checagem de +// erros. Note que até agora não declaramos nenhum tipo e o programa está +// funcionando normalmente. De fato, os tipos são ignorados em tempo de execução. +// Os tipos podem até mesmo estarem errados e o programa ainda vai dar o +// benefício da dúvida e rodar, visto que os tipos não importam. +// Existe um parâmetro que checa erros de tipagem que é o +// checked mode, dizem que é útil enquanto se está desenvolvendo, +// mas também é mais lento devido às checagens extras e por isso +// é evitado em ambiente de produção. +class Example21 { + List _names; + Example21() { + _names = ["a", "b"]; + } + List get names => _names; + set names(List list) { + _names = list; + } + int get length => _names.length; + void add(String name) { + _names.add(name); + } +} +void example21() { + Example21 o = new Example21(); + o.add("c"); + print("Example21 names '${o.names}' and length '${o.length}'"); + o.names = ["d", "e"]; + print("Example21 names '${o.names}' and length '${o.length}'"); +} + +// Herança em classes é feito assim: class name extends AnotherClassName {}. +class Example22A { + var _name = "Some Name!"; + get name => _name; +} +class Example22B extends Example22A {} +example22() { + var o = new Example22B(); + print("Example22 class inheritance '${o.name}'"); +} + +// Mistura de classes também é possível, e é feito assim: +// class name extends SomeClass with AnotherClassName {} +// É necessário extender uma classe para poder misturar com outra. +// No momento, classes misturadas não podem ter construtor. +// Mistura de classes é mais usado para compartilhar métodos com classes distantes, então +// a herança comum não fica no caminho do reuso de código. +// As misturas aparecem após o comando "with" na declaração da classe. +class Example23A {} +class Example23Utils { + addTwo(n1, n2) { + return n1 + n2; + } +} +class Example23B extends Example23A with Example23Utils { + addThree(n1, n2, n3) { + return addTwo(n1, n2) + n3; + } +} +example23() { + var o = new Example23B(), r1 = o.addThree(1, 2, 3), + r2 = o.addTwo(1, 2); + print("Example23 addThree(1, 2, 3) results in '${r1}'"); + print("Example23 addTwo(1, 2) results in '${r2}'"); +} + +// O método construtor da classe usa o mesmo nome da classe e +// é feito assim SomeClass() : super() {}, onde a parte ": super()" +// é opcional e é usada para passar parâmetros estáticos para o +// construtor da classe pai. +class Example24A { + var _value; + Example24A({value: "someValue"}) { + _value = value; + } + get value => _value; +} +class Example24B extends Example24A { + Example24B({value: "someOtherValue"}) : super(value: value); +} +example24() { + var o1 = new Example24B(), + o2 = new Example24B(value: "evenMore"); + print("Example24 calling super during constructor '${o1.value}'"); + print("Example24 calling super during constructor '${o2.value}'"); +} + +// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples. +// Simplesmente use o prefixo this.nomeDoParametro e isso irá passar o parâmetro para uma +// instância de variável de mesmo nome. +class Example25 { + var value, anotherValue; + Example25({this.value, this.anotherValue}); +} +example25() { + var o = new Example25(value: "a", anotherValue: "b"); + print("Example25 shortcut for constructor '${o.value}' and " + "'${o.anotherValue}'"); +} + +// Parâmetros com nome estão disponíveis quando declarados entre {}. +// Quando os parâmetros têm nomes, eles podem ser passados em qualquer ordem. +// Parâmetros declarados entre [] são opcionais. +example26() { + var _name, _surname, _email; + setConfig1({name, surname}) { + _name = name; + _surname = surname; + } + setConfig2(name, [surname, email]) { + _name = name; + _surname = surname; + _email = email; + } + setConfig1(surname: "Doe", name: "John"); + print("Example26 name '${_name}', surname '${_surname}', " + "email '${_email}'"); + setConfig2("Mary", "Jane"); + print("Example26 name '${_name}', surname '${_surname}', " + "email '${_email}'"); +} + +// Variáveis declaradas com um final só podem receber valor uma vez. +// No caso de classes, variáveis final podem ter valor atribuido através +// de um parâmetro no construtor +class Example27 { + final color1, color2; + // Um pouco de flexibilidade ao criar variáveis final com a sintaxe + // que é a seguinte: + Example27({this.color1, color2}) : color2 = color2; +} +example27() { + final color = "orange", o = new Example27(color1: "lilac", color2: "white"); + print("Example27 color is '${color}'"); + print("Example27 color is '${o.color1}' and '${o.color2}'"); +} + +// para importar uma biblioteca, use import "libraryPath" ou se for uma biblioteca da linguagem, +// import "dart:libraryName". Também tem o gerenciador de pacotes "pub"que tem +// sua própria convenção de import "package:packageName". +// Veja o import "dart:collection"; no início do arquivo. Imports devem vir no início +// do arquivo. IterableBase vem de dart:collection. +class Example28 extends IterableBase { + var names; + Example28() { + names = ["a", "b"]; + } + get iterator => names.iterator; +} +example28() { + var o = new Example28(); + o.forEach((name) => print("Example28 '${name}'")); +} + +// Para controle de fluxo nós temos: +// * switch com comandos break obrigatórios +// * if-else if-else e se-ternário ..?..:.. +// * closures e funções anônimas +// * comandos break, continue e return +example29() { + var v = true ? 30 : 60; + switch (v) { + case 30: + print("Example29 switch statement"); + break; + } + if (v < 30) { + } else if (v > 30) { + } else { + print("Example29 if-else statement"); + } + callItForMe(fn()) { + return fn(); + } + rand() { + v = new DM.Random().nextInt(50); + return v; + } + while (true) { + print("Example29 callItForMe(rand) '${callItForMe(rand)}'"); + if (v != 30) { + break; + } else { + continue; + } + // Nunca chega aqui. + } +} + +// Você pode converter string para int, double para int, ou só pegar a parte inteira da divisão +// usando o comando ~/. Vamos jogar um jogo de adivinhação. +example30() { + var gn, tooHigh = false, + n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0; + top = top ~/ 6; + gn = new DM.Random().nextInt(top + 1); // +1 porque o máximo do nextInt conta o número passado - 1 + print("Example30 Diga um número entre 0 e ${top}"); + guessNumber(i) { + if (n == gn) { + print("Example30 Você acertou! O número é ${gn}"); + } else { + tooHigh = n > gn; + print("Example30 O número ${n} é muito " + "${tooHigh ? 'alto' : 'baixo'}. Tente de novo"); + } + return n == gn; + } + n = (top - bottom) ~/ 2; + while (!guessNumber(n)) { + if (tooHigh) { + top = n - 1; + } else { + bottom = n + 1; + } + n = bottom + ((top - bottom) ~/ 2); + } +} + +// Programas em Dart só têm um ponto de entrada, que é a função main. +// Nada será executado antes da funcão main de um programa. +// Isso ajuda a carregar o programa mais rapidamente, até mesmo quando o +// carregamento é "Lazy". +// O programa deve começar com: +main() { + print("Aprenda Dart em 15 minutos!"); + [example1, example2, example3, example4, example5, example6, example7, + example8, example9, example10, example11, example12, example13, example14, + example15, example16, example17, example18, example19, example20, + example21, example22, example23, example24, example25, example26, + example27, example28, example29, example30 + ].forEach((ef) => ef()); +} + +``` + +## Continue lendo + +Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma +opção muito útil de testar o Dart online. +http://www.dartlang.org/ +http://try.dartlang.org/ + + + -- cgit v1.2.3 From 784bc7a9bd18b78b344e5fa4057df430ba042e0e Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Wed, 28 Feb 2018 20:18:45 +0545 Subject: Fix URLs --- pt-br/dart-pt.html.markdown | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown index c127034c..e9d72850 100644 --- a/pt-br/dart-pt.html.markdown +++ b/pt-br/dart-pt.html.markdown @@ -501,8 +501,9 @@ main() { Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma opção muito útil de testar o Dart online. -http://www.dartlang.org/ -http://try.dartlang.org/ +* [https://www.dartlang.org](https://www.dartlang.org) +* [https://try.dartlang.org](https://try.dartlang.org) + -- cgit v1.2.3 From caa8993076365c3e650e82a3c5c970dca25ed4c4 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Sun, 4 Mar 2018 19:48:44 -0800 Subject: Assorted fixes --- pt-br/common-lisp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown index 03a7c15c..c3381824 100644 --- a/pt-br/common-lisp-pt.html.markdown +++ b/pt-br/common-lisp-pt.html.markdown @@ -19,7 +19,7 @@ Outro livro recente e popular é o [Land of Lisp](http://landoflisp.com/). -```common_lisp +```common-lisp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 0. Sintaxe -- cgit v1.2.3 From 8330d94dedd8c5636fe4bba83d3a767acecb982f Mon Sep 17 00:00:00 2001 From: meleu Date: Thu, 8 Mar 2018 00:44:18 -0300 Subject: small typo and better translated words --- pt-br/c-pt.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index 0dca7ab0..d594b7b9 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -638,16 +638,17 @@ typedef void (*minha_função_type)(char *); ## Leitura adicional É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language). -Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem, -ideias que não são consideradas boas hoje) ou práticas mudadas. +Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem, +ideias que não são mais consideradas boas) ou práticas ultrapassadas. Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/). Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com). É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral. -Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja +Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e sensato, veja [Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle). Além disso, Google é teu amigo. + [1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member -- cgit v1.2.3 From f5bdb745a5471a5f3c292e482b627b85db53fbd1 Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Wed, 14 Mar 2018 08:44:44 +0545 Subject: Update bf-pt.html.markdown --- pt-br/bf-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/bf-pt.html.markdown b/pt-br/bf-pt.html.markdown index c69995ab..53baa9a2 100644 --- a/pt-br/bf-pt.html.markdown +++ b/pt-br/bf-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: Brainfuck +language: bf filename: learnbf-pt.bf contributors: - ["Prajit Ramachandran", "http://prajitr.github.io/"] -- cgit v1.2.3 From d375092374d0a71f95e3a418c08236a68426dad0 Mon Sep 17 00:00:00 2001 From: Aleksandr Mazurik Date: Sat, 28 Jul 2018 21:48:25 +0300 Subject: [awk/en] Fix atan2 args order --- pt-br/awk-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown index 75b73abe..761f5294 100644 --- a/pt-br/awk-pt.html.markdown +++ b/pt-br/awk-pt.html.markdown @@ -171,7 +171,7 @@ function arithmetic_functions(a, b, c, d) { # Muitas implementações AWK possuem algumas funções trigonométricas padrão localvar = sin(a) localvar = cos(a) - localvar = atan2(a, b) # arco-tangente de b / a + localvar = atan2(b, a) # arco-tangente de b / a # E conteúdo logarítmico localvar = exp(a) -- cgit v1.2.3 From e4894a56ff15f1aaa3fa5716fa75499237e96aa9 Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Wed, 15 Aug 2018 17:11:27 +0530 Subject: Fix build error in 'build/docs/pt-br/markdown-pt/index.html' --- pt-br/markdown-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown index f22093f9..c2aa515d 100644 --- a/pt-br/markdown-pt.html.markdown +++ b/pt-br/markdown-pt.html.markdown @@ -14,7 +14,7 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e puxar o projeto (pull request) -```markdown +```md + + + + + + + + + Meu Site + + +

Olá, mundo!

+ Venha ver como isso aparece +

Esse é um parágrafo.

+

Esse é um outro parágrafo.

+
    +
  • Esse é um item de uma lista não enumerada (bullet list)
    • +
  • Esse é um outro item
    • +
  • E esse é o último item da lista
    • +
+ + + + + + + + + + + + + + + + + + + + + Meu Site + + + + + + + +

Olá, mundo!

+ + Venha ver o que isso exibe +

Esse é um parágrafo.

+

Esse é um outro parágrafo.

+
    + +
  • Esse é um item de uma lista não-enumerada.
    • +
  • Esse é um outro item
    • +
  • E esse é o último item da lista
    • +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Primeiro cabeçalho Segundo cabeçalho
Primeira linha, primeira coluna Primeira linha, segunda coluna
Segunda linha, primeira colunaSegunda linha, segunda coluna
+ +``` + +## Uso + +HTML é escrito em arquivos com a extensão `.html` ou `.htm`. Seu mime type é `text/html`. + +## Para aprender mais + +* [wikipedia](https://en.wikipedia.org/wiki/HTML) +* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML) +* [W3School](http://www.w3schools.com/html/html_intro.asp) -- cgit v1.2.3 From 1c932a33f99149f6be77aa0de07abc1aedbc0d74 Mon Sep 17 00:00:00 2001 From: Lucas Pugliesi Date: Fri, 12 Oct 2018 22:49:15 -0300 Subject: [cmake/pt-br] Add portuguese language for cmake --- pt-br/cmake-pt.html.markdown | 178 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 pt-br/cmake-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown new file mode 100644 index 00000000..bc3e7050 --- /dev/null +++ b/pt-br/cmake-pt.html.markdown @@ -0,0 +1,178 @@ +--- +language: cmake +contributors: + - ["Bruno Alano", "https://github.com/brunoalano"] +filename: CMake +translators: + - ["Lucas Pugliesi", "https://github.com/fplucas"] +lang: pt-br +--- + +CMake é um programa de compilação open-source e multiplataforma. Essa ferramenta +permitirá testar, compilar e criar pacotes a partir do seu código fonte. + +O problema que o CMake tenta resolver são os problemas de configurar os Makefiles +e Autoconfigure (diferente dos interpretadores make que tem comandos diferentes) +e sua facilidade de uso envolvendo bibliotecas terceiras. + +CMake é um sistema open-source extensível que gerencia o processo de build em um +sistema operacional e um método independente de compilador. Diferente de sistemas +multiplataformas, CMake é designado a usar em conjunto ao ambiente de compilação +nativo. Seus simples arquivos de configuração localizados em seus diretórios +(chamados arquivos CMakeLists.txt) que são usados para gerar padrões de arquivos +de compilação (ex: makefiles no Unix e projetos em Windows MSVC) que são usados +de maneira simples. + +```cmake +# No CMake, isso é um comentário + +# Para rodar nosso código, iremos utilizar esses comandos: +# - mkdir build && cd build +# - cmake .. +# - make +# +# Com esses comandos, iremos seguir as melhores práticas para compilar em um +# subdiretório e na segunda linha pediremos ao CMake para gerar um novo Makefile +# independente de sistema operacional. E finalmente, rodar o comando make. + +#------------------------------------------------------------------------------ +# Básico +#------------------------------------------------------------------------------ +# +# O arquivo CMake deve ser chamado de "CMakeLists.txt". + +# Configura a versão mínima requerida do CMake para gerar o Makefile +cmake_minimum_required (VERSION 2.8) + +# Exibe FATAL_ERROR se a versão for menor que 2.8 +cmake_minimum_required (VERSION 2.8 FATAL_ERROR) + +# Configuramos o nome do nosso projeto. Mas antes disso, iremos alterar alguns +# diretórios em nome da convenção gerada pelo CMake. Podemos enviar a LANG do +# código como segundo parâmetro +project (learncmake C) + +# Configure o diretório do código do projeto (somente convenção) +set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) +set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} ) + +# Isso é muito útil para configurar a versão do nosso código no sistema de compilação +# usando um estilo `semver` +set (LEARN_CMAKE_VERSION_MAJOR 1) +set (LEARN_CMAKE_VERSION_MINOR 0) +set (LEARN_CMAKE_VERSION_PATCH 0) + +# Envie as variáveis (número da versão) para o cabeçalho de código-fonte +configure_file ( + "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in" + "${PROJECT_BINARY_DIR}/TutorialConfig.h" +) + +# Inclua Diretórios +# No GCC, isso irá invocar o comando "-I" +include_directories( include ) + +# Onde as bibliotecas adicionais estão instaladas? Nota: permite incluir o path +# aqui, na sequência as checagens irão resolver o resto +set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" ) + +# Condições +if ( CONDICAO ) + # reposta! + + # Informação incidental + message(STATUS "Minha mensagem") + + # Aviso CMake, continua processando + message(WARNING "Minha mensagem") + + # Aviso (dev) CMake, continua processando + message(AUTHOR_WARNING "Minha mensagem") + + # Erro CMake, continua processando, mas pula a geração + message(SEND_ERROR "Minha mensagem") + + # Erro CMake, para o processamento e a geração + message(FATAL_ERROR "Minha mensagem") +endif() + +if( CONDICAO ) + +elseif( CONDICAO ) + +else( CONDICAO ) + +endif( CONDICAO ) + +# Loops +foreach(loop_var arg1 arg2 ...) + COMANDO1(ARGS ...) + COMANDO2(ARGS ...) + ... +endforeach(loop_var) + +foreach(loop_var RANGE total) +foreach(loop_var RANGE start stop [step]) + +foreach(loop_var IN [LISTS [list1 [...]]] + [ITEMS [item1 [...]]]) + +while(condicao) + COMANDO1(ARGS ...) + COMANDO2(ARGS ...) + ... +endwhile(condicao) + + +# Operações Lógicas +if(FALSE AND (FALSE OR TRUE)) + message("Não exiba!") +endif() + +# Configure um cache normal, ou uma variável de ambiente com o dado valor. +# Se a opção PARENT_SCOPE for informada em uma variável que será setada no escopo +# acima do escopo corrente. +# `set( ... [PARENT_SCOPE])` + +# Como refencia variáveis dentro de aspas ou não, argumentos com strings vazias +# não serão setados +${nome_da_variavel} + +# Listas +# Configure a lista de arquivos código-fonte +set( LEARN_CMAKE_SOURCES + src/main.c + src/imagem.c + src/pather.c +) + +# Chama o compilador +# +# ${PROJECT_NAME} referencia ao Learn_CMake +add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} ) + +# Linka as bibliotecas +target_link_libraries( ${PROJECT_NAME} ${LIBS} m ) + +# Onde as bibliotecas adicionais serão instaladas? Nota: nos permite incluir o path +# aqui, em seguida os testes irão resolver o restante +set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" ) + +# Condição do compilador (gcc ; g++) +if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" ) + message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" ) + add_definitions( --std=c99 ) +endif() + +# Checa o Sistema Operacional +if( UNIX ) + set( LEARN_CMAKE_DEFINITIONS + "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" ) +endif() +``` + +### Mais Recursos + ++ [cmake tutorial](https://cmake.org/cmake-tutorial/) ++ [cmake documentation](https://cmake.org/documentation/) ++ [mastering cmake](http://amzn.com/1930934319/) -- cgit v1.2.3 From 44663fba02c5c5f1f70112c8a5a3610334ef90ee Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Sun, 14 Oct 2018 05:35:29 +0530 Subject: Fix links and list styling --- pt-br/c++-pt.html.markdown | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'pt-br') diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 2c15e92c..cefa2c64 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -609,7 +609,5 @@ h=sum(f,g); ``` Leitura Adicional: -Uma referência atualizada da linguagem pode ser encontrada em - - -Uma fonte adicional pode ser encontrada em +* Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp). +* Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com). -- cgit v1.2.3 From 99618d394e33c51ed8073b2dc013623442201c51 Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Sun, 14 Oct 2018 05:51:14 +0530 Subject: Add new link from 2242ad7 --- pt-br/c++-pt.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'pt-br') diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index cefa2c64..42a29991 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -611,3 +611,4 @@ Leitura Adicional: * Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp). * Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com). +* Um tutorial cobrindo o básico da linguagem e configurando o ambiente de codificação está disponível em [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb). -- cgit v1.2.3 From b3da5ca955bd3ad47ab6a7ec1c72f2b189b2335e Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Sun, 14 Oct 2018 06:07:03 +0530 Subject: Fix links --- pt-br/dynamic-programming-pt.html.markdown | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 84b055d9..518660a3 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -63,13 +63,11 @@ grafo acíclico dirigido. ``` ## Alguns Problemas Famosos de Programação Dinâmica -``` -Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code - -Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem -Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence -``` +- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]() +- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]() +- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]() + ## Recursos Online (EN) -- cgit v1.2.3 From cb88631777e409ad7358b39a9902c011a102f000 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Fri, 19 Oct 2018 21:27:51 -0300 Subject: [less/pt-br] Add portuguese language for less --- pt-br/less-pt.html.markdown | 390 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 390 insertions(+) create mode 100644 pt-br/less-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown new file mode 100644 index 00000000..679a2ed2 --- /dev/null +++ b/pt-br/less-pt.html.markdown @@ -0,0 +1,390 @@ +--- +language: less +filename: learnless.less +contributors: + - ["Saravanan Ganesh", "http://srrvnn.me"] + +lang: pt-br +--- + +Less é um pré-processador de CSS, que adiciona recursos como variáveis, aninhamento, mixins e muito mais. +Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam os desenvolvedores a escreverem código que pode ser mantido e DRY (não se repita). + +```css + + +//Comentários de linha única são removidos quando Less é compilado para CSS. + +/*Comentários de várias linhas são preservados.*/ + + + +/* Variáveis +==============================*/ + + +/* Você pode armazenar um valor de CSS (como uma cor) em uma variável. + Use o símbolo '@' para criar uma variável. */ + +@primary-color: #a3a4ff; +@secondary-color: #51527f; +@body-font: 'Roboto', sans-serif; + +/* Você pode usar as variáveis ​​em toda a sua folha de estilo. + Agora, se você quiser alterar uma cor, só precisa fazer a alteração uma vez. */ + +body { + background-color: @primary-color; + color: @secondary-color; + font-family: @body-font; +} + +/* Isso compilará para: */ + +body { + background-color: #a3a4ff; + color: #51527F; + font-family: 'Roboto', sans-serif; +} + + +/* Isso é muito mais sustentável do que ter que mudar a cor + cada vez que aparece em toda a sua folha de estilo. */ + + + +/* Mixins +==============================*/ + + +/* Se você achar que está escrevendo o mesmo código para mais de um + elemento, você pode querer reutilizá-lo facilmente. */ + +.center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +/* Você pode usar o mixin simplesmente adicionando o seletor como um estilo. */ + +div { + .center; + background-color: @primary-color; +} + +/* Que compilaria para: */ + +.center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #a3a4ff; +} + +/* Você pode omitir o código mixin de ser compilado adicionando parênteses + depois do seletor. */ + +.center() { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +div { + .center; + background-color: @primary-color; +} + +/* Que compilaria para: */ +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #a3a4ff; +} + + + +/* Aninhamento +==============================*/ + + +/* Less permite aninhar seletores nos seletores. */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: #f00; + } +} + +/* '&' será substituído pelo seletor pai. */ +/* Você também pode aninhar pseudo-classes. */ +/* Tenha em mente que o aninhamento excessivo tornará seu código menos sustentável. + As melhores práticas recomendam não ultrapassar 3 níveis de profundidade ao aninhar. + Por exemplo: */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: red; + + &:hover { + background-color: blue; + } + + a { + color: white; + } + } +} + +/* Compila para: */ + +ul { + list-style-type: none; + margin-top: 2em; +} + +ul li { + background-color: red; +} + +ul li:hover { + background-color: blue; +} + +ul li a { + color: white; +} + + + +/* Functions +==============================*/ + + +/* Less fornece funções que podem ser usadas para realizar uma variedade de + tarefas. Considere o seguinte: */ + +/* Funções podem ser invocadas usando seu nome e passando os + argumentos requeridos. */ + +body { + width: round(10.25px); +} + +.header { + background-color: lighten(#000, 0.5); +} + +.footer { + background-color: fadeout(#000, 0.25) +} + +/* Compila para: */ + +body { + width: 10px; +} + +.header { + background-color: #010101; +} + +.footer { + background-color: rgba(0, 0, 0, 0.75); +} + +/* Você também pode definir suas próprias funções. Funções são muito semelhantes às + mixins. Ao tentar escolher entre uma função ou a um mixin, lembre-se + que mixins são melhores para gerar CSS, enquanto as funções são melhores para + lógica que pode ser usada em todo o seu código Less. Os exemplos na + seção 'Operadores Matemáticos' são candidatos ideais para se tornarem funções reutilizáveis. */ + +/* Esta função calcula a média de dois números: */ + +.average(@x, @y) { + @average-result: ((@x + @y) / 2); +} + +div { + .average(16px, 50px); // "chama" o mixin + padding: @average-result; // use seu valor de "retorno" +} + +/* Compila para: */ + +div { + padding: 33px; +} + + + +/* Estender (herança) +==============================*/ + + +/* Estender é uma maneira de compartilhar as propriedades de um seletor com outro. */ + +.display { + height: 50px; +} + +.display-success { + &:extend(.display); + border-color: #22df56; +} + +/* Compila para: */ + +.display, +.display-success { + height: 50px; +} +.display-success { + border-color: #22df56; +} + +/* Estender uma instrução CSS é preferível para criar um mixin + por causa da maneira como agrupa as classes que compartilham + o mesmo estilo base. Se isso foi feito com um mixin, as propriedades + seriam duplicadas para cada declaração que + chamou o mixin. Embora isso não afete o seu fluxo de trabalho, + adicione o inchaço desnecessário aos arquivos criados pelo compilador Less. */ + + + +/* Parciais e Importações +==============================*/ + + +/* Less permite criar arquivos parciais. Isso pode ajudar a manter o seu + código Less modularizado. Arquivos parciais convencionalmente começam com um '_', + por exemplo. _reset.less. e são importados para um arquivo less principal que recebe + o css compilado. */ + +/* Considere o seguinte CSS que vamos colocar em um arquivo chamado _reset.less */ + +html, +body, +ul, +ol { + margin: 0; + padding: 0; +} + +/* Less disponibiliza @import que podem ser usadas para importar parciais em um arquivo. + Isso difere da declaração tradicional CSS @import que faz + outra solicitação HTTP para buscar o arquivo importado. Less leva o + arquivo importado e combina com o código compilado. */ + +@import 'reset'; + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + +/* Compila para: */ + +html, body, ul, ol { + margin: 0; + padding: 0; +} + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + + + +/* Operações Matemáticas +==============================*/ + + +/* Less fornece os seguintes operadores: +, -, *, / e %. Estes podem + ser úteis para calcular valores diretamente nos seus arquivos Less + para usar valores que você já calculou manualmente. Abaixo está um exemplo + de como configurar um design simples de duas colunas. */ + +@content-area: 960px; +@main-content: 600px; +@sidebar-content: 300px; + +@main-size: @main-content / @content-area * 100%; +@sidebar-size: @sidebar-content / @content-area * 100%; +@gutter: 100% - (@main-size + @sidebar-size); + +body { + width: 100%; +} + +.main-content { + width: @main-size; +} + +.sidebar { + width: @sidebar-size; +} + +.gutter { + width: @gutter; +} + +/* Compila para: */ + +body { + width: 100%; +} + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + +.gutter { + width: 6.25%; +} + + +``` + +## Pratique Less + +Se você quiser praticar com Less no seu navegador, confira: * [Codepen](http://codepen.io/) * [LESS2CSS](http://lesscss.org/less-preview/) + +## Compatibilidade + +Less pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo em CSS. Você deseja verificar +se o CSS que você está usando é compatível com seus navegadores de destino. + +[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificar a compatibilidade. + +## Leitura adicional +* [Documentação Oficial](http://lesscss.org/features/) +* [Less CSS - Guia do iniciante](http://www.hongkiat.com/blog/less-basic/) -- cgit v1.2.3 From 097fbf70761a8e525e574162b684e14e166f871b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Sat, 20 Oct 2018 23:10:56 -0300 Subject: [make/pt-br] Add portuguese language for make --- pt-br/make-pt.html.markdown | 242 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 pt-br/make-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown new file mode 100644 index 00000000..8e7603cc --- /dev/null +++ b/pt-br/make-pt.html.markdown @@ -0,0 +1,242 @@ +--- +language: 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 `. +# Caso contrário, nós usamos `make -f "nome-do-arquivo" `. + +# Aviso - use somente TABS para identar em Makefiles, nunca espaços! + +#----------------------------------------------------------------------- +# Noções básicas +#----------------------------------------------------------------------- + +# Regras são do formato +# alvo: +# 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) -- cgit v1.2.3 From e3123b92837ed05dd802c24e5e99d966d2a9f306 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Sat, 20 Oct 2018 23:47:54 -0300 Subject: Remove make translate --- pt-br/make-pt.html.markdown | 242 -------------------------------------------- 1 file changed, 242 deletions(-) delete mode 100644 pt-br/make-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown deleted file mode 100644 index 8e7603cc..00000000 --- a/pt-br/make-pt.html.markdown +++ /dev/null @@ -1,242 +0,0 @@ ---- -language: 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 `. -# Caso contrário, nós usamos `make -f "nome-do-arquivo" `. - -# Aviso - use somente TABS para identar em Makefiles, nunca espaços! - -#----------------------------------------------------------------------- -# Noções básicas -#----------------------------------------------------------------------- - -# Regras são do formato -# alvo: -# 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) -- cgit v1.2.3 From 678e42b2a34cd91f40139eefa7cc3dd3e6e4e30a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Sun, 21 Oct 2018 00:27:00 -0300 Subject: [make/pt-br] Add portuguese language for make --- pt-br/make-pt.html.markdown | 242 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 pt-br/make-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown new file mode 100644 index 00000000..8e7603cc --- /dev/null +++ b/pt-br/make-pt.html.markdown @@ -0,0 +1,242 @@ +--- +language: 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 `. +# Caso contrário, nós usamos `make -f "nome-do-arquivo" `. + +# Aviso - use somente TABS para identar em Makefiles, nunca espaços! + +#----------------------------------------------------------------------- +# Noções básicas +#----------------------------------------------------------------------- + +# Regras são do formato +# alvo: +# 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) -- cgit v1.2.3 From c73fbc27631e51598bcefecc5ac9606e1bab6476 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Sun, 21 Oct 2018 16:45:44 -0300 Subject: [cypher/pt-br] Add portuguese language for cypher --- pt-br/cypher-pt.html.markdown | 250 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 pt-br/cypher-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown new file mode 100644 index 00000000..7cfd8dcd --- /dev/null +++ b/pt-br/cypher-pt.html.markdown @@ -0,0 +1,250 @@ +--- +language: cypher +filename: LearnCypher.cql +contributors: + - ["Théo Gauchoux", "https://github.com/TheoGauchoux"] + +lang: pt-br +--- + +O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos. + +[Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/) + + +Nós +--- + +**Representa um registro em um gráfico.** + +`()` +É um *nó* vazio, para indicar que existe um *nó*, mas não é relevante para a consulta. + +`(n)` +É um *nó* referido pela variável **n**, reutilizável na consulta. Começa com minúsculas e usa o camelCase. + +`(p:Person)` +Você pode adicionar um *label* ao seu nó, aqui **Person**. É como um tipo / uma classe / uma categoria. Começa com maiúsculas e usa o camelCase. + +`(p:Person:Manager)` +Um nó pode ter muitos *labels*. + +`(p:Person {name : 'Théo Gauchoux', age : 22})` +Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com minúsculas e usa o camelCase. + +Os tipos permitidos nas propriedades: + + - Numeric + - Boolean + - String + - Lista de tipos primitivos anteriores + +*Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.* + +`p.name` +Você pode acessar uma propriedade com o estilo de ponto. + + +Relacionamentos (ou Arestas) +--- + +**Conecta dois nós** + +`[:KNOWS]` +É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE. + +`[k:KNOWS]` +O mesmo *relacionamento*, referido pela variável **k**, reutilizável na consulta, mas não é necessário. + +`[k:KNOWS {since:2017}]` +O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**. + +`[k:KNOWS*..4]` +É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes. + + +Paths +--- + +**A maneira de misturar nós e relacionamentos.** + +`(a:Person)-[:KNOWS]-(b:Person)` +Um path descrevendo que **a** e **b** se conhecem. + +`(a:Person)-[:MANAGES]->(b:Person)` +Um path pode ser direcionado. Este path descreve que **a** é o gerente de **b**. + +`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)` +Você pode encadear vários relacionamentos. Este path descreve o amigo de um amigo. + +`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)` +Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**. + +Padrões frequentemente usados ​​(do Neo4j doc) : + +``` +// Amigo de um amigo +(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf) + +// Path mais curto +path = shortestPath( (user)-[:KNOWS*..5]-(other) ) + +// Filtragem colaborativa +(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct) + +// Navegação de árvore +(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product) + +``` + + +Crie consultas +--- + +Create a new node +``` +CREATE (a:Person {name:"Théo Gauchoux"}) +RETURN a +``` +*`RETURN` permite ter um resultado após a consulta. Pode ser múltiplo, como `RETURN a, b`.* + +Crie um novo relacionamento (com 2 novos nós) +``` +CREATE (a:Person)-[k:KNOWS]-(b:Person) +RETURN a,k,b +``` + +Consultas que casam +--- + +Casam todos os nós +``` +MATCH (n) +RETURN n +``` + +Casam nós por label +``` +MATCH (a:Person) +RETURN a +``` + +Casam nós por label e propriedade +``` +MATCH (a:Person {name:"Théo Gauchoux"}) +RETURN a +``` + +Casam nós de acordo com os relacionamentos (não direcionados) +``` +MATCH (a)-[:KNOWS]-(b) +RETURN a,b +``` + +Casam nós de acordo com os relacionamentos (direcionados) +``` +MATCH (a)-[:MANAGES]->(b) +RETURN a,b +``` + +Casam nós com um cláusula `WHERE` +``` +MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City) +WHERE s.since = 2015 +RETURN p,state +``` + +Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE` +``` +MATCH (a), (b) +WHERE a.name = "Jacquie" AND b.name = "Michel" +CREATE (a)-[:KNOWS]-(b) +``` + + +Atualizar consultas +--- + +Atualizar uma propriedade específica de um nó +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p.age = 23 +``` + +Substituir todas as propriedades de um nó +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p = {name: "Michel", age: 23} +``` + +Adicionar nova propriedade a um nó +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p + = {studies: "IT Engineering"} +``` + +Adicione um label a um nó +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p:Internship +``` + + +Excluir consultas +--- + +Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes) +``` +MATCH (p:Person)-[relationship]-() +WHERE p.name = "Théo Gauchoux" +DELETE relationship, p +``` + +Remover uma propriedade em um nó específico +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +REMOVE p.age +``` +*Prestar atenção à palavra chave `REMOVE`, não é `DELETE` !* + +Remover um label de um nó específico +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +DELETE p:Person +``` + +Excluir o banco de dados inteiro +``` +MATCH (n) +OPTIONAL MATCH (n)-[r]-() +DELETE n, r +``` +*Sério, é o `rm -rf /` do Cypher !* + + +Outras cláusulas úteis +--- + +`PROFILE` +Antes de uma consulta, mostre o plano de execução dela. + +`COUNT(e)` +Contar entidades (nós ou relacionamentos) que casam com **e**. + +`LIMIT x` +Limite o resultado aos primeiros x resultados. + + +Dicas Especiais +--- + +- Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários +- Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**). +- Use o shell Neo4j para escrever Cypher, é realmente incrível. +- O Cypher será a linguagem de consulta padrão para todos os bancos de dados de gráficos (conhecidos como **OpenCypher**). -- cgit v1.2.3 From cb1ef05aa638d5e99e9956c215b79767bc02c1ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rog=C3=A9rio?= Date: Sun, 21 Oct 2018 20:35:57 -0300 Subject: [factor/pt-br] Add portuguese language for factor --- pt-br/factor-pt.html.markdown | 184 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 pt-br/factor-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown new file mode 100644 index 00000000..99e2b67f --- /dev/null +++ b/pt-br/factor-pt.html.markdown @@ -0,0 +1,184 @@ +--- +language: factor +contributors: + - ["hyphz", "http://github.com/hyphz/"] +filename: learnfactor.factor + +lang: pt-br +--- + +Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov. + +Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso. + +``` +! Este é um comentário + +! Como Forth, toda a programação é feita manipulando a pilha. +! A indicação de um valor literal o coloca na pilha. +5 2 3 56 76 23 65 ! Nenhuma saída, mas a pilha é impressa no modo interativo + +! Esses números são adicionados à pilha, da esquerda para a direita. +! .s imprime a pilha de forma não destrutiva. +.s ! 5 2 3 56 76 23 65 + +! A aritmética funciona manipulando dados na pilha. +5 4 + ! Sem saída + +! `.` mostra o resultado superior da pilha e o imprime. +. ! 9 + +! Mais exemplos de aritmética: +6 7 * . ! 42 +1360 23 - . ! 1337 +12 12 / . ! 1 +13 2 mod . ! 1 + +99 neg . ! -99 +-99 abs . ! 99 +52 23 max . ! 52 +52 23 min . ! 23 + +! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas. + +3 dup - ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3 +2 5 swap / ! troca o primeiro com o segundo elemento: 5 / 2 +4 0 drop 2 / ! remove o primeiro item (não imprima na tela): 4 / 2 +1 2 3 nip .s ! remove o segundo item (semelhante a drop): 1 3 +1 2 clear .s ! acaba com toda a pilha +1 2 3 4 over .s ! duplica o segundo item para o topo: 1 2 3 4 3 +1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3 + +! Criando Palavras +! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`. +: square ( n -- n ) dup * ; ! Sem saída +5 square . ! 25 + +! Podemos ver o que as palavra fazem também. +! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha. +\ square see ! : square ( n -- n ) dup * ; + +! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha. +! Podemos usar os nomes que quisermos dentro da declaração: +: weirdsquare ( camel -- llama ) dup * ; + +! Contanto que sua contagem corresponda ao efeito da pilha da palavra: +: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong +: doubledup ( a -- a a a ) dup dup ; ! Ok +: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok + +! Onde Factor difere do Forth é no uso de citações. +! Uma citação é um bloco de código que é colocado na pilha como um valor. +! [ inicia o modo de citação; ] termina. +[ 2 + ] ! A citação que adiciona 2 é deixada na pilha +4 swap call . ! 6 + +! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior. +2 3 [ 2 + ] dip .s ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3 +3 4 [ + ] keep .s ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4 +1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4 +4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 ) +1 2 [ 2 + ] bi@ .s ! Executar a citação no primeiro e segundo valores +2 [ + ] curry ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha + +! Condicionais +! Qualquer valor é verdadeiro, exceto o valor interno f. +! m valor interno não existe, mas seu uso não é essencial. +! Condicionais são palavras de maior ordem, como com os combinadores acima. + +5 [ "Five is true" . ] when ! Cinco é verdadeiro +0 [ "Zero is true" . ] when ! Zero é verdadeiro +f [ "F is true" . ] when ! Sem saída +f [ "F is false" . ] unless ! F é falso +2 [ "Two is true" . ] [ "Two is false" . ] if ! Two é verdadeiro + +! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco +! deixe sozinho se é verdadeiro: + +5 [ . ] when* ! 5 +f [ . ] when* ! Nenhuma saída, pilha vazia, f é consumida porque é falsa + + +! Laços +! Você adivinhou .. estas são palavras de ordem mais elevada também. + +5 [ . ] each-integer ! 0 1 2 3 4 +4 3 2 1 0 5 [ + . ] each-integer ! 0 2 4 6 8 +5 [ "Hello" . ] times ! Hello Hello Hello Hello Hello + +! Here's a list: +{ 2 4 6 8 } ! Goes on the stack as one item + +! Aqui está uma lista: +{ 2 4 6 8 } [ 1 + . ] each ! Exibe 3 5 7 9 +{ 2 4 6 8 } [ 1 + ] map ! Sai { 3 5 7 9 } na pilha + +! Reduzir laços ou criar listas: +{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 } +{ 2 4 6 8 } 0 [ + ] reduce . ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8) +{ 2 4 6 8 } 0 [ + ] accumulate . . ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20 +1 5 [ 2 * dup ] replicate . ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 } +1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 } + +! Se tudo mais falhar, uma finalidade geral, enquanto repete: +1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Exibe "Hello" 10 vezes + ! Sim, é difícil de ler + ! Isso é o que todos esses loops variantes são para + +! Variáveis +! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha. +! Usar variáveis ​​nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo) +! Variáveis ​​globais, se você precisar: + +SYMBOL: name ! Cria o nome como uma palavra identificadora +"Bob" name set-global ! Sem saída +name get-global . ! "Bob" + +! Variáveis ​​locais nomeadas são consideradas uma extensão, mas estão disponíveis +! Em uma citação .. +[| m n ! A citação captura os dois principais valores da pilha em m e n + | m n + ] ! Leia-os + +! Ou em uma palavra.. +:: lword ( -- ) ! Note os dois pontos duplos para invocar a extensão da variável lexica + 2 :> c ! Declara a variável imutável c para manter 2 + c . ; ! Imprima isso + +! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha +! torna-se significativo e fornece os valores das variáveis ​​em que os valores da pilha são capturados +:: double ( a -- result ) a 2 * ; + +! Variáveis ​​são declaradas mutáveis ​​ao terminar seu nome com um ponto de exclamação +:: mword2 ( a! -- x y ) ! Capture o topo da pilha na variável mutável a + a ! Empurrar a + a 2 * a! ! Multiplique por 2 e armazene o resultado em a + a ; ! Empurre novo valor de a +5 mword2 ! Pilha: 5 10 + +! Listas e Sequências +! Vimos acima como empurrar uma lista para a pilha + +0 { 1 2 3 4 } nth ! Acessar um membro específico de uma lista: 1 +10 { 1 2 3 4 } nth ! Error: índice de sequência fora dos limites +1 { 1 2 3 4 } ?nth ! O mesmo que nth se o índice estiver dentro dos limites: 2 +10 { 1 2 3 4 } ?nth ! Nenhum erro se estiver fora dos limites: f + +{ "at" "the" "beginning" } "Append" prefix ! { "Append" "at" "the" "beginning" } +{ "Append" "at" "the" } "end" suffix ! { "Append" "at" "the" "end" } +"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" } +"Concat" "enate" append ! "Concatenate" - strings are sequences too +"Concatenate" "Reverse " prepend ! "Reverse Concatenate" +{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs" +{ "Connect" "subseqs" "with" "separators" } " " join ! "Connect subseqs with separators" + +! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas.. +0 [ 2 + ] nth ! 2 +1 [ 2 + ] nth ! + +[ 2 + ] \ - suffix ! Quotation [ 2 + - ] + + +``` + +##Pronto para mais? + +* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html) -- cgit v1.2.3 From 868b22058fe14b270c55116d8a5943c2d708415b Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Tue, 23 Oct 2018 20:36:28 -0700 Subject: Factor highlight is here --- pt-br/factor-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown index 99e2b67f..e3c8f4a9 100644 --- a/pt-br/factor-pt.html.markdown +++ b/pt-br/factor-pt.html.markdown @@ -11,7 +11,7 @@ Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por S Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso. -``` +```factor ! Este é um comentário ! Como Forth, toda a programação é feita manipulando a pilha. -- cgit v1.2.3 From 360349bf35a301b8c4586798560d410c892a1540 Mon Sep 17 00:00:00 2001 From: LukaxFeh Date: Tue, 30 Oct 2018 22:15:10 -0300 Subject: [Dynamic programming-PT/BR] Fixed links --- pt-br/dynamic-programming-pt.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown index 518660a3..93171955 100644 --- a/pt-br/dynamic-programming-pt.html.markdown +++ b/pt-br/dynamic-programming-pt.html.markdown @@ -64,9 +64,9 @@ grafo acíclico dirigido. ## Alguns Problemas Famosos de Programação Dinâmica -- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]() -- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]() -- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]() +- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code) +- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem) +- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence) ## Recursos Online (EN) -- cgit v1.2.3 From 1b1acc6f3ed7d24733fbacee2d3a6bf6df7c66a4 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Wed, 31 Oct 2018 08:23:24 -0300 Subject: Update csharp-pt.html.markdown Translation of comments (line 98 and 99) and correction of comments (line 62) --- pt-br/csharp-pt.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..2b61a8fa 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -59,7 +59,7 @@ namespace Learning.CSharp Console.Write("World"); /////////////////////////////////////////////////// - // Tpos e Variáveis + // Tipos e Variáveis // // Declare uma variável usando /////////////////////////////////////////////////// @@ -95,8 +95,9 @@ namespace Learning.CSharp float fooFloat = 234.5f; // Precision: 7 digits // f is used to denote that this variable value is of type float - // Decimal - a 128-bits data type, with more precision than other floating-point types, - // suited for financial and monetary calculations + // Decimal - um tipo de dados de 128 bits, com mais precisão do que outros tipos de ponto flutuante, + // adequado para cálculos financeiros e monetários + decimal fooDecimal = 150.3m; // Boolean - true & false -- cgit v1.2.3 From 6d23388f632bc2149a59269a6456ad2bea5552c0 Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 08:33:18 -0300 Subject: [typescript/pt-br] Removed duplicate text --- pt-br/typescript-pt.html.markdown | 7 ------- 1 file changed, 7 deletions(-) (limited to 'pt-br') diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown index f072b257..077aa2cc 100644 --- a/pt-br/typescript-pt.html.markdown +++ b/pt-br/typescript-pt.html.markdown @@ -8,13 +8,6 @@ translators: lang: pt-br --- -TypeScript is a language that aims at easing development of large scale applications written in JavaScript. -TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript. -It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript. - -This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/). - - Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript. Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript. É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript. -- cgit v1.2.3 From cb9b22fa54cf29eda343904cef7a26c6860270e8 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Wed, 31 Oct 2018 08:37:56 -0300 Subject: [ruby/pt-br] Update ruby-pt.html.markdown Translation of comment. --- pt-br/ruby-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown index 1078f6c5..7ae28ac2 100644 --- a/pt-br/ruby-pt.html.markdown +++ b/pt-br/ruby-pt.html.markdown @@ -71,7 +71,7 @@ false.class #=> FalseClass 2 <= 2 #=> true 2 >= 2 #=> true -# Strings são objects +# Strings são objetos 'Eu sou uma string'.class #=> String "Eu também sou uma string".class #=> String -- cgit v1.2.3 From f08c02338ae371ecffe07f18a11caee64100b8b1 Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 08:40:34 -0300 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..f0d01e6e 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -294,9 +294,9 @@ on a new line! ""Wow!"", the masses cried"; case 3: monthString = "March"; break; - // You can assign more than one case to an action - // But you can't add an action without a break before another case - // (if you want to do this, you would have to explicitly add a goto case x + // Você pode declarar mais de um "case" para uma ação + // Mas você não pode adicionar uma ação sem um "break" antes de outro "case" + // (se você quiser fazer isso, você tem que explicitamente adicionar um "goto case x") case 6: case 7: case 8: -- cgit v1.2.3 From 8bad4d109cff8165d1dddf5796db41a4f8273128 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Wed, 31 Oct 2018 08:41:41 -0300 Subject: [csharp/pt-br] Update csharp-pt.html.markdown Translation of comments. --- pt-br/csharp-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..c310ce2e 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried"; foreach (var key in responses.Keys) Console.WriteLine("{0}:{1}", key, responses[key]); - // DYNAMIC OBJECTS (great for working with other languages) + // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas) dynamic student = new ExpandoObject(); student.FirstName = "First Name"; // No need to define class first! -- cgit v1.2.3 From fd5ee982bc9f2f10bafb8b4d7cf15c15e646da10 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Wed, 31 Oct 2018 08:45:05 -0300 Subject: [csharp/pt-br] Update csharp-pt.html.markdown Translation of comments. --- pt-br/csharp-pt.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..3d84f91f 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried"; foreach (var key in responses.Keys) Console.WriteLine("{0}:{1}", key, responses[key]); - // DYNAMIC OBJECTS (great for working with other languages) + // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas) dynamic student = new ExpandoObject(); student.FirstName = "First Name"; // No need to define class first! @@ -730,10 +730,10 @@ on a new line! ""Wow!"", the masses cried"; set { _hasTassles = value; } } - // You can also define an automatic property in one line - // this syntax will create a backing field automatically. - // You can set an access modifier on either the getter or the setter (or both) - // to restrict its access: + // Você também pode definir uma propriedade automática em uma linha +        // Esta sintaxe criará um campo de apoio automaticamente. +        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos) +        // para restringir seu acesso: public bool IsBroken { get; private set; } // Properties can be auto-implemented -- cgit v1.2.3 From b0d213ca09f5453a1f957b202bc5b1cc20cc5cb9 Mon Sep 17 00:00:00 2001 From: daniloyamauti <33129352+daniloyamauti@users.noreply.github.com> Date: Wed, 31 Oct 2018 08:50:50 -0300 Subject: [csharp/pt-br] Update csharp-pt.html.markdown Translation of comments. --- pt-br/csharp-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..e5c7eed0 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -854,8 +854,8 @@ on a new line! ""Wow!"", the masses cried"; } /// - /// Used to connect to DB for LinqToSql example. - /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional) + /// Exemplo de como conectar-se ao DB via LinqToSql. +    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional) /// http://msdn.microsoft.com/en-us/data/jj193542.aspx /// public class BikeRepository : DbContext -- cgit v1.2.3 From 049838460e27f0a9777ac92dfc2843a5f9056358 Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 08:51:04 -0300 Subject: [yaml/pt-br] Fixing translation --- pt-br/yaml-pt.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown index 341ae675..569bde75 100644 --- a/pt-br/yaml-pt.html.markdown +++ b/pt-br/yaml-pt.html.markdown @@ -11,9 +11,9 @@ lang: pt-br YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e legível por seres humanos. -É um estrito subconjunto de JSON, com a adição de sintaticamente -novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto, -YAML não permite caracteres de tabulação literais em tudo. +It's a strict superset of JSON, with the addition of syntactically significant newlines and indentation, like Python. Unlike Python, however, YAML doesn't allow literal tab characters for indentation. + +É um superconjunto de JSON, com a adição de indentaçã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 # Commentários em YAML são como este. -- cgit v1.2.3 From 1255d7166830068d6e1ed1e5b0532b858f3fdf14 Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 08:54:09 -0300 Subject: [xml/pt-bt] Better translation --- pt-br/xml-pt.html.markdown | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown index f347f8ef..6710b387 100644 --- a/pt-br/xml-pt.html.markdown +++ b/pt-br/xml-pt.html.markdown @@ -10,8 +10,7 @@ lang: pt-br XML é uma linguagem de marcação projetada para armazenar e transportar dados. -Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, -basta carregá-lo. +Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, apenas o transporta. * Sintaxe XML -- cgit v1.2.3 From 34621899d314845bb116e922d8947db12056852d Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 09:01:02 -0300 Subject: [whip/pt-br] Better translation --- pt-br/whip-pt.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'pt-br') diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown index 989bae05..7bdeec25 100644 --- a/pt-br/whip-pt.html.markdown +++ b/pt-br/whip-pt.html.markdown @@ -15,13 +15,13 @@ Whip é um dialeto de Lisp feito para construir scripts e trabalhar com conceitos mais simples. Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata) -Esse documento foi escrito pelo próprio autor da linguagem. Então é isso. +Esse documento foi escrito pelo próprio autor da linguagem. Então é isso. ```scheme ; Comentário são como em Lisp. Pontos-e-vírgulas... ; A maioria das declarações de primeiro nível estão dentro de "listas" -; que nada mais são que coisas entre parêntesis separadas por espaços em branco +; que nada mais são que coisas entre parênteses separadas por espaços em branco nao_é_uma_lista (uma lista) @@ -64,7 +64,7 @@ false (not false) ; => true ; Mas a maioria das funções não-haskell tem atalhos -; o não atalho é um '!'. +; o atalho para "não" é um '!'. (! (! true)) ; => true ; Igualdade é `equal` ou `=`. @@ -114,7 +114,7 @@ undefined ; usada para indicar que um valor não foi informado (1 2 3) ; => [1, 2, 3] (sintaxe JavaScript) ; Dicionários em Whip são o equivalente a 'object' em JavaScript ou -; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada +; 'dict' em python ou 'hash' em Ruby: eles são uma coleção desordenada de pares chave-valor. {"key1" "value1" "key2" 2 3 3} @@ -222,7 +222,7 @@ linguagens imperativas. (take 1 (1 2 3 4)) ; (1 2) ; Contrário de `take` (drop 1 (1 2 3 4)) ; (3 4) -; Menos valor em uma lista +; Menor valor em uma lista (min (1 2 3 4)) ; 1 ; Maior valor em uma lista (max (1 2 3 4)) ; 4 -- cgit v1.2.3 From ac42b7b824bdfb0b85852a7a4f9f82f281e99d76 Mon Sep 17 00:00:00 2001 From: Thiago Ribeiro Date: Wed, 31 Oct 2018 09:33:00 -0300 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index be14a1c8..10e8a201 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -336,28 +336,28 @@ on a new line! ""Wow!"", the masses cried"; } /////////////////////////////////////// - // CLASSES - see definitions at end of file + // CLASSES - Veja definições no fim do arquivo /////////////////////////////////////// public static void Classes() { - // See Declaration of objects at end of file + // Veja Declaração de objetos no fim do arquivo - // Use new to instantiate a class + // Use new para instanciar uma classe Bicycle trek = new Bicycle(); - // Call object methods - trek.SpeedUp(3); // You should always use setter and getter methods + // Chame métodos do objeto + trek.SpeedUp(3); // Você deve sempre usar métodos setter e getter trek.Cadence = 100; - // ToString is a convention to display the value of this Object. + // ToString é uma convenção para exibir o valor desse Objeto. Console.WriteLine("trek info: " + trek.Info()); - // Instantiate a new Penny Farthing + // Instancie um novo Penny Farthing PennyFarthing funbike = new PennyFarthing(1, 10); Console.WriteLine("funbike info: " + funbike.Info()); Console.Read(); - } // End main method + } // Fim do método principal // CONSOLE ENTRY A console application must have a main method as an entry point public static void Main(string[] args) -- cgit v1.2.3 From a9c9379d4f359c79f3d44687ee19e65eaae4208c Mon Sep 17 00:00:00 2001 From: Thiago Ribeiro Date: Wed, 31 Oct 2018 09:54:59 -0300 Subject: [paren/pt-br] Small typos --- pt-br/paren-pt.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'pt-br') diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown index 464a69d2..92414ba3 100644 --- a/pt-br/paren-pt.html.markdown +++ b/pt-br/paren-pt.html.markdown @@ -182,8 +182,8 @@ a ; => (3 2) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Macros lhe permitem estender a sintaxe da linguagem. -;; Os macros no Paren são fáceis. -;; Na verdade, (defn) é um macro. +;; As macros no Paren são fáceis. +;; Na verdade, (defn) é uma macro. (defmacro setfn (nome ...) (set nome (fn ...))) (defmacro defn (nome ...) (def nome (fn ...))) @@ -191,6 +191,6 @@ a ; => (3 2) (defmacro infix (a op ...) (op a ...)) (infix 1 + 2 (infix 3 * 4)) ; => 15 -;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes! -;; Eles são transformações de códigos. +;; Macros não são higiênicas, você pode sobrescrever as variáveis já existentes! +;; Elas são transformações de códigos. ``` -- cgit v1.2.3 From e2637963b93d6fd610de994273713ccbd94a6522 Mon Sep 17 00:00:00 2001 From: Fer Date: Wed, 31 Oct 2018 10:38:22 -0300 Subject: [yaml/pt-br] Remove lines --- pt-br/yaml-pt.html.markdown | 2 -- 1 file changed, 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown index 569bde75..0b71877e 100644 --- a/pt-br/yaml-pt.html.markdown +++ b/pt-br/yaml-pt.html.markdown @@ -11,8 +11,6 @@ lang: pt-br YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e legível por seres humanos. -It's a strict superset of JSON, with the addition of syntactically significant newlines and indentation, like Python. Unlike Python, however, YAML doesn't allow literal tab characters for indentation. - É um superconjunto de JSON, com a adição de indentaçã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 -- cgit v1.2.3 From ec8231e6c25a9db40705c5336105652bfb43b8c5 Mon Sep 17 00:00:00 2001 From: fnscoder Date: Wed, 31 Oct 2018 15:11:33 -0300 Subject: [python3/pr-br] Fixed typo --- pt-br/python3-pt.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'pt-br') diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown index 9b6bd1b6..ea0617f4 100644 --- a/pt-br/python3-pt.html.markdown +++ b/pt-br/python3-pt.html.markdown @@ -105,9 +105,9 @@ False or True # => True 1 < 2 < 3 # => True 2 < 3 < 2 # => False -# (operador 'is' e operador '==') is verifica se duas referenciam um -# mesmo objeto, mas == verifica se as variáveis apontam para o -# mesmo valor. +# (operador 'is' e operador '==') is verifica se duas variáveis +# referenciam um mesmo objeto, mas == verifica se as variáveis +# apontam para o mesmo valor. a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4] b = a # b referencia o que está referenciado por a b is a # => True, a e b referenciam o mesmo objeto -- cgit v1.2.3 From e9622c01f4a22106546c58c6e3fc8d1f6ef42cb6 Mon Sep 17 00:00:00 2001 From: David Lima Date: Tue, 30 Oct 2018 20:16:06 -0300 Subject: Translate Haxe documentation to pt-br --- pt-br/haxe-pt.html.markdown | 795 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 795 insertions(+) create mode 100644 pt-br/haxe-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/haxe-pt.html.markdown b/pt-br/haxe-pt.html.markdown new file mode 100644 index 00000000..13264dec --- /dev/null +++ b/pt-br/haxe-pt.html.markdown @@ -0,0 +1,795 @@ +--- +language: haxe +filename: LearnHaxe3-br.hx +contributors: + - ["Justin Donaldson", "https://github.com/jdonaldson/"] + - ["Dan Korostelev", "https://github.com/nadako/"] +translators: + - ["David Lima", "https://github.com/davelima/"] +lang: pt-br +--- + +Haxe é uma linguagem baseada na web que provê suporte a C++, C#, SWF/ActionScript, +Java e Neko byte code (também desenvolvida pelo autor de Haxe). Observe que +este guia é para a versão 3 de Haxe. Alguns pontos do guia são aplicáveis +para versões anteriores, mas é recomendado que você busque outras referências +para essas versões. + + +```csharp +/* + Bem vindo ao Aprenda Haxe 3 em 15 minutos. http://www.haxe.org + Este é um tutorial executável. Você pode compilar e rodar este tutorial + usando o compilador haxe, estando no mesmo diretório de LearnHaxe.hx: + $> haxe -main LearnHaxe3 -x out + + Olhe para os sinais de /* e */ em volta desses parágrafos. Nós estamos + dentro de um "Comentário multilinha". Nós podemos colocar observações aqui + e elas serão ignoradas pelo compilador. + + Comentários multilinha também são utilizados para gerar documentação haxedoc, + seguindo o estilo javadoc. Eles serão usados pelo haxedoc se precerem imediatamente + uma classe, uma função de uma classe ou uma variável de uma classe. + + */ + +// Duas barras, como as dessa linha, farão um comentário de linha única. + + +/* + Este será o primeiro código haxe de verdade, e está declarando um pacote vazio. + Não é necessário usar um pacote, mas ele será útil se você quiser criar + um namespace para o seu código (exemplo: org.seuapp.SuaClasse). + + Omitir a declaração de pacote é a mesma coisa que declarar um pacote vazio. + */ +package; // pacote vazio, sem namespace. + +/* + Pacotes são diretórios que contém módulos. Cada módulo é um arquivo .hx que + contém tipos definidos em um pacote. Nomes de pacotes (ex. org.seuapp) + devem estar em letras minúsculas, enquanto nomes de módulos devem começar + com uma letra maiúscula. Um módulo contem um ou mais tipos, cujo os nomes + também devem começar com uma letra maiúscula. + + Exemplo: a classe "org.seuapp.Foo" deve ter a estrutura de diretório org/module/Foo.hx, + sendo acessível do diretório do compilador ou caminho da classe. + + Se você importar código de outros arquivos, isso deve ser declarado antes + do restante do código. Haxe disponibiliza várias classes padrões para você + começar: + */ +import haxe.ds.ArraySort; + +// você pode importar várias classes/módulos de uma vez usando "*" +import haxe.ds.*; + +// você pode importar campos estáticos +import Lambda.array; + +// você também pode usar "*" para importar todos os campos estáticos +import Math.*; + +/* + Você também pode importar classes de uma forma diferente, habilitando-as para + extender a funcionalidade de outras classes, como um "mixin". Falaremos sobre + "using" em breve. + */ +using StringTools; + +/* + Typedefs são como variáveis... para tipos. Eles devem ser declarados antes + de qualquer código. Veremos isso em breve. + */ +typedef FooString = String; + +// Typedefs também podem referenciar tipos "estruturais". Também veremos isso em breve. +typedef FooObject = { foo: String }; + +/* + Esta é a definição da classe. É a classe principal do arquivo, visto que + possui o mesmo nome (LearnHaxe3) + */ +class LearnHaxe3{ + /* + Se você quiser que um determinado código rode automaticamente, você + precisa colocá-lo em uma função estática "main", e especificar a classe + nos argumentos do compilador. + Nesse caso, nós especificamos a classe "LearnHaxe3" no nos argumentos + do compilador acima. + */ + static function main(){ + + /* + Trace é o método padrão para imprimir expressões haxe na tela. + Temos diferentes métodos para conseguir isso em diferentes destinos. + Por exemplo: Java, C++, C#, etc. irão imprimir para stdout. + Javascript irá imprimir no console.log, e Flash irá imprimir para um + TextField anexado. Todos os "traces" imprimem também uma linha em branco + por padrão. Por fim, é possível prevenir um trace de ser exibido usando + o argumento "--no-traces" no compilador. + */ + trace("Olá mundo, com trace()!"); + + /* + Trace pode tratar qualquer tipo de valor ou objeto. O método tentará + imprimir a representação de uma expressão da melhor forma. Você também + pode concatenar strings usando o operador "+": + */ + trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true); + + /* + Em Haxe, é obrigatório separar expressões no mesmo bloco com ';'. Mas + é possível colocar duas expressões na mesma linha, dessa forma: + */ + trace('duas expressões..'); trace('uma linha'); + + + ////////////////////////////////////////////////////////////////// + // Tipos & Variáveis + ////////////////////////////////////////////////////////////////// + trace("***Tipos & Variáveis***"); + + /* + Vcoê pode atrelar valores e referências à estruturas usando a + palavra-chave "var": + */ + var um_inteiro:Int = 1; + trace(um_inteiro + " é o valor de um_inteiro"); + + + /* + Haxe é tipada estaticamente, então "um_inteiro" temos que declarar + um valor do tipo "Int", e o restante da expressão atrela o valor "1" + a esta variável. Em muitos casos, não é necessário declarar o tipo. + Aqui, o compilador haxe assume que o tipo de "outro_inteiro" deve + ser "Int" + */ + var outro_inteiro = 2; + trace(outro_inteiro + " é o valor de outro_inteiro"); + + // O método $type() imprime o tipo que o compilador assume: + $type(outro_inteiro); + + // Você também pode representar inteiros em hexadecimal: + var hex_inteiro = 0xffffff; + + /* + Haxe usa precisão de pltaforma para os tamanhos de Int e Float. + Ele também usa o comportamento de plataforma para sobrecarga. + (É possível ter outros tipos numéricos e comportamentos usando + bibliotecas especiais) + */ + + /* + Em adição a valores simples como Integers, Floats e Booleans, + Haxe disponibiliza implementações padrões de bibliotecas para + dados comuns de estrutura como strings, arrays, lists e maps: + */ + + var uma_string = "alguma" + 'string'; // strings podem estar entre aspas simples ou duplas + trace(uma_string + " é o valor de uma_string"); + + /* + Strings podem ser "interpoladas" se inserirmos variáveis em + posições específicas. A string deve estar entre aspas simples, e as + variáveis devem ser precedidas por "$". Expressões podem estar entre + ${...}. + */ + var x = 1; + var uma_string_interpolada = 'o valor de x é $x'; + var outra_string_interpolada = 'o valor de x + 1 é ${x + 1}'; + + /* + Strings são imutáveis, métodos retornarão uma cópia de partes + ou de toda a string. (Veja também a classe StringBuf) + */ + var uma_sub_string = a_string.substr(0,4); + trace(uma_sub_string + " é o valor de a_sub_string"); + + /* + Regex também são suportadas, mas não temos espaço suficiente para + entrar em muitos detalhes. + */ + var re = ~/foobar/; + trace(re.match('foo') + " é o valor de (~/foobar/.match('foo')))"); + + /* + Arrays são indexadas a partir de zero, dinâmicas e mutáveis. Valores + faltando são definidos como null. + */ + var a = new Array(); // um array que contém Strings + a[0] = 'foo'; + trace(a.length + " é o valor de a.length"); + a[9] = 'bar'; + trace(a.length + " é o valor de a.length (depois da modificação)"); + trace(a[3] + " é o valor de a[3]"); // null + + /* + Arrays são *genéricas*, então você pode indicar quais valores elas + contém usando um parâmetro de tipo: + */ + var a2 = new Array(); // um Array de Ints + var a3 = new Array>(); // um Array de Arrays (de Strings). + + /* + Mapas são estruturas simples de chave/valor. A chave e o valor podem + ser de qualquer tipo. + */ + var m = new Map(); // As chaves são strings, os valores são Ints. + m.set('foo', 4); + // Você também pode usar a notação de array; + m['bar'] = 5; + trace(m.exists('bar') + " é o valor de m.exists('bar')"); + trace(m.get('bar') + " é o valor de m.get('bar')"); + trace(m['bar'] + " é o valor de m['bar']"); + + var m2 = ['foo' => 4, 'baz' => 6]; // Syntaxe alternativa de map + trace(m2 + " é o valor de m2"); + + /* + Lembre-se, você pode usar descoberta de tipo. O compilador + Haxe irá decidir o tipo da variável assim que você passar um + argumento que define um parâmetro de tipo. + */ + var m3 = new Map(); + m3.set(6, 'baz'); // m3 agora é Map + trace(m3 + " é o valor de m3"); + + /* + Haxe possui mais algumas estruturas de dados padrões no módulo haxe.ds, + tais como List, Stack e BalancedTree + */ + + + ////////////////////////////////////////////////////////////////// + // Operadores + ////////////////////////////////////////////////////////////////// + trace("***OPERADORES***"); + + // aritmética básica + trace((4 + 3) + " é o valor de (4 + 3)"); + trace((5 - 1) + " é o valor de (5 - 1)"); + trace((2 * 4) + " é o valor de (2 * 4)"); + trace((8 / 3) + " é o valor de (8 / 3) (divisão sempre produz Floats)"); + trace((12 % 4) + " é o valor de (12 % 4)"); + + + // comparação básica + trace((3 == 2) + " é o valor de 3 == 2"); + trace((3 != 2) + " é o valor de 3 != 2"); + trace((3 > 2) + " é o valor de 3 > 2"); + trace((3 < 2) + " é o valor de 3 < 2"); + trace((3 >= 2) + " é o valor de 3 >= 2"); + trace((3 <= 2) + " é o valor de 3 <= 2"); + + // operadores bit-a-bit padrões + /* + ~ Complemento bit-a-bit unário + << Deslocamento a esquerda + >> Deslocamento a direita + >>> Deslocamento a direita com preenchimento de 0 + & Bit-a-bit AND + ^ Bit-a-bit OR exclusivo + | Bit-a-bit OR inclusivo + */ + + // incrementos + var i = 0; + trace("Incrementos e decrementos"); + trace(i++); //i = 1. Pós-incremento + trace(++i); //i = 2. Pré-incremento + trace(i--); //i = 1. Pós-decremento + trace(--i); //i = 0. Pré-decremento + + ////////////////////////////////////////////////////////////////// + // Estruturas de controle + ////////////////////////////////////////////////////////////////// + trace("***ESTRUTURAS DE CONTROLE***"); + + // operadores if + var j = 10; + if (j == 10){ + trace("isto é impresso"); + } else if (j > 10){ + trace("não é maior que 10, então não é impresso"); + } else { + trace("também não é impresso."); + } + + // temos também um if "ternário": + (j == 10) ? trace("igual a 10") : trace("diferente de 10"); + + /* + Por fim, temos uma outra forma de estrutura de controle que opera + e na hora da compilação: compilação condicional. + */ +#if neko + trace('olá de neko'); +#elseif js + trace('olá de js'); +#else + trace('olá de outra plataforma!'); +#end + /* + O código compilado irá mudar de acordo com o alvo de plataforma. + Se estivermos compilando para neko (-x ou -neko), só teremos a + saudação de neko. + */ + + + trace("Loops e Interações"); + + // loop while + var k = 0; + while(k < 100){ + // trace(counter); // irá iprimir números de 0 a 99 + k++; + } + + // loop do-while + var l = 0; + do{ + trace("do sempre rodará pelo menos uma vez"); + } while (l > 0); + + // loop for + /* + Não há loop for no estilo C para Haxe, pois é propenso + a erros e não é necessário. Ao invés disso, Haxe possui + uma versão muito mais simples e segura que usa Iterators + (veremos isso logo mais). + */ + var m = [1,2,3]; + for (val in m){ + trace(val + " é o valor de val no array m"); + } + + // Perceba que você pode iterar em um índice usando uma lista limitada + // (veremos isso em breve também) + var n = ['foo', 'bar', 'baz']; + for (val in 0...n.length){ + trace(val + " é o valor de val (um índice de n)"); + } + + + trace("Compreensões de array"); + + // Compreensões de array servem para que você posse iterar um array + // enquanto cria filtros e modificações + var n_filtrado = [for (val in n) if (val != "foo") val]; + trace(n_filtrado + " é o valor de n_filtrado"); + + var n_modificado = [for (val in n) val += '!']; + trace(n_modificado + " é o valor de n_modificado"); + + var n_filtrado_e_modificado = [for (val in n) if (val != "foo") val += "!"]; + trace(n_filtrado_e_modificado + " é o valor de n_filtrado_e_modificado"); + + ////////////////////////////////////////////////////////////////// + // Blocos Switch (Tipos de valor) + ////////////////////////////////////////////////////////////////// + trace("***BLOCOS SWITCH (Tipos de valor)***"); + + /* + Blocos Switch no Haxe são muito poderosos. Além de funcionar com + valores básicos como strings e ints, também funcionam com tipos + algébricos em enums (falaremos sobre enums depois). + Veja alguns exemplos de valor básico por enquanto: + */ + var meu_cachorro = "fido"; + var coisa_favorita = ""; + switch(meu_cachorro){ + case "fido" : favorite_thing = "osso"; + case "rex" : favorite_thing = "sapato"; + case "spot" : favorite_thing = "bola de tênis"; + default : favorite_thing = "algum brinquedo desconhecido"; + // case _ : favorite_thing = "algum brinquedo desconhecido"; // mesma coisa que default + } + // O case "_" acima é um valor "coringa" que + // que funcionará para qualquer coisa. + + trace("O nome do meu cachorro é " + meu_cachorro + + ", e sua coisa favorita é: " + + coisa_favorita); + + ////////////////////////////////////////////////////////////////// + // Declarações de expressão + ////////////////////////////////////////////////////////////////// + trace("***DECLARAÇÕES DE EXPRESSÃO***"); + + /* + As declarações de controle em Haxe são muito poderosas pois + toda declaração também é uma expressão, considere o seguinte: + */ + + // declarações if + var k = if (true) 10 else 20; + + trace("k igual a ", k); // retorna 10 + + var outra_coisa_favorita = switch(meu_cachorro) { + case "fido" : "ursinho"; + case "rex" : "graveto"; + case "spot" : "bola de futebol"; + default : "algum brinquedo desconhecido"; + } + + trace("O nome do meu cachorro é " + meu cachorro + + ", e sua outra coisa favorita é: " + + outra_coisa_favorita); + + ////////////////////////////////////////////////////////////////// + // Convertendo tipos de valores + ////////////////////////////////////////////////////////////////// + trace("***CONVERTENDO TIPOS DE VALORES***"); + + // Você pode converter strings em ints de forma bem fácil. + + // string para int + Std.parseInt("0"); // retorna 0 + Std.parseFloat("0.4"); // retorna 0.4; + + // int para string + Std.string(0); // retorna "0"; + // concatenar com strings irá converter automaticamente em string. + 0 + ""; // retorna "0"; + true + ""; // retorna "true"; + // Veja a documentação de parseamento em Std para mais detalhes. + + + ////////////////////////////////////////////////////////////////// + // Lidando com Tipos + ////////////////////////////////////////////////////////////////// + + /* + Como mencionamos anteriormente, Haxe é uma linguagem tipada + estaticamente. Tipagem estática é uma coisa maravilhosa. Isto + permite autocompletar mais preciso, e pode ser usado para checar + completamente o funcionamento de um programa. Além disso, o compilador + Haxe é super rápido. + + *ENTRETANTO*, há momentos em que você espera que o compilador apenas + deixe algo passar, e não lance um "type error" em um determinado caso. + + Para fazer isso, Haxe tem duas palavras-chave separadas. A primeira + é o tipo "Dynamic": + */ + var din: Dynamic = "qualquer tipo de variável, assim como essa string"; + + /* + Tudo o que você sabe sobre uma variável Dynamic é que o compilador + não irá mais se preocupar com o tipo dela. É como uma variável + "coringa": você pode usar isso ao invés de qualquer tipo de variável, + e você pode atrelar qualquer valor a essa variável. + + A outra (e mais extrema) opção é a palavra-chave "untyped": + */ + + untyped { + var x:Int = 'foo'; // não faz sentido! + var y:String = 4; // loucura! + } + + /* + A palavra-chave "untyped" opera em *blocos* inteiros de código, + ignorando qualquer verificação de tipo que seria obrigatória em + outros casos. Essa palavra-chave deve ser usada com muita cautela, + como em situações limitadas de compilação condicional onde a + verificação de tipo pode ser um obstáculo. + + No geral, ignorar verificações de tipo *não* é recomendado. Use + os modelos de enum, herança ou estrutural para garantir o correto + funcionamento do seu programa. Só quando você tiver certeza de que + nenhum desses modelos funcionam no seu caso, você deve usar "Dynamic" + ou "untyped". + */ + + ////////////////////////////////////////////////////////////////// + // Programação básica orientada a objetos + ////////////////////////////////////////////////////////////////// + trace("***PROGRAMAÇÃO BÁSICA ORIENTADA A OBJETOS***"); + + + /* + Cria uma instância da FooClass. As definicções dessas classes + estão no final do arquivo. + */ + var instancia_foo = new FooClass(3); + + // lê a variável pública normalmente + trace(instancia_foo.variavel_publica + " é o valor de instancia_foo.variavel_publica"); + + // nós podemos ler essa variável + trace(instancia_foo.publica_leitura + " é o valor de instancia_foo.publica_leitura"); + // mas não podemos escrever nela + // instancia_foo.publica_leitura = 4; // isso irá causar um erro se descomentado: + // trace(instancia_foo.public_escrita); // e isso também. + + // chama o método toString: + trace(instancia_foo + " é o valor de instancia_foo"); + // mesma coisa: + trace(instancia_foo.toString() + " é o valor de instancia_foo.toString()"); + + + /* + A instancia_foo é do tipo "FooClass", enquanto acceptBarInstance + é do tipo BarClass. Entretanto, como FooClass extende BarClass, + ela é aceita. + */ + BarClass.acceptBarInstance(instancia_foo); + + /* + As classes abaixo têm mais alguns exemplos avançados, o método + "example()" executará esses exemplos aqui: + */ + SimpleEnumTest.example(); + ComplexEnumTest.example(); + TypedefsAndStructuralTypes.example(); + UsingExample.example(); + + } + +} + +/* + Essa é a "classe filha" do classe principal LearnHaxe3 + */ +class FooClass extends BarClass implements BarInterface{ + public var variavel_publica:Int; // variáveis públicas são acessíveis de qualquer lugar + public var publica_leitura (default, null): Int; // somente leitura pública habilitada + public var publica_escrita (null, default): Int; // somente escrita pública habilitada + public var property (get, set): Int; // use este estilo para habilitar getters e setters + + // variáveis privadas não estão disponíveis fora da classe. + // veja @:allow para formas de fazer isso. + var _private:Int; // variáveis são privadas se não forem marcadas como públicas + + // um construtor público + public function new(arg:Int){ + // chama o construtor do objeto pai, já que nós extendemos a BarClass: + super(); + + this.variavel_publica = 0; + this._private = arg; + + } + + // getter para _private + function get_property() : Int { + return _private; + } + + // setter para _private + function set_property(val:Int) : Int { + _private = val; + return val; + } + + // função especial que é chamada sempre que uma instância é convertida em string. + public function toString(){ + return _private + " com o método toString()!"; + } + + // essa classe precisa ter essa função definida, pois ela implementa + // a interface BarInterface + public function baseFunction(x: Int) : String{ + // converte o int em string automaticamente + return x + " foi passado pela baseFunction!"; + } +} + +/* + Uma classe simples para extendermos +*/ +class BarClass { + var base_variable:Int; + public function new(){ + base_variable = 4; + } + public static function acceptBarInstance(b:BarClass){ + } +} + +/* + Uma interface simples para implementarmos +*/ +interface BarInterface{ + public function baseFunction(x:Int):String; +} + +////////////////////////////////////////////////////////////////// +// Declarações Enum e Switch +////////////////////////////////////////////////////////////////// + +/* + Enums no Haxe são muito poderosos. Resumidamente, enums são + um tipo com um número limitado de estados: + */ + +enum SimpleEnum { + Foo; + Bar; + Baz; +} + +// Uma classe que faz uso desse enum: + +class SimpleEnumTest{ + public static function example(){ + var e_explicit:SimpleEnum = SimpleEnum.Foo; // você pode especificar o nome "completo" + var e = Foo; // bas descoberta de tipo também funciona. + switch(e){ + case Foo: trace("e era Foo"); + case Bar: trace("e era Bar"); + case Baz: trace("e era Baz"); // comente esta linha e teremos um erro. + } + + /* + Isso não parece tão diferente de uma alteração simples de valor em strings. + Entretanto, se nós não incluirmos *todos* os estados, o compilador + reclamará. Você pode testar isso comentando a linha mencionada acima. + + Você também pode especificar um valor padrão (default) para enums: + */ + switch(e){ + case Foo: trace("e é Foo outra vez"); + default : trace("default funciona aqui também"); + } + } +} + +/* + Enums vão muito mais além que estados simples, nós também + podemos enumerar *construtores*, mas nós precisaremos de um + exemplo mais complexo de enum: + */ +enum ComplexEnum{ + IntEnum(i:Int); + MultiEnum(i:Int, j:String, k:Float); + SimpleEnumEnum(s:SimpleEnum); + ComplexEnumEnum(c:ComplexEnum); +} +// Observação: O enum acima pode incluir *outros* enums também, incluindo ele mesmo! +// Observação: Isto é o que chamamos de *Tipos de dado algébricos* em algumas outras linguagens. + +class ComplexEnumTest{ + public static function example(){ + var e1:ComplexEnum = IntEnum(4); // especificando o parâmetro enum + /* + Agora nós podemos usar switch no enum, assim como extrair qualquer + parâmetros que ele possa ter. + */ + switch(e1){ + case IntEnum(x) : trace('$x foi o parâmetro passado para e1'); + default: trace("Isso não deve ser impresso"); + } + + // outro parâmetro aqui que também é um enum... um enum enum? + var e2 = SimpleEnumEnum(Foo); + switch(e2){ + case SimpleEnumEnum(s): trace('$s foi o parâmetro passado para e2'); + default: trace("Isso não deve ser impresso"); + } + + // enum dentro de enum dentro de enum + var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3))); + switch(e3){ + // Você pode buscar por certos enums aninhados especificando-os + // explicitamente: + case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : { + trace('$i, $j, e $k foram passados dentro desse monstro aninhado.'); + } + default: trace("Isso não deve ser impresso"); + } + /* + Veja outros "tipos de dado algébricos" (GADT, do inglês) para mais + detalhes sobre o porque eles são tão úteis. + */ + } +} + +class TypedefsAndStructuralTypes { + public static function example(){ + /* + Aqui nós usaremos tipos typedef, ao invés de tipos base. + Lá no começo, nós definimos que o tipo "FooString" é um tipo "String". + */ + var t1:FooString = "alguma string"; + + /* + Aqui nós usamos typedefs para "tipos estruturais" também. Esses tipos + são definidos pela sua estrutura de campos, não por herança de classe. + Aqui temos um objeto anônimo com um campo String chamado "foo": + */ + + var anon_obj = { foo: 'hi' }; + + /* + A variável anon_obj não tem um tipo declarado, e é um objeto anônimo + de acordo com o compilador. Entretanto, lembra que lá no início nós + declaramos a typedef FooObj? Visto que o anon_obj tem a mesma estrutura, + nós podemos usar ele em qualquer lugar que um "FooObject" é esperado. + */ + + var f = function(fo:FooObject){ + trace('$fo foi passado para esta função'); + } + f(anon_obj); // chama a assinatura de FooObject com anon_obj. + + /* + Note que typedefs podem ter campos opcionais também, marcados com "?" + + typedef OptionalFooObj = { + ?optionalString: String, + requiredInt: Int + } + */ + + /* + Typedefs também funcionam com compilação condicional. Por exemplo, + nós poderíamos ter incluído isso no topo deste arquivo: + +#if( js ) + typedef Surface = js.html.CanvasRenderingContext2D; +#elseif( nme ) + typedef Surface = nme.display.Graphics; +#elseif( !flash9 ) + typedef Surface = flash8.MovieClip; +#elseif( java ) + typedef Surface = java.awt.geom.GeneralPath; +#end + + E teríamos apenas um tipo "Surface" para funcionar em todas + essas plataformas. + */ + } +} + +class UsingExample { + public static function example() { + + /* + A palavra-chave "using" é um tipo especial de import de classe que + altera o comportamento de qualquer método estático na classe. + + Neste arquivo, nós aplicamos "using" em "StringTools", que contém + alguns métodos estáticos para tratar tipos String. + */ + trace(StringTools.endsWith("foobar", "bar") + " deve ser verdadeiro!"); + + /* + Com um import "using", o primeiro argumento é extendido com o método. + O que isso significa? Bem, como "endsWith" tem um primeiro argumento + de tipo "String", isso significa que todos os tipos "String" agora + possuem o método "endsWith": + */ + trace("foobar".endsWith("bar") + " deve ser verdadeiro!"); + + /* + Essa técnica habilita uma grande quantidade de expressões para certos + tipos, e limita o escopo de modificações para um único arquivo. + + Note que a instância String *não* é modificada em tempo de execução. + O novo método adicionado não é uma parte da instância anexada, e o + compilador ainda irá gerar o código equivalente ao método estático. + */ + } + +} + +``` +Isso foi apenas o começo do que Haxe pode fazer. Para uma documentação de todos +os recursos de Haxe, veja o [manual](https://haxe.org/manual) e a +[documentação de API](https://api.haxe.org/). Para um diretório de bibliotecas de terceiros +disponíveis, veja a [Haxelib](https://lib.haxe.org/) + +Para tópicos mais avançados, dê uma olhada em: + +* [Tipos abstratos](https://haxe.org/manual/types-abstract.html) +* [Macros](https://haxe.org/manual/macro.html) +* [Recursos do compilador](https://haxe.org/manual/cr-features.html) + +Por fim, participe do [forum Haxe](https://community.haxe.org/), +ou no IRC [#haxe onfreenode](http://webchat.freenode.net/), ou no +[Chat Gitter](https://gitter.im/HaxeFoundation/haxe). -- cgit v1.2.3 From 833714f75ec5b61291c086a98238f4e570ea8fa8 Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Fri, 2 Nov 2018 04:43:08 +0530 Subject: Update csharp-pt.html.markdown Remove unnecessary newline --- pt-br/csharp-pt.html.markdown | 1 - 1 file changed, 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 2b61a8fa..53fb11e9 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -97,7 +97,6 @@ namespace Learning.CSharp // Decimal - um tipo de dados de 128 bits, com mais precisão do que outros tipos de ponto flutuante, // adequado para cálculos financeiros e monetários - decimal fooDecimal = 150.3m; // Boolean - true & false -- cgit v1.2.3 From f5b3d1c97c23a28200ca122e29578470c91b8df1 Mon Sep 17 00:00:00 2001 From: Divay Prakash Date: Sat, 17 Nov 2018 23:55:42 +0530 Subject: YAML fixes (#3400) --- pt-br/cmake-pt.html.markdown | 2 +- pt-br/cypher-pt.html.markdown | 2 +- pt-br/factor-pt.html.markdown | 2 +- pt-br/html-pt.html.markdown | 2 +- pt-br/less-pt.html.markdown | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) (limited to 'pt-br') diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown index bc3e7050..8d4c3fda 100644 --- a/pt-br/cmake-pt.html.markdown +++ b/pt-br/cmake-pt.html.markdown @@ -2,7 +2,7 @@ language: cmake contributors: - ["Bruno Alano", "https://github.com/brunoalano"] -filename: CMake +filename: CMake-br translators: - ["Lucas Pugliesi", "https://github.com/fplucas"] lang: pt-br diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown index 7cfd8dcd..9b60f771 100644 --- a/pt-br/cypher-pt.html.markdown +++ b/pt-br/cypher-pt.html.markdown @@ -1,6 +1,6 @@ --- language: cypher -filename: LearnCypher.cql +filename: LearnCypher-br.cql contributors: - ["Théo Gauchoux", "https://github.com/TheoGauchoux"] diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown index e3c8f4a9..b4b5c7f5 100644 --- a/pt-br/factor-pt.html.markdown +++ b/pt-br/factor-pt.html.markdown @@ -2,7 +2,7 @@ language: factor contributors: - ["hyphz", "http://github.com/hyphz/"] -filename: learnfactor.factor +filename: learnfactor-br.factor lang: pt-br --- diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown index 5a4bc3bc..22b7836e 100644 --- a/pt-br/html-pt.html.markdown +++ b/pt-br/html-pt.html.markdown @@ -1,6 +1,6 @@ --- language: html -filename: learnhtml.txt +filename: learnhtml-br.txt contributors: - ["Christophe THOMAS", "https://github.com/WinChris"] translators: diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown index 679a2ed2..f6cf2d71 100644 --- a/pt-br/less-pt.html.markdown +++ b/pt-br/less-pt.html.markdown @@ -1,6 +1,6 @@ --- language: less -filename: learnless.less +filename: learnless-br.less contributors: - ["Saravanan Ganesh", "http://srrvnn.me"] -- cgit v1.2.3 From 5b5fbc4e48e3ed471d7f7ec7a491a16fe5b491f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Salom=C3=A3o=20Neto?= Date: Wed, 26 Dec 2018 16:10:45 -0300 Subject: Learn Stylus in pt-BR! --- pt-br/stylus-pt.html.markdown | 228 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100755 pt-br/stylus-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown new file mode 100755 index 00000000..c42bec34 --- /dev/null +++ b/pt-br/stylus-pt.html.markdown @@ -0,0 +1,228 @@ +--- +language: stylus +filename: learnStylus-pt.styl +contributors: + - ["Salomão Neto", "https://github.com/salomaosnff"] + - ["Isaac Henrique", "https://github.com/Isaachi1"] +lang: pt-br +--- + +Stylus tem como propósito, adicionar funcionalidades às suas folhas de estilos CSS que te ajudam no desenvolvimento, sem que haja a quebra de compartibilidade entre os navegadores Web. +Entre elas estão variáveis, aninhamento, mixins, funções e muito mais. + +A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS e deixando opcional o ponto e vírgula (;), dois pontos (:) e até mesmo as chaves ({ e }), tornando assim o seu código ainda mais legível. + +Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico. + + +```stylus + +/* Estilo de código +==============================*/ + +/* As chaves, ponto e vírgula, e dois pontos são opcionais no Stylus. */ + +body { + background: #000; +} + +body { + background: #000 +} + +body { + background #000 +} + +body + background #000 + +body + background: #000; + +body + background: #000 + + +// Comentários de linha única são removidos quando Stylus é compilado para CSS. + +/* Comentários multi-line são preservados. */ + + +/* Seletores +==============================*/ + +/* Selecionando elementos dentro de outro elemento */ +body { + background: #000000; + h1 { + color: #FF0000; + } +} + +/* Ou se preferir... */ +body + background #000000 + h1 + color #FF0000 + + +/* Obtendo a referência do elemento pai +==============================*/ +a { + color: #0088dd; + &:hover { + color: #DD8800; + } +} + + +/*Variáveis +==============================*/ + + +/* + É possível armazenar um valor CSS (tais como a cor) de uma variável. + Embora seja opcional, é recomendado adicionar $ antes de um nome de variável + para que você possa distinguir uma variável de outro valor CSS. +*/ + +$primary-color = #A3A4FF +$secondary-color = #51527F +$body-font = 'Roboto', sans-serif + +/* Você pode usar as variáveis em toda a sua folha de estilo. +Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */ + +body + background-color $primary-color + color $secondary-color + font-family $body-font + +/* Quando compilar ficaria assim: */ +body { + background-color: #A3A4FF; + color: #51527F; + font-family: 'Roboto', sans-serif; +} + +/ * +Este é muito mais fácil de manter do que ter de mudar a cor +cada vez que aparece em toda a sua folha de estilo. +* / + + + +/*Mixins +==============================*/ + +/* Se você achar que você está escrevendo o mesmo código para mais de um +elemento, você pode querer armazenar esse código em um mixin. + +center() + display block + margin-left auto + margin-right auto + left 0 + right 0 + +/* Utilizando um mixin */ +body { + center() + background-color: $primary-color +} + +/* Apoś compilar ficaria assim: */ +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #A3A4FF; +} + +/* Você pode usar mixins para criar uma propriedade estenográfica. */ + +size($width, $height) + width $width + height $height + +.rectangle + size(100px, 60px) + +.square + size(40px, 40px) + +/* Você pode usar um mixin como uma propriedade CSS. */ +circle($ratio) + width $ratio * 2 + height $ratio * 2 + border-radius $ratio + +.ball + circle 25px + + +/* Interpolação +==============================*/ + +vendor(prop, args) + -webkit-{prop} args + -moz-{prop} args + {prop} args + +border-radius() + vendor('border-radius', arguments) + +box-shadow() + vendor('box-shadow', arguments) + +button + border-radius 1px 2px / 3px 4px + +/* Funções +==============================*/ + +/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */ + +body { + background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50% +} + +/** Criando sua própria função */ +somar(a, b) + a + b + +body + padding somar(10px, 5) + +/* Condições +==============================*/ +comparar(a, b) + if a > b + maior + else if a < b + menor + else + igual + +comparar(5, 2) // => maior +comparar(1, 5) // => menor +comparar(10, 10) // => igual + +/* Iterações +==============================*/ + +/** +Sintaxe de laço de repetição for: +for [, ] in +**/ + +for $item in (1..2) /* Repete o bloco 12 vezes */ + .col-{$item} + width ($item / 12) * 100% /* Calcula a largula pelo número da coluna* + +``` + +Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com. \ No newline at end of file -- cgit v1.2.3 From a33a90899f4ee52d483929c1b2b2e85d8c567d07 Mon Sep 17 00:00:00 2001 From: Leonardo Santos Date: Wed, 2 Jan 2019 08:22:46 -0200 Subject: [asymptotic-notation/pt-br] fix several typos --- pt-br/asymptotic-notation-pt.html.markdown | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'pt-br') diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown index 2f179f96..b70d26b7 100644 --- a/pt-br/asymptotic-notation-pt.html.markdown +++ b/pt-br/asymptotic-notation-pt.html.markdown @@ -13,7 +13,7 @@ lang: pt-br ## O que é? Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução - de um algoritmo através da indentificação de seu comportamento com o + de um algoritmo através da identificação de seu comportamento com o crescimento da entrada oferecida. Isso também é conhecido como taxa de crescimento do algoritmo. O algoritmo de repente torna-se lento quando o tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução @@ -33,12 +33,12 @@ Um modo seria contar o número de operações primitivas com diferentes tamanhos ## Tipos de Notação Assintótica -Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo +Na primeira seção deste documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então, para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução - *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução -, a coordernada X representa o tamanho da entrada e os pontos representam o tempo + *f(n)*. Isto resulta em um gráfico onde a coordenada Y é o tempo de execução, + a coordenada X representa o tamanho da entrada e os pontos representam o tempo de execução para dado tamanho de entrada. Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias @@ -49,7 +49,7 @@ não avalia o melhor caso, porque essas condições não são atingidas com freq Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá -que percorrer a árvore de forma apropriada, o que pode causar a analise de um +que percorrer a árvore de forma apropriada, o que pode causar a análise de um ramo inteiro. Este é o pior caso, e isto é o que você está se preparando. @@ -63,16 +63,16 @@ Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma const Função Exponencial - a^n, onde a é alguma constante ``` Estas são as funções básicas de crescimento usadas em várias notações. A lista - começa com a de crescimento mais lento (logarítima, a de execução mais rápida) + começa com a de crescimento mais lento (logarítmica, a de execução mais rápida) e segue para a de crescimento mais rápido (exponencial, de execução mais lenta). -Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais -rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear. +Repare que enquanto *n*, a entrada, cresce, cada uma dessas funções cresce mais +rápido que quadrático, polinomial e exponencial, comparadas com logarítmica e linear. Uma nota extremamente importante para notações é tentar usar os termos mais simples. Isto significa descartar constantes e termos de ordem mais baixa, pois quando o tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma -constante muito grande, 2^9001, a simplificação não afeterá sua notação. +constante muito grande, 2^9001, a simplificação não afetará sua notação. Já que queremos as formas mais simples, mudemos nossa tabela um pouco... @@ -87,7 +87,7 @@ Função Exponencial - a^n, onde *a* é uma constante ### Big-O Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos -*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade +*f(n)* seja o tempo de execução de um algoritmo e *g(n)) um tempo de complexidade arbitrário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada n (n > 0). @@ -116,7 +116,7 @@ Há alguma constante c que satisfaça a definição para todo n? 3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1) ``` -Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`. +Sim! A definição de Big-O foi atendida, portanto `f(n)` é `O(g(n))`. *Exemplo 2* @@ -146,7 +146,7 @@ Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos. ### Notas Finais -É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve. +É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algorithms & Data Structures' virá; teremos um documento sobre analisar código em breve. ## Livros -- cgit v1.2.3 From 41ef626a18766ec6eec02faa3e252622ccaf4688 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Tue, 8 Jan 2019 16:13:15 -0800 Subject: Try scss highlighting --- pt-br/stylus-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown index c42bec34..804fa806 100755 --- a/pt-br/stylus-pt.html.markdown +++ b/pt-br/stylus-pt.html.markdown @@ -15,7 +15,7 @@ A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico. -```stylus +```scss /* Estilo de código ==============================*/ @@ -225,4 +225,4 @@ for $item in (1..2) /* Repete o bloco 12 vezes */ ``` -Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com. \ No newline at end of file +Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com. -- cgit v1.2.3 From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001 From: Anindya Srivastava Date: Wed, 6 Feb 2019 07:26:25 +0530 Subject: Type correction for the output of math.sqrt() propagated across versions and languages --- pt-br/python-pt.html.markdown | 2 +- pt-br/python3-pt.html.markdown | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown index 5afd46d0..82b70117 100644 --- a/pt-br/python-pt.html.markdown +++ b/pt-br/python-pt.html.markdown @@ -464,7 +464,7 @@ Humano.ronca() #=> "*arrrrrrr*" # Você pode importar módulos import math -print math.sqrt(16) #=> 4 +print math.sqrt(16) #=> 4.0 # Você pode importar funções específicas de um módulo from math import ceil, floor diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown index ea0617f4..b72c732a 100644 --- a/pt-br/python3-pt.html.markdown +++ b/pt-br/python3-pt.html.markdown @@ -647,7 +647,7 @@ Human.grunt() # => "*grunt*" # Você pode importar módulos import math -print(math.sqrt(16)) # => 4 +print(math.sqrt(16)) # => 4.0 # Você pode importar apenas funções específicas de um módulo from math import ceil, floor -- cgit v1.2.3 From 722dc2d63fc63d9e4514280c8d44d7f87d65b7ff Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 14:31:33 -0200 Subject: Translated the Pascal text to Brazilian Portuguese (created pascal-pt.html.markdown) TO DO/Observations: -Change capitalization of native words -Change some variable names (to more portuguese-appropriate alternatives) -Introduction is still in English --- pt-br/pascal-pt.html.markdown | 208 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 pt-br/pascal-pt.html.markdown (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown new file mode 100644 index 00000000..6e175216 --- /dev/null +++ b/pt-br/pascal-pt.html.markdown @@ -0,0 +1,208 @@ +--- +language: Pascal +filename: learnpascal.pas +contributors: + - ["Raul Almeida", "http://github.com/almeidaraul"] +--- + + +>Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. +source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language)) + + + +Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) + +```pascal +//Corpo de um programa em Pascal +//isso é um comentário +{ + isso também é um comentário, + mas com várias linhas +} + +//cabeçalho do programa +program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. + +const + { + aqui você declara valores constantes + } +type + { + aqui você declara tipos não nativos + } +var + { + aqui você declara variáveis + } + +//programa de fato +begin + { + aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos + } +end. //o "end" no final do programa requer um ponto final. +``` + +```pascal +//formas de declarar uma variável +var a:integer; +var b:integer; + +var + a : integer; + b : integer; + +var a,b : integer; +``` + +```pascal +program Learn_More; +//agora, mais sobre tipos de dados e operações + +const + PI = 3.141592654; + GNU = 'GNU''s Not Unix'; + // a convenção é usar caixa alta para constantes + // constantes têm valores fixos que só podem ser alterados antes da compilação + // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) + +type + ch_array : array [0..255] of char; + // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres + md_array : array of array of integer; + // vetores de vetores são vetores multidimensionais + // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) + // vetores do tipo md_array são de duas dimensões + +//declarando variáveis +var + int, c, d : integer; + // três variáveis que guardam valores inteiros + // inteiros têm 16 bits (vão de -32768 a 32767) + r : real; + // uma variável que guarda um valor real + // reais vão de 3.4E-38 a 3.4E38 + bool : boolean; + // uma variável que guarda um valor booleano (verdadeiro ou falso) + ch : char; + // uma variável que guarda um caractere + // caracteres têm 8 bits + str : string; + // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores + // string é um vetor de caracteres com tamanho padrão de 255 elementos + s : string[50]; + // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória + my_str: ch_array; + // aqui, uma variável de um tipo personalizado declarado acima + my_2d : md_array; + // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados + + // tipos adicionais de inteiros + b : byte; // faixa [0..255] + shi : shortint; // faixa [-128..127] + smi : smallint; // faixa [-32,768..32,767] (inteiro padrão) + w : word; // faixa [0..65,535] + li : longint; // faixa [-2,147,483,648..2,147,483,647] + lw : longword; // faixa [0..4,294,967,295] + c : cardinal; // longword + i64 : int64; // faixa [-9223372036854775808..9223372036854775807] + qw : qword; // faixa [0..18,446,744,073,709,551,615] + + // tipos adicionais de reais + rr : real; // faixa depende da plataforma (8 bits, 16 bits, etc) + rs : single; // faixa [1.5E-45..3.4E38] + rd : double; // faixa [5.0E-324 .. 1.7E308] + re : extended; // faixa [1.9E-4932..1.1E4932] + rc : comp; // faixa [-2E64+1 .. 2E63-1] + +Begin + int := 1;// usa-se := para atribuir valores a variáveis + r := 3.14; + ch := 'a'; + str := 'apple'; + bool := true; + //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas) + //uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes + //aritmética + int := 1 + 1; // int deixa de ser 1 e passa a ser 2 + int := int + 1; // int = 2 + 1 = 3; + int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 3 div 2; //int = 1 + int := 1 div 2; //int = 0 + + bool := true or false; // bool = true + bool := false and true; // bool = false + bool := true xor true; // bool = false + + r := 3 / 2; // usa-se a "/" para divisões entre inteiros + r := int; // um real pode receber um valor inteiro (mas não o contrário) + + c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento] + str := 'hello' + 'world'; //concatenção de strings + + my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) + + setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 + for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) + for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa + my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + +End. +``` + +```pascal +program Functional_Programming; + +Var + i, dummy : integer; + +{ OBS: diferença entre procedimento e função + função: realiza operações e retorna valor + procedimento: só realiza operações +} +//declarando e descrevendo uma função +function fatorial_recursiva(const a: integer) : integer; +{ calcula a! recursivamente } + +// pode-se declarar variáveis locais para funções e procedimentos +// exemplo: +// Var +// local_a : integer; + +Begin + If a >= 1 Then + // o valor de retorno é atribuído como se a função fosse uma variável + fatorial_recursiva := a * fatorial_recursiva(a-1) + Else + fatorial_recursiva := 1; +End; // o END de funções e procedimentos recebe ponto e vírgula + +//declarando e descrevendo um procedimento +procedure salvainteiro(var i : integer; dummy : integer); +{ recebe entrada do usuário e salva na variável i + passagem de valor: + por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa + por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas +} + +Begin + write('Insira um inteiro: '); //escreve sem quebrar linha + readln(i); //lê i com quebra de linha + dummy := 4; // dummy não terá seu valor alterado fora do procedimento. +End; + +Begin // programa principal + dummy := 3; + salvainteiro(i, dummy); + + // escrevendo i! + writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + + // escrevendo o valor de dummy + writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro +End. + +``` + -- cgit v1.2.3 From d5529d632ff29549db61296e9c21d195625037cc Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 19:32:24 -0200 Subject: Finished the Pascal text for Brazilian Portuguese. Added some extra details about loops and if/else blocks (modified pascal-pt.html.markdown) --- pt-br/pascal-pt.html.markdown | 171 +++++++++++++++++++++++------------------- 1 file changed, 92 insertions(+), 79 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index 6e175216..3c6343ca 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -6,8 +6,8 @@ contributors: --- ->Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. -source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language)) +>Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. +fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o)) @@ -22,102 +22,105 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um } //cabeçalho do programa -program learn_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. +PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. -const +CONST { aqui você declara valores constantes } -type +TYPE { aqui você declara tipos não nativos } -var +VAR { aqui você declara variáveis } //programa de fato -begin +BEGIN { aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos + blocos de código começam com BEGIN e terminam com END (como as chaves em C) } -end. //o "end" no final do programa requer um ponto final. +END. //o "end" no final do programa requer um ponto final. ``` ```pascal //formas de declarar uma variável -var a:integer; -var b:integer; +VAR a:INTEGER; +VAR b:INTEGER; -var - a : integer; - b : integer; +VAR + a : INTEGER; + b : INTEGER; -var a,b : integer; +VAR a,b : INTEGER; ``` ```pascal -program Learn_More; +PROGRAM Learn_More; //agora, mais sobre tipos de dados e operações -const +CONST PI = 3.141592654; GNU = 'GNU''s Not Unix'; // a convenção é usar caixa alta para constantes // constantes têm valores fixos que só podem ser alterados antes da compilação // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) -type - ch_array : array [0..255] of char; - // isso declara um novo tipo de variável, ch_array, que tem 256 caracteres - md_array : array of array of integer; +TYPE + vet_char : array [0..255] of CHAR; + // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres + vet_multd : array of array of INTEGER; // vetores de vetores são vetores multidimensionais // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) - // vetores do tipo md_array são de duas dimensões + // vetores do tipo vet_multd são de duas dimensões //declarando variáveis -var - int, c, d : integer; +VAR + int, c, d : INTEGER; // três variáveis que guardam valores inteiros // inteiros têm 16 bits (vão de -32768 a 32767) - r : real; + r : REAL; // uma variável que guarda um valor real // reais vão de 3.4E-38 a 3.4E38 - bool : boolean; + bool : BOOLEAN; // uma variável que guarda um valor booleano (verdadeiro ou falso) - ch : char; + ch : CHAR; // uma variável que guarda um caractere // caracteres têm 8 bits - str : string; + str : STRING; // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores // string é um vetor de caracteres com tamanho padrão de 255 elementos - s : string[50]; + s : STRING[50]; // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória - my_str: ch_array; + my_str: vet_char; // aqui, uma variável de um tipo personalizado declarado acima - my_2d : md_array; + my_2d : vet_multd; // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados +// outros tipos de dados (pascal é uma linguagem fortemente tipada) + // tipos adicionais de inteiros - b : byte; // faixa [0..255] - shi : shortint; // faixa [-128..127] - smi : smallint; // faixa [-32,768..32,767] (inteiro padrão) - w : word; // faixa [0..65,535] - li : longint; // faixa [-2,147,483,648..2,147,483,647] - lw : longword; // faixa [0..4,294,967,295] - c : cardinal; // longword - i64 : int64; // faixa [-9223372036854775808..9223372036854775807] - qw : qword; // faixa [0..18,446,744,073,709,551,615] + b : BYTE; // faixa [0..255] + shi : SHORTINT; // faixa [-128..127] + smi : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão) + w : WORD; // faixa [0..65,535] + li : LONGINT; // faixa [-2,147,483,648..2,147,483,647] + lw : LONGWORD; // faixa [0..4,294,967,295] + c : CARDINAL; // longword + i64 : INT64; // faixa [-9223372036854775808..9223372036854775807] + qw : QWORD; // faixa [0..18,446,744,073,709,551,615] // tipos adicionais de reais - rr : real; // faixa depende da plataforma (8 bits, 16 bits, etc) - rs : single; // faixa [1.5E-45..3.4E38] - rd : double; // faixa [5.0E-324 .. 1.7E308] - re : extended; // faixa [1.9E-4932..1.1E4932] - rc : comp; // faixa [-2E64+1 .. 2E63-1] + rr : REAL; // faixa depende da plataforma (8 bits, 16 bits, etc) + rs : SINGLE; // faixa [1.5E-45..3.4E38] + rd : DOUBLE; // faixa [5.0E-324 .. 1.7E308] + re : EXTENDED; // faixa [1.9E-4932..1.1E4932] + rc : COMP; // faixa [-2E64+1 .. 2E63-1] -Begin +BEGIN int := 1;// usa-se := para atribuir valores a variáveis r := 3.14; ch := 'a'; @@ -128,13 +131,13 @@ Begin //aritmética int := 1 + 1; // int deixa de ser 1 e passa a ser 2 int := int + 1; // int = 2 + 1 = 3; - int := 4 div 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") - int := 3 div 2; //int = 1 - int := 1 div 2; //int = 0 + int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 3 DIV 2; //int = 1 + int := 1 DIV 2; //int = 0 - bool := true or false; // bool = true - bool := false and true; // bool = false - bool := true xor true; // bool = false + bool := true OR false; // bool = true + bool := false AND true; // bool = false + bool := true XOR true; // bool = false r := 3 / 2; // usa-se a "/" para divisões entre inteiros r := int; // um real pode receber um valor inteiro (mas não o contrário) @@ -144,65 +147,75 @@ Begin my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) - setlength(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 - for c := 0 to 9 do // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) - for d := 0 to 9 do // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa + // LAÇOS + WHILE (ch != 'a') DO + BEGIN + writeln('ch é diferente de a'); + IF (ch = 'c') THEN + writeln('ch é igual a c'); + END; + + SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 + FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) + FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + -End. +END. ``` ```pascal -program Functional_Programming; +PROGRAM programacao_com_funcoes; -Var - i, dummy : integer; +VAR + i, inutil : INTEGER; { OBS: diferença entre procedimento e função função: realiza operações e retorna valor procedimento: só realiza operações } //declarando e descrevendo uma função -function fatorial_recursiva(const a: integer) : integer; +FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER; { calcula a! recursivamente } // pode-se declarar variáveis locais para funções e procedimentos // exemplo: -// Var -// local_a : integer; +// VAR +// local_a : INTEGER; -Begin - If a >= 1 Then +BEGIN + // obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila) + IF a >= 1 THEN // o valor de retorno é atribuído como se a função fosse uma variável fatorial_recursiva := a * fatorial_recursiva(a-1) - Else + ELSE fatorial_recursiva := 1; -End; // o END de funções e procedimentos recebe ponto e vírgula +END; // o END de funções e procedimentos recebe ponto e vírgula //declarando e descrevendo um procedimento -procedure salvainteiro(var i : integer; dummy : integer); +PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER); { recebe entrada do usuário e salva na variável i passagem de valor: por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa - por valor - "dummy: integer"; implica que o valor do argumento é copiado e alterações na variável dummy não são guardadas + por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas } -Begin - write('Insira um inteiro: '); //escreve sem quebrar linha - readln(i); //lê i com quebra de linha - dummy := 4; // dummy não terá seu valor alterado fora do procedimento. -End; +BEGIN + WRITE('Insira um inteiro: '); //escreve sem quebrar linha + READLN(i); //lê i com quebra de linha + inutil := 4; // inutil não terá seu valor alterado fora do procedimento. +END; -Begin // programa principal - dummy := 3; - salvainteiro(i, dummy); +BEGIN // programa principal + inutil := 3; + salvainteiro(i, inutil); // escrevendo i! - writeln(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita - // escrevendo o valor de dummy - writeln('dummy = ', dummy); // sempre vai escrever 3, já que o valor de dummy não é alterado por salvainteiro -End. + // escrevendo o valor de inutil + WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro +END. ``` -- cgit v1.2.3 From a689a8c7dbef6b6148ba10ebcf910fc77a98ccae Mon Sep 17 00:00:00 2001 From: Raul Gomes Pimentel de Almeida Date: Mon, 11 Feb 2019 19:58:20 -0200 Subject: Minor changes on line breaking for Pascal in pt-br --- pt-br/pascal-pt.html.markdown | 84 +++++++++++++++++++++++++++++-------------- 1 file changed, 57 insertions(+), 27 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index 3c6343ca..d6d675c3 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -2,7 +2,9 @@ language: Pascal filename: learnpascal.pas contributors: - - ["Raul Almeida", "http://github.com/almeidaraul"] + - ["Ganesha Danu", "https://github.com/blinfoldking"] + - ["Keith Miyake", "https//github.com/kaymmm"] + - ["Raul Almeida", "https://github.com/almeidaraul"] --- @@ -11,7 +13,8 @@ fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa -Para compilar e executar um programa em Pascal, você pode usar o freepascal, um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) +Para compilar e executar um programa em Pascal, você pode usar o freepascal, +um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/) ```pascal //Corpo de um programa em Pascal @@ -22,7 +25,8 @@ Para compilar e executar um programa em Pascal, você pode usar o freepascal, um } //cabeçalho do programa -PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do programa deve começar com uma letra. +PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do +programa deve começar com uma letra. CONST { @@ -40,8 +44,11 @@ VAR //programa de fato BEGIN { - aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos - blocos de código começam com BEGIN e terminam com END (como as chaves em C) + aqui ficam todas as instruções que não pertencem nem a funções + nem a procedimentos + + blocos de código começam com BEGIN e terminam com END + (como as chaves em C) } END. //o "end" no final do programa requer um ponto final. ``` @@ -65,16 +72,20 @@ PROGRAM Learn_More; CONST PI = 3.141592654; GNU = 'GNU''s Not Unix'; - // a convenção é usar caixa alta para constantes - // constantes têm valores fixos que só podem ser alterados antes da compilação - // constantes podem ser de qualquer tipo nativo (integer, real, boolean, char, string) + { a convenção é usar caixa alta para constantes + + constantes têm valores fixos que só podem ser alterados + antes da compilação + + constantes podem ser de qualquer tipo nativo (integer, real, boolean, + char, string) TYPE vet_char : array [0..255] of CHAR; - // isso declara um novo tipo de variável, vet_char, que tem 256 caracteres + // isso declara um novo tipo de variável, vet_char, com 256 caracteres vet_multd : array of array of INTEGER; // vetores de vetores são vetores multidimensionais - // pode-se definir vetores de tamanho 0 (daí, usa-se alocação dinâmica) + // use vetores de tamanho 0 (daí, usa-se alocação dinâmica) // vetores do tipo vet_multd são de duas dimensões //declarando variáveis @@ -91,14 +102,14 @@ VAR // uma variável que guarda um caractere // caracteres têm 8 bits str : STRING; - // esse tipo de variável não é padrão, mas é incluído na maioria dos compiladores + // STRING não é um tipo padrão, mas vem na maioria dos compiladores // string é um vetor de caracteres com tamanho padrão de 255 elementos s : STRING[50]; - // você pode especificar o tamanho de uma string desta maneira para otimizar o uso de memória + // especificar o tamanho de uma string assim otimiza o uso de memória my_str: vet_char; // aqui, uma variável de um tipo personalizado declarado acima my_2d : vet_multd; - // vetores de alocação dinâmica de memória precisam receber um tamanho antes de serem usados + // defina o tamanho de vetores dinâmicos antes de usá-los // outros tipos de dados (pascal é uma linguagem fortemente tipada) @@ -127,11 +138,12 @@ BEGIN str := 'apple'; bool := true; //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas) - //uma opção de organização é usar maiúsculas para termos da linguagem (BEGIN, END, INTEGER, etc) e constantes - //aritmética + // uma opção de organização é usar maiúsculas para termos da linguagem + // (BEGIN, END, INTEGER, etc) e constantes + // aritmética int := 1 + 1; // int deixa de ser 1 e passa a ser 2 int := int + 1; // int = 2 + 1 = 3; - int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira, ou seja, o resto é "jogado fora") + int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira - ignora o resto) int := 3 DIV 2; //int = 1 int := 1 DIV 2; //int = 0 @@ -145,7 +157,8 @@ BEGIN c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento] str := 'hello' + 'world'; //concatenção de strings - my_str[0] := 'a'; // só se pode atribuir valores a vetores elemento por elemento (não o vetor inteiro de uma vez) + my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento + por elemento (não o vetor inteiro de uma vez) } // LAÇOS WHILE (ch != 'a') DO @@ -155,10 +168,15 @@ BEGIN writeln('ch é igual a c'); END; - SETLENGTH(my_2d,10,10); // inicialização de um vetor com alocação dinâmica de memória; my_2d vira um 10x10 - FOR c := 0 to 9 DO // vetores começam em 0 e terminam em tamanho-1 (exceto se, na declaração do tipo, forem especificados valores diferentes) - FOR d := 0 to 9 DO // a variável usada em um laço FOR deve ter sido declarada no cabeçalho do programa - my_2d[c,d] := c * d; // acessam-se elementos de vetores multidimensionais com [dimensão1, dimensão2, dimensão3...] + SETLENGTH(my_2d,10,10); + // inicialização de um vetor com alocação dinâmica; my_2d vira um 10x10 + FOR c := 0 to 9 DO + { vetores começam em 0 e terminam em tamanho-1 + (exceto se, declarando o tipo, forem especificados valores diferentes) } + FOR d := 0 to 9 DO + // a variável usada em um laço FOR deve ter sido declarada no cabeçalho + my_2d[c,d] := c * d; + // acessam-se elementos de vetores multidimensionais com [d1, d2, d3...] END. @@ -184,7 +202,14 @@ FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER; // local_a : INTEGER; BEGIN - // obs: o ELSE só funciona se não houver ponto e vírgula no bloco do IF (exemplo: IF a THEN writeln('a'); ELSE writeln('b') é um programa que não compila) + { O bloco ELSE só funciona se não houver ponto e vírgula no bloco do IF + exemplo: + IF a THEN + writeln('a'); + ELSE + writeln('b'); + Isso não permitiria que o programa compilasse } + IF a >= 1 THEN // o valor de retorno é atribuído como se a função fosse uma variável fatorial_recursiva := a * fatorial_recursiva(a-1) @@ -196,8 +221,12 @@ END; // o END de funções e procedimentos recebe ponto e vírgula PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER); { recebe entrada do usuário e salva na variável i passagem de valor: - por referência - "VAR i: integer"; implica que alterações na variável i dentro da função são guardadas para o escopo de todo o programa - por valor - "inutil: integer"; implica que o valor do argumento é copiado e alterações na variável inutil não são guardadas + + POR REFERÊNCIA - "VAR i: integer"; implica que alterações na variável i + dentro da função são guardadas para o escopo de todo o programa + + POR VALOR - "inutil: integer"; implica que o valor do argumento é copiado + e alterações na variável inutil não são guardadas } BEGIN @@ -211,10 +240,11 @@ BEGIN // programa principal salvainteiro(i, inutil); // escrevendo i! - WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha; valores numéricos são automaticamente convertidos para texto na escrita + WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha + // valores numéricos são automaticamente convertidos para texto na escrita - // escrevendo o valor de inutil - WRITELN('inutil = ', inutil); // sempre vai escrever 3, já que o valor de inutil não é alterado por salvainteiro + // escrever valor de inutil (sempre 3, já que salvainteiro não a altera) + WRITELN('inutil = ', inutil); END. ``` -- cgit v1.2.3 From 14357102aa1c818272b7c5077adbc4fca62e5b7b Mon Sep 17 00:00:00 2001 From: Andre Polykanine Date: Wed, 13 Feb 2019 02:14:08 +0200 Subject: Fixed frontmatter --- pt-br/pascal-pt.html.markdown | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'pt-br') diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown index d6d675c3..3a37271a 100644 --- a/pt-br/pascal-pt.html.markdown +++ b/pt-br/pascal-pt.html.markdown @@ -1,10 +1,12 @@ --- language: Pascal -filename: learnpascal.pas +filename: learnpascal-pt.pas contributors: - - ["Ganesha Danu", "https://github.com/blinfoldking"] - - ["Keith Miyake", "https//github.com/kaymmm"] + - ["Ganesha Danu", "https://github.com/blinfoldking"] + - ["Keith Miyake", "https//github.com/kaymmm"] +translators: - ["Raul Almeida", "https://github.com/almeidaraul"] +lang: pt-br --- @@ -43,7 +45,7 @@ VAR //programa de fato BEGIN - { + 80 aqui ficam todas as instruções que não pertencem nem a funções nem a procedimentos -- cgit v1.2.3 From ed100434e33ed95e69620fc9ff6167bb130d3862 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= Date: Fri, 8 Mar 2019 17:18:42 +0100 Subject: Move "awk" articles to the "tool" category --- pt-br/awk-pt.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown index 761f5294..9bf770fd 100644 --- a/pt-br/awk-pt.html.markdown +++ b/pt-br/awk-pt.html.markdown @@ -1,5 +1,6 @@ --- -language: awk +category: tool +tool: awk filename: learnawk-pt.awk contributors: - ["Marshall Mason", "http://github.com/marshallmason"] -- cgit v1.2.3 From 6ca3b99774483f320cd430b8166df58dba178dc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= Date: Fri, 8 Mar 2019 17:20:20 +0100 Subject: Move "cmake" articles to the "tool" category --- pt-br/cmake-pt.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown index 8d4c3fda..d11fe4f4 100644 --- a/pt-br/cmake-pt.html.markdown +++ b/pt-br/cmake-pt.html.markdown @@ -1,5 +1,6 @@ --- -language: cmake +category: tool +tool: cmake contributors: - ["Bruno Alano", "https://github.com/brunoalano"] filename: CMake-br -- cgit v1.2.3 From 0a3207587d7a548f1691f11a7bff2bfead264026 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= Date: Fri, 8 Mar 2019 17:21:53 +0100 Subject: Move "make" articles to the "tool" category --- pt-br/make-pt.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown index 8e7603cc..cbdebde7 100644 --- a/pt-br/make-pt.html.markdown +++ b/pt-br/make-pt.html.markdown @@ -1,5 +1,6 @@ --- -language: make +category: tool +tool: make contributors: - ["Robert Steed", "https://github.com/robochat"] - ["Stephan Fuhrmann", "https://github.com/sfuhrm"] -- cgit v1.2.3 From 52c74e4f17f034a398a85a8f7832264f31bb9787 Mon Sep 17 00:00:00 2001 From: Claudio Busatto Date: Wed, 27 Mar 2019 19:46:41 +0100 Subject: Fix layout and typos --- pt-br/coffeescript-pt.html.markdown | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'pt-br') diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown index 8b1094b1..37a70006 100644 --- a/pt-br/coffeescript-pt.html.markdown +++ b/pt-br/coffeescript-pt.html.markdown @@ -31,24 +31,24 @@ Você deveria entender mais de semântica de JavaScript antes de continuar... ### # Tarefa: -numero = 42 #=> número var = 42; +numero = 42 #=> var numero = 42; oposto = true #=> var oposto = true; # Condições: -numero = -42 if oposto #=> if (oposto) {número = -42;} +numero = -42 if oposto #=> if (oposto) {numero = -42;} # Funções: quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;} -preencher = (recipiente, líquido = "coffee") -> - "Preenchendo o #{recipiente} with #{líquido}..." +preencher = (recipiente, liquido = "coffee") -> + "Preenchendo o #{recipiente} with #{liquido}..." #=>var preencher; # -#preencher = function(recipiente, líquido) { -# if (líquido == null) { -# líquido = "coffee"; +#preencher = function(recipiente, liquido) { +# if (liquido == null) { +# liquido = "coffee"; # } -# return "Preenchendo o " + recipiente + " with " + líquido + "..."; +# return "Preenchendo o " + recipiente + " with " + liquido + "..."; #}; # Alcances: @@ -90,17 +90,18 @@ cubes = (math.cube num for num in list) # return _results; # })(); -comidas = ['brócolis', 'espinafre', 'chocolate'] +comidas = ['brocolis', 'espinafre', 'chocolate'] eat alimento for alimento in comidas when alimento isnt 'chocolate' -#=>comidas = ['brócolis', 'espinafre', 'chocolate']; +#=>comidas = ['brocolis', 'espinafre', 'chocolate']; # #for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) { # alimento = comidas[_k]; # if (alimento !== 'chocolate') { # eat(alimento); # } +``` ## Recursos adicionais - [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) -- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) \ No newline at end of file +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) -- cgit v1.2.3 From 56e7570b12b001d4c094c9a8b8b10508f3db6f19 Mon Sep 17 00:00:00 2001 From: Claudio Busatto Date: Wed, 27 Mar 2019 19:48:50 +0100 Subject: Include me as a contributor --- pt-br/coffeescript-pt.html.markdown | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) (limited to 'pt-br') diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown index 37a70006..03098e90 100644 --- a/pt-br/coffeescript-pt.html.markdown +++ b/pt-br/coffeescript-pt.html.markdown @@ -3,19 +3,20 @@ language: coffeescript contributors: - ["Tenor Biel", "http://github.com/L8D"] - ["Xavier Yao", "http://github.com/xavieryao"] + - ["Claudio Busatto", "http://github.com/cjcbusatto"] translators: - ["Miguel Araújo", "https://github.com/miguelarauj1o"] lang: pt-br filename: learncoffeescript-pt.coffee --- -CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript -equivalente, e não há interpretação em tempo de execução. Como um dos sucessores -de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, -bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de +CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript +equivalente, e não há interpretação em tempo de execução. Como um dos sucessores +de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, +bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de execução JavaScript. -Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial +Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial completo sobre CoffeeScript. ``` coffeescript @@ -23,21 +24,21 @@ completo sobre CoffeeScript. #Segue as tendências de muitas linguagens modernas #Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos. -### -Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e +### +Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e '* /'s para o código JavaScript que resulta... -Você deveria entender mais de semântica de JavaScript antes de continuar... +Você deveria entender mais de semântica de JavaScript antes de continuar... ### -# Tarefa: -numero = 42 #=> var numero = 42; +# Tarefa: +numero = 42 #=> var numero = 42; oposto = true #=> var oposto = true; -# Condições: +# Condições: numero = -42 if oposto #=> if (oposto) {numero = -42;} -# Funções: +# Funções: quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;} preencher = (recipiente, liquido = "coffee") -> @@ -51,7 +52,7 @@ preencher = (recipiente, liquido = "coffee") -> # return "Preenchendo o " + recipiente + " with " + liquido + "..."; #}; -# Alcances: +# Alcances: list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5]; # Objetos: @@ -79,7 +80,7 @@ alert "Eu sabia!" if elvis? #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); } # Compressão de Matrizes: -cubes = (math.cube num for num in list) +cubes = (math.cube num for num in list) #=>cubes = (function() { # var _i, _len, _results; # _results = []; -- cgit v1.2.3 From fc7e08639656cba77170160880f505d9f3dfe044 Mon Sep 17 00:00:00 2001 From: Claudio Busatto Date: Wed, 27 Mar 2019 20:00:34 +0100 Subject: User data has to follow the grammar of the target language --- pt-br/coffeescript-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown index 03098e90..7129a463 100644 --- a/pt-br/coffeescript-pt.html.markdown +++ b/pt-br/coffeescript-pt.html.markdown @@ -91,9 +91,9 @@ cubes = (math.cube num for num in list) # return _results; # })(); -comidas = ['brocolis', 'espinafre', 'chocolate'] +comidas = ['brócolis', 'espinafre', 'chocolate'] eat alimento for alimento in comidas when alimento isnt 'chocolate' -#=>comidas = ['brocolis', 'espinafre', 'chocolate']; +#=>comidas = ['brócolis', 'espinafre', 'chocolate']; # #for (_k = 0, _len2 = comidas.length; _k < _len2; _k++) { # alimento = comidas[_k]; -- cgit v1.2.3 From 9f7893995ca5653ccb651181a76d7bb19883a43a Mon Sep 17 00:00:00 2001 From: Raphael Date: Sat, 1 Jun 2019 10:32:20 -0300 Subject: fix some typos --- pt-br/clojure-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown index 7e8b3f7b..b88d4eec 100644 --- a/pt-br/clojure-pt.html.markdown +++ b/pt-br/clojure-pt.html.markdown @@ -340,7 +340,7 @@ keymap ; => {:a 1, :b 2, :c 3} (def my-atom (atom {})) ; Atualize o atom com um swap!. -; swap! pega uma funçnao and chama ela com o valor atual do atom +; swap! pega uma função e chama ela com o valor atual do atom ; como primeiro argumento, e qualquer argumento restante como o segundo (swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de (assoc {} :a 1) (swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2) -- cgit v1.2.3 From 3e1fe4dc0077817c8946fc8644c29d2ba585b0e1 Mon Sep 17 00:00:00 2001 From: Victor Bastos Date: Tue, 1 Oct 2019 11:55:55 -0300 Subject: [php/pt-br] Small typo --- pt-br/php-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown index 8a1c956e..e55f1100 100644 --- a/pt-br/php-pt.html.markdown +++ b/pt-br/php-pt.html.markdown @@ -20,7 +20,7 @@ Este documento descreve PHP 5+. // Duas barras iniciam o comentário de uma linha. -# O hash (aka pound symbol) também inicia, mas // é mais comum. +# O hash (conhecido como "pound symbol") também inicia, mas // é mais comum. /* O texto envolto por barra-asterisco e asterisco-barra -- cgit v1.2.3 From 4df895568d5600f20636e88b58cdfd74e7df4410 Mon Sep 17 00:00:00 2001 From: Victor Bastos Date: Tue, 1 Oct 2019 11:58:32 -0300 Subject: [cypher/pt-br] Small typo --- pt-br/cypher-pt.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'pt-br') diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown index 9b60f771..d4400148 100644 --- a/pt-br/cypher-pt.html.markdown +++ b/pt-br/cypher-pt.html.markdown @@ -101,7 +101,7 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) ) Crie consultas --- -Create a new node +Crie um novo nó ``` CREATE (a:Person {name:"Théo Gauchoux"}) RETURN a -- cgit v1.2.3 From 1e17f8e3c7c3e7c3bf287af242dc4311f5cda615 Mon Sep 17 00:00:00 2001 From: Antonio Roberto Furlaneto Date: Tue, 1 Oct 2019 12:07:14 -0300 Subject: [csharp/pt-br] Missing translation --- pt-br/csharp-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 2ff59296..3bdbcdb1 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -85,8 +85,8 @@ namespace Learning.CSharp // Long - 64-bit integer long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) - // Numbers default to being int or uint depending on size. - // L is used to denote that this variable value is of type long or ulong + // Números por padrão são int ou uint dependendo do tamanho. + // L é usado para denotar que o valor da variável é do tipo long ou ulong. // Double - Double-precision 64-bit IEEE 754 Floating Point double fooDouble = 123.4; // Precision: 15-16 digits -- cgit v1.2.3 From 1ccbe647ede9c36aa1d789811826e43341b7911f Mon Sep 17 00:00:00 2001 From: Victor Bastos Date: Tue, 1 Oct 2019 12:10:38 -0300 Subject: [typescript/pt-br] Small typo --- pt-br/typescript-pt.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'pt-br') diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown index 077aa2cc..e8ed6a7f 100644 --- a/pt-br/typescript-pt.html.markdown +++ b/pt-br/typescript-pt.html.markdown @@ -22,7 +22,7 @@ var isDone: boolean = false; var lines: number = 42; var name: string = "Anders"; -// Quando é impossível saber, há o "Qualquer" tipo +// Quando é impossível saber, há o tipo "Qualquer" var notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // Ok, definitivamente um boolean @@ -65,7 +65,7 @@ interface Person { move(): void; } -// Objeto que implementa a "Pessoa" Interface +// Objeto que implementa a Interface "Pessoa" // Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades var p: Person = { name: "Bobby", move: () => {} }; // Os objetos que têm a propriedade opcional: -- cgit v1.2.3 From 0e5203510bcd6500d707e0a03f30cb9f90b93cac Mon Sep 17 00:00:00 2001 From: Fer Date: Tue, 1 Oct 2019 12:16:59 -0300 Subject: [css/pt-br] Translation adjustments --- pt-br/css-pt.html.markdown | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'pt-br') diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown index c73669d0..1c4be746 100644 --- a/pt-br/css-pt.html.markdown +++ b/pt-br/css-pt.html.markdown @@ -14,15 +14,15 @@ translators: lang: pt-br --- -Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum. +No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornara comum. -CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web. +CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web. CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles. -Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular. +Este guia foi escrito para CSS2, embora CSS3 esteja rapidamente se tornando popular. -**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/). +**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa treinar em um playground CSS como [dabblet](http://dabblet.com/). O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais. ```css @@ -42,7 +42,7 @@ Abaixo um elemento de exemplo:
*/ -/* Você pode direciona-lo usando uma das suas classes CSS */ +/* Você pode direcioná-lo usando uma das suas classes CSS */ .class1 { } /* ou ambas as classes! */ @@ -82,9 +82,9 @@ classe div.some [attr $ = 'ue'] {} /* Você pode selecionar um elemento que é filho de outro elemento */ div.some-parent> .class-name {} -/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de -   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes -   nivelar por baixo da árvore. */ +/* Ou um descendente de um outro elemento. Os filhos são os descendentes diretos de +   seu elemento pai, apenas um nível abaixo da árvore. Pode ser quaisquer descendentes +   nivelados por baixo da árvore. */ div.some-parent class-name {} /* Atenção: o mesmo seletor sem espaço tem um outro significado. @@ -118,7 +118,7 @@ seletor:first-child {} /* Qualquer elemento que é o último filho de seu pai */ seletor:last-child {} -/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */ +/* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */ /* Corresponde a um primeiro filho virtual do elemento selecionado */ seletor::before {} @@ -127,7 +127,7 @@ seletor::before {} seletor::after {} /* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos -   elemento */ +   os elementos */ * {} /* */ Todos os elementos .parent * {} /* */ todos os descendentes .parent> * {} /* */ todas as crianças @@ -181,7 +181,7 @@ seletor { ## Uso -Guardar uma folha de estilo CSS com a extensão `.css`. +Salvar uma folha de estilo CSS com a extensão `.css`. ```xml +não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.--> - +específico para um determinado interpretador --> +que deseja estar nesse elemento por um número de cerquilhas (#) --> # Isto é um cabeçalho

## Isto é um cabeçalho

### Isto é um cabeçalho

@@ -65,7 +66,7 @@ uma ou múltiplas linhas em branco. --> Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal? -Agora, eu estou no parágrado 2. +Agora, eu estou no parágrafo 2. ... Ainda continuo no parágrafo 2! :) Eu estou no parágrafo três. @@ -111,7 +112,7 @@ ou 1. Item um 2. Item dois -3. Tem três +3. Item três -- cgit v1.2.3 From 53488ee57128a653f7a4d65d9abc9e11dc69ede7 Mon Sep 17 00:00:00 2001 From: bfmonique <42034934+bfmonique@users.noreply.github.com> Date: Tue, 29 Oct 2019 20:09:46 -0300 Subject: Fix python3-pt portuguese mistakes --- pt-br/python3-pt.html.markdown | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'pt-br') diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown index b72c732a..23a9b3ce 100644 --- a/pt-br/python3-pt.html.markdown +++ b/pt-br/python3-pt.html.markdown @@ -7,6 +7,7 @@ contributors: - ["Zachary Ferguson", "http://github.com/zfergus2"] translators: - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"] + - ["Monique Baptista", "https://github.com/bfmonique"] lang: pt-br filename: learnpython3-pt.py --- @@ -44,7 +45,7 @@ aprender o velho Python 2.7. 8 - 1 # => 7 10 * 2 # => 20 -# Números inteiros por padrão, exceto na divisão, que retorna número +# Números são inteiros por padrão, exceto na divisão, que retorna número # de ponto flutuante (float). 35 / 5 # => 7.0 @@ -64,7 +65,7 @@ aprender o velho Python 2.7. # Exponenciação (x**y, x elevado à potência y) 2**4 # => 16 -# Determine a precedência usando parêntesis +# Determine a precedência usando parênteses (1 + 3) * 2 # => 8 # Valores lógicos são primitivos (Atenção à primeira letra maiúscula) @@ -105,9 +106,8 @@ False or True # => True 1 < 2 < 3 # => True 2 < 3 < 2 # => False -# (operador 'is' e operador '==') is verifica se duas variáveis -# referenciam um mesmo objeto, mas == verifica se as variáveis -# apontam para o mesmo valor. +# 'is' verifica se duas variáveis representam o mesmo endereço +# na memória; '==' verifica se duas variáveis têm o mesmo valor a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4] b = a # b referencia o que está referenciado por a b is a # => True, a e b referenciam o mesmo objeto @@ -174,7 +174,7 @@ input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado e # Observação: Em versões antigas do Python, o método input() era chamado raw_input() # Não é necessário declarar variáveis antes de iniciá-las -# È uma convenção usar letras_minúsculas_com_sublinhados +# É uma convenção usar letras_minúsculas_com_sublinhados alguma_variavel = 5 alguma_variavel # => 5 @@ -182,31 +182,31 @@ alguma_variavel # => 5 # Veja Controle de Fluxo para aprender mais sobre tratamento de exceções. alguma_variavel_nao_inicializada # Gera a exceção NameError -# Listas armazenam sequencias +# Listas armazenam sequências li = [] -# Você pode iniciar com uma lista com alguns valores +# Você pode iniciar uma lista com valores outra_li = [4, 5, 6] -# Adicionar conteúdo ao fim da lista com append +# Adicione conteúdo ao fim da lista com append li.append(1) # li agora é [1] li.append(2) # li agora é [1, 2] li.append(4) # li agora é [1, 2, 4] li.append(3) # li agora é [1, 2, 4, 3] -# Remover do final da lista com pop +# Remova do final da lista com pop li.pop() # => 3 e agora li é [1, 2, 4] # Vamos colocá-lo lá novamente! li.append(3) # li agora é [1, 2, 4, 3] novamente. -# Acessar uma lista da mesma forma que você faz com um array +# Acesse uma lista da mesma forma que você faz com um array li[0] # => 1 -# Acessa o último elemento +# Acessando o último elemento li[-1] # => 3 -# Acessando além dos limites gera um IndexError +# Acessar além dos limites gera um IndexError li[4] # Gera o IndexError # Você pode acessar vários elementos com a sintaxe de limites -# (É um limite fechado, aberto pra você que gosta de matemática.) +# Inclusivo para o primeiro termo, exclusivo para o segundo li[1:3] # => [2, 4] # Omitindo o final li[2:] # => [4, 3] -- cgit v1.2.3