adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-25 08:13:29 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #955 from suuuzi/master

Browse Source 
Translating brainfuck & git to pt-br; Fixing typos in git pt-pt translation; Adding links refering other tutorials
This commit is contained in:
ven 2015-03-21 16:55:06 +01:00
commit 74ae2554d2
5 changed files with 253 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
pt-br/brainfuck-pt.html.markdown Normal file
View File

@ -0,0 +1,84 @@
---
language: brainfuck
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["Suzane Sant Ana", "http://github.com/suuuzi"]
lang: pt-pt
---
Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de
programação Turing-completa extremamente simples com apenas 8 comandos.
```
Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
e um ponteiro de dados que aponta para a célula atual.
Existem 8 comandos:
+ : Incrementa o vaor da célula atual em 1.
- : Decrementa o valor da célula atual em 1.
> : Move o ponteiro de dados para a célula seguinte (célula à direita).
< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
, : Lê um único caractere para a célula atual.
[ : Se o valor da célula atual for zero, salta para o ] correspondente.
Caso contrário, passa para a instrução seguinte.
] : Se o valor da célula atual for zero, passa para a instrução seguinte.
Caso contrário, volta para a instrução relativa ao [ correspondente.
[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
Vamos ver alguns exemplos básicos em brainfuck:
++++++ [ > ++++++++++ < - ] > +++++ .
Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
continuando com a instrução seguinte).
Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
, [ > + < - ] > .
Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
célula #2 e imprimimos o valor em ASCII.
Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
o mesmo programa da seguinte maneira:
,[>+<-]>.
Tente descobrir o que este programa faz:
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
Este programa lê dois números e os multiplica.
Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
#2, incrementando o valor da célula #3. Porém existe um problema, no final do
ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
célula #4 é também incrementado e copiado para a célula #2.
```
E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
seus próprios programas em brainfuck, ou então escrever um interpretador de
brainfuck em outra linguagem. O interpretador é relativamente fácil de se
implementar, mas caso você seja masoquista, tente escrever um interpretador de
brainfuck… em brainfuck.

312
pt-br/git-pt.html.markdown
View File

@ -1,110 +1,119 @@
--- ---
category: tool category: tool
tool: git tool: git
lang: pt-pt
filename: LearnGit.txt
contributors: contributors:
- ["Jake Prather", "http://github.com/JakeHP"] - ["Jake Prather", "http://github.com/JakeHP"]
translators: translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"] - ["Suzane Sant Ana", "http://github.com/suuuzi"]
lang: pt-br
filename: learngit-pt.txt
--- ---
Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte. Git é um sistema distribuido de gestão para código fonte e controle de versões.
Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona Funciona através de uma série de registos de estado do projeto e usa esse
com esses momentos para lhe fornecer a funcionalidade para a versão e registo para permitir funcionalidades de versionamento e gestão de código
gerenciar o seu código-fonte. fonte.
## Versionando Conceitos ## Conceitos de versionamento
### O que é controle de versão? ### O que é controle de versão
O controle de versão é um sistema que registra alterações em um arquivo ou conjunto Controle de versão (*source control*) é um processo de registo de alterações
de arquivos, ao longo do tempo. a um arquivo ou conjunto de arquivos ao longo do tempo.
### Versionamento Centralizado VS Versionamento Distribuído ### Controle de versão: Centralizado VS Distribuído
* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos. * Controle de versão centralizado foca na sincronização, registo e *backup*
* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único. de arquivos.
* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN, * Controle de versão distribuído foca em compartilhar alterações. Cada
sistema centralizado, com git. alteração é associada a um *id* único.
* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
centralizado ao estilo SVN usando git.
[Informação Adicional](http://git-scm.com/book/en/Getting-Started-About-Version-Control) [Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
### Porque usar o Git? ### Por que usar git?
* Possibilidade de trabalhar offline * Permite trabalhar offline.
* Colaborar com os outros é fácil! * Colaborar com outros é fácil!
* Ramificação é fácil * Criar *branches* é fácil!
* Mesclagem é fácil * Fazer *merge* é fácil!
* Git é rápido * Git é rápido.
* Git é flexível. * Git é flexivel.
## Git - Arquitetura
## Arquitetura Git
### Repositório ### Repositório
Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o Um conjunto de arquivos, diretórios, registos históricos, *commits* e
como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do referências. Pode ser descrito como uma estrutura de dados de código fonte
código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas. com a particularidade de cada elemento do código fonte permitir acesso ao
histórico das suas alterações, entre outras coisas.
Um repositório git é composto do diretório git. e árvore de trabalho. Um repositório git é constituido pelo diretório .git e a *working tree*
### Diretório .git (componente do repositório) ### Diretório .git (componente do repositório)
O diretório git. contém todas as configurações, registros, galhos, cabeça(HEAD) e muito mais. O repositório .git contém todas as configurações, *logs*, *branches*,
[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) referências e outros.
### Árvore de trabalho (componente do repositório) [Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida ### *Working Tree* (componente do repositório)
como seu diretório de trabalho.
### Índice (componente do diretório .git) A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho ### *Index* (componente do diretório .git)
a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
repositório Git.
### Comete (commit) O *Index* é a camada da interface no git. É o elemento que separa
o diretório do projeto do repositório git. Isto permite aos programadores um
maior controle sobre o que é registado no repositório git.
A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho. ### *Commit*
Por exemplo, se você adicionou 5 imagens, e removeu outros dois, estas mudanças serão contidas
em um commit (ou instantâneo). Esta confirmação pode ser empurrado para outros repositórios, ou não!
### Ramo (branch) Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto.
Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações
serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
para outros repositórios ou não!
Um ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como ### *Branch*
você se comprometer, este ponteiro irá atualizar automaticamente e apontar para o último commit.
### Cabeça (HEAD) e cabeça (head) (componente do diretório .git) Um *branch* é essencialmente uma referência que aponta para o último *commit*
efetuado. Na medida que são feitos novos commits, esta referência é atualizada
automaticamente e passa a apontar para o commit mais recente.
HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD. ### *HEAD* e *head* (componentes do diretório .git)
head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
### Recursos Conceituais *HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
uma *HEAD* activa.
*head* é uma referência que aponta para qualquer *commit*. Um repositório pode
ter um número indefinido de *heads*
* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/) ### Recursos conceituais (EN)
* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/)
* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html) * [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
## Comandos ## Comandos
### init ### *init*
Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas, Cria um repositório Git vazio. As definições, informação guardada e outros do
e mais são armazenados em um diretório (pasta) com o nome ". git". repositório git são guardados em uma pasta chamada ".git".
```bash ```bash
$ git init $ git init
``` ```
### config ### *config*
Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou Permite configurar as definições, sejam as definições do repositório, sistema
configurações globais. ou configurações globais.
```bash ```bash
# Impressão e definir algumas variáveis ​​de configuração básica (global) # Imprime e define algumas variáveis de configuração básicas (global)
$ git config --global user.email $ git config --global user.email
$ git config --global user.name $ git config --global user.name
@ -112,22 +121,21 @@ $ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name" $ git config --global user.name "My Name"
``` ```
[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config) [Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
### help ### help
Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
apenas dar-lhe um rápido lembrete de algumas semânticas.
```bash ```bash
# Rapidamente verificar os comandos disponíveis # Ver rapidamente os comandos disponiveis
$ git help $ git help
# Confira todos os comandos disponíveis # Ver todos os comandos disponiveis
$ git help -a $ git help -a
# Ajuda específica de comando - manual do usuário # Usar o *help* para um comando especifico
# git help <command_here> # git help <comando_aqui>
$ git help add $ git help add
$ git help commit $ git help commit
$ git help init $ git help init
@ -135,85 +143,89 @@ $ git help init
### status ### status
Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de Apresenta as diferenças entre o arquivo *index* (a versão corrente
copiar/repo) e a HEAD commit corrente. do repositório) e o *commit* da *HEAD* atual.
```bash ```bash
# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças # Apresenta o *branch*, arquivos não monitorados, alterações e outras
# difereças
$ git status $ git status
# Para saber outras "tid bits" sobre git status # Para aprender mais detalhes sobre git *status*
$ git help status $ git help status
``` ```
### add ### add
Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não Adiciona arquivos ao repositório corrente. Se os arquivos novos não forem
der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão adicionados através de `git add` ao repositório, então eles não serão
incluídos em commits! incluidos nos commits!
```bash ```bash
# Adicionar um arquivo no seu diretório de trabalho atual # adiciona um arquivo no diretório do projeto atual
$ git add HelloWorld.java $ git add HelloWorld.java
# Adicionar um arquivo em um diretório aninhado # adiciona um arquivo num sub-diretório
$ git add /path/to/file/HelloWorld.c $ git add /path/to/file/HelloWorld.c
# Suporte a expressões regulares! # permite usar expressões regulares!
$ git add ./*.java $ git add ./*.java
``` ```
### branch ### branch
Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando. Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
comando.
```bash ```bash
# Lista ramos e controles remotos existentes # listar *branches* existentes e remotos
$ git branch -a $ git branch -a
# Criar um novo ramo # criar um novo *branch*
$ git branch myNewBranch $ git branch myNewBranch
# Apagar um ramo # apagar um *branch*
$ git branch -d myBranch $ git branch -d myBranch
# Renomear um ramo # alterar o nome de um *branch*
# git branch -m <oldname> <newname> # git branch -m <oldname> <newname>
$ git branch -m myBranchName myNewBranchName $ git branch -m myBranchName myNewBranchName
# Editar a descrição de um ramo # editar a descrição de um *branch*
$ git branch myBranchName --edit-description $ git branch myBranchName --edit-description
``` ```
### checkout ### checkout
Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
índice, ou árvore especificada. à versão do index ou do *branch* especificado.
```bash ```bash
# Finalizar um repo - padrão de ramo mestre # Checkout de um repositório - por padrão para o branch master
$ git checkout $ git checkout
# Checa um ramo especificado # Checkout de um branch especifico
$ git checkout branchName $ git checkout branchName
# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>" # Cria um novo branch e faz checkout para ele.
# Equivalente a: "git branch <name>; git checkout <name>"
$ git checkout -b newBranch $ git checkout -b newBranch
``` ```
### clone ### clone
Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona Clona ou copia um repositório existente para um novo diretório. Também
filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre adiciona *branches* de monitoramento remoto para cada *branch* no repositório
a um ramo remoto. clonado o que permite enviar alterações para um *branch* remoto.
```bash ```bash
# Clone learnxinyminutes-docs # Clona learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git $ git clone https://github.com/adambard/learnxinyminutes-docs.git
``` ```
### commit ### commit
Armazena o conteúdo atual do índice em um novo "commit". Este commit contém Guarda o conteudo atual do index num novo *commit*. Este *commit* contém
as alterações feitas e uma mensagem criada pelo utilizador. as alterações feitas e a mensagem criada pelo usuário.
```bash ```bash
# commit com uma mensagem # commit com uma mensagem
@ -222,170 +234,170 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
### diff ### diff
Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits. Apresenta as diferenças entre um arquivo no repositório do projeto, *index*
e *commits*
```bash ```bash
# Mostrar diferença entre o seu diretório de trabalho e o índice. # Apresenta a diferença entre o diretório atual e o index
$ git diff $ git diff
# Mostrar diferenças entre o índice e o commit mais recente. # Apresenta a diferença entre o index e os commits mais recentes
$ git diff --cached $ git diff --cached
# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente. # Apresenta a diferença entre o diretório atual e o commit mais recente
$ git diff HEAD $ git diff HEAD
``` ```
### grep ### grep
Permite procurar rapidamente um repositório. Permite procurar facilmente num repositório
Configurações opcionais: Configurações opcionais:
```bash ```bash
# Obrigado ao Travis Jeffery por isto # Define a apresentação de números de linha nos resultados do grep
# Configure os números de linha a serem mostrados nos resultados de busca grep
$ git config --global grep.lineNumber true $ git config --global grep.lineNumber true
# Fazer resultados de pesquisa mais legível, incluindo agrupamento # Agrupa os resultados da pesquisa para facilitar a leitura
$ git config --global alias.g "grep --break --heading --line-number" $ git config --global alias.g "grep --break --heading --line-number"
``` ```
```bash ```bash
# Procure por "variableName" em todos os arquivos java # Pesquisa por "variableName" em todos os arquivos java
$ git grep 'variableName' -- '*.java' $ git grep 'variableName' -- '*.java'
# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover" # Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove"
$ git grep -e 'arrayListName' --and \( -e add -e remove \) $ git grep -e 'arrayListName' --and \( -e add -e remove \)
``` ```
Google é seu amigo; para mais exemplos O Google é seu amigo; para mais exemplos:
[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) [Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
### log ### log
Mostrar commits para o repositório. Apresenta commits do repositório.
```bash ```bash
# Mostrar todos os commits # Apresenta todos os commits
$ git log $ git log
# Mostrar um número X de commits # Apresenta X commits
$ git log -n 10 $ git log -n 10
# Mostrar somente commits mesclados # Apresenta apenas commits de merge
$ git log --merges $ git log --merges
``` ```
### merge ### merge
"Merge" em mudanças de commits externos no branch atual. "Merge" junta as alterações de commits externos com o *branch* atual.
```bash ```bash
# Mesclar o ramo especificado para o atual. # Junta o branch especificado com o atual
$ git merge branchName $ git merge branchName
# Gera sempre uma mesclagem commit ao mesclar # Para gerar sempre um commit ao juntar os branches
$ git merge --no-ff branchName $ git merge --no-ff branchName
``` ```
### mv ### mv
Renomear ou mover um arquivo Alterar o nome ou mover um arquivo.
```bash ```bash
# Renomear um arquivo # Alterar o nome de um arquivo
$ git mv HelloWorld.c HelloNewWorld.c $ git mv HelloWorld.c HelloNewWorld.c
# Mover um arquivo # Mover um arquivo
$ git mv HelloWorld.c ./new/path/HelloWorld.c $ git mv HelloWorld.c ./new/path/HelloWorld.c
# Força renomear ou mover # Forçar a alteração de nome ou mudança local
# "ExistingFile" já existe no diretório, será substituído # "existingFile" já existe no directório, será sobrescrito.
$ git mv -f myFile existingFile $ git mv -f myFile existingFile
``` ```
### pull ### pull
Puxa de um repositório e se funde com outro ramo. Puxa alterações de um repositório e as junta com outro branch
```bash ```bash
# Atualize seu repo local, através da fusão de novas mudanças # Atualiza o repositório local, juntando as novas alterações
# A partir da "origem" remoto e ramo "master (mestre)". # do repositório remoto 'origin' e branch 'master'
# git pull <remote> <branch> # git pull <remote> <branch>
# git pull => implícito por padrão => git pull origin master # git pull => aplica a predefinição => git pull origin master
$ git pull origin master $ git pull origin master
# Mesclar em mudanças de ramo remoto e rebase # Juntar alterações do branch remote e fazer rebase commits do branch
# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>" # no repositório local, como: "git pull <remote> <branch>, git rebase <branch>"
$ git pull origin master --rebase $ git pull origin master --rebase
``` ```
### push ### push
Empurre e mesclar as alterações de uma ramificação para uma remota e ramo. Enviar e juntar alterações de um branch para o seu branch correspondente
num repositório remoto.
```bash ```bash
# Pressione e mesclar as alterações de um repo local para um # Envia e junta as alterações de um repositório local
# Chamado remoto "origem" e ramo de "mestre". # para um remoto denominado "origin" no branch "master".
# git push <remote> <branch> # git push <remote> <branch>
# git push => implícito por padrão => git push origin master # git push => aplica a predefinição => git push origin master
$ git push origin master $ git push origin master
# Para ligar atual filial local com uma filial remota, bandeira add-u:
$ git push -u origin master
# Agora, a qualquer hora que você quer empurrar a partir desse mesmo ramo local, uso de atalho:
$ git push
``` ```
### rebase (CAUTELA) ### rebase (cautela!)
Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo. Pega em todas as alterações que foram registadas num branch e volta a
* Não rebase commits que você tenha empurrado a um repo público *. aplicá-las em outro branch.
*Não deve ser feito rebase de commits que foram enviados para um repositório
público*
```bash ```bash
# Rebase experimentBranch para mestre # Faz Rebase de experimentBranch para master
# git rebase <basebranch> <topicbranch> # git rebase <basebranch> <topicbranch>
$ git rebase master experimentBranch $ git rebase master experimentBranch
``` ```
[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing) [Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing)
### reset (CAUTELA) ### reset (cuidado!)
Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge), Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também *pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também
perigoso se não saber o que se está fazendo. perigoso quando não há certeza do que se está fazendo.
```bash ```bash
# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado) # Restabelece a camada intermediária de registo para o último
# commit (o directório fica sem alterações)
$ git reset $ git reset
# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado # Restabelece a camada intermediária de registo para o último commit, e
# sobrescreve o projeto atual
$ git reset --hard $ git reset --hard
# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado) # Move a head do branch atual para o commit especificado, sem alterar o projeto.
# Todas as alterações ainda existem no diretório. # todas as alterações ainda existem no projeto
$ git reset 31f2bb1 $ git reset 31f2bb1
# Move a ponta ramo atual para trás, para o commit especificado # Inverte a head do branch atual para o commit especificado
# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits # fazendo com que este esteja em sintonia com o diretório do projeto
# Após o commit especificado). # Remove alterações não registadas e todos os commits após o commit especificado
$ git reset --hard 31f2bb1 $ git reset --hard 31f2bb1
``` ```
### rm ### rm
O oposto do git add, git rm remove arquivos da atual árvore de trabalho. O oposto de git add, git rm remove arquivos do branch atual.
```bash ```bash
# remove HelloWorld.c # remove HelloWorld.c
$ git rm HelloWorld.c $ git rm HelloWorld.c
# Remove um arquivo de um diretório aninhado # Remove um arquivo de um sub-directório
$ git rm /pather/to/the/file/HelloWorld.c $ git rm /pather/to/the/file/HelloWorld.c
``` ```
# # Mais informações ## Informação complementar (EN)
* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
@ -398,5 +410,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/) * [GitGuys](http://www.gitguys.com/)
* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html)

13
pt-pt/git-pt.html.markdown
View File

@ -74,8 +74,7 @@ maior controlo sobre o que é registado no repositório git.
### *Commit* ### *Commit*
Um *commit** de git é um registo de um cojunto de alterações ou manipulações Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos ficheiros do projecto.
no nos ficheiros do projecto.
Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações
serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
para outros repositórios ou não! para outros repositórios ou não!
@ -83,7 +82,7 @@ para outros repositórios ou não!
### *Branch* ### *Branch*
Um *branch* é essencialmente uma referência que aponta para o último *commit* Um *branch* é essencialmente uma referência que aponta para o último *commit*
efetuado. à medida que são feitos novos commits, esta referência é atualizada efetuado. À medida que são feitos novos commits, esta referência é atualizada
automaticamente e passa a apontar para o commit mais recente. automaticamente e passa a apontar para o commit mais recente.
### *HEAD* e *head* (componentes do directório .git) ### *HEAD* e *head* (componentes do directório .git)
@ -115,7 +114,7 @@ Permite configurar as definições, sejam as definições do repositório, siste
ou configurações globais. ou configurações globais.
```bash ```bash
# Imprime & Define Algumas Variáveis de Configuração Básicas (Global) # Imprime e define algumas variáveis de configuração básicas (global)
$ git config --global user.email $ git config --global user.email
$ git config --global user.name $ git config --global user.name
@ -123,7 +122,7 @@ $ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name" $ git config --global user.name "My Name"
``` ```
[Aprenda Mais Sobre git config. (EN)](http://git-scm.com/docs/git-config) [Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
### help ### help
@ -166,7 +165,7 @@ adicionados através de `git add` ao repositório, então eles não serão
incluidos nos commits! incluidos nos commits!
```bash ```bash
# adiciona um ficheiro no directório do project atual # adiciona um ficheiro no directório do projecto atual
$ git add HelloWorld.java $ git add HelloWorld.java
# adiciona um ficheiro num sub-directório # adiciona um ficheiro num sub-directório
@ -371,7 +370,7 @@ Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
perigoso se não há certeza quanto ao que se está a fazer. perigoso se não há certeza quanto ao que se está a fazer.
```bash ```bash
# Restabelece a camada intermediária dr registo para o último # Restabelece a camada intermediária de registo para o último
# commit (o directório fica sem alterações) # commit (o directório fica sem alterações)
$ git reset $ git reset

2
python.html.markdown
View File

@ -14,7 +14,7 @@ executable pseudocode.
Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service] Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
Note: This article applies to Python 2.7 specifically, but should be applicable Note: This article applies to Python 2.7 specifically, but should be applicable
to Python 2.x. For Python 3.x, take a look at the Python 3 tutorial. to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
```python ```python

2
python3.html.markdown
View File

@ -13,7 +13,7 @@ executable pseudocode.
Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service] Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
Note: This article applies to Python 3 specifically. Check out the other tutorial if you want to learn the old Python 2.7 Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/python/) if you want to learn the old Python 2.7
```python ```python