adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 15:24:09 +03:00
Code Issues Projects Releases Wiki Activity

Translating GIT and JSON to pt-br. Added link to further information

Browse Source
This commit is contained in:
miguel araujo 2014-06-14 01:28:20 -03:00
parent b73a35a306
commit 7bc3a435c6
3 changed files with 456 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
git.html.markdown
View File

@ -395,3 +395,5 @@ $ 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 - the simple guide](http://rogerdudler.github.io/git-guide/index.html)

402
pt-br/git-pt.html.markdown Normal file
View File

@ -0,0 +1,402 @@
---
category: tool
tool: git
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
lang: pt-br
filename: learngit-pt.txt
---
Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte.
Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona
com esses momentos para lhe fornecer a funcionalidade para a versão e
gerenciar o seu código-fonte.
## Versionando Conceitos
### O que é controle de versão?
O controle de versão é um sistema que registra alterações em um arquivo ou conjunto
de arquivos, ao longo do tempo.
### Versionamento Centralizado VS Versionamento Distribuído
* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos.
* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único.
* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN,
sistema centralizado, com git.
[Informação Adicional](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
### Porque usar o Git?
* Possibilidade de trabalhar offline
* Colaborar com os outros é fácil!
* Ramificação é fácil
* Mesclagem é fácil
* Git é rápido
* Git é flexível.
## Arquitetura Git
### Repositório
Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o
como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do
código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas.
Um repositório git é composto do diretório git. e árvore de trabalho.
### 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.
[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
### Árvore de trabalho (componente do repositório)
Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida
como seu diretório de trabalho.
### Índice (componente do diretório .git)
O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho
a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
repositório Git.
### Comete (commit)
A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho.
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 ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como
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)
HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD.
head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
### Recursos Conceituais
* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/)
* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
## Comandos
### init
Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas,
e mais são armazenados em um diretório (pasta) com o nome ". git".
```bash
$ git init
```
### config
Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou
configurações globais.
```bash
# Impressão e definir algumas variáveis ​​de configuração básica (global)
$ git config --global user.email
$ git config --global user.name
$ git config --global user.email "MyEmail@Zoho.com"
$ git config --global user.name "My Name"
```
[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config)
### help
Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou
apenas dar-lhe um rápido lembrete de algumas semânticas.
```bash
# Rapidamente verificar os comandos disponíveis
$ git help
# Confira todos os comandos disponíveis
$ git help -a
# Ajuda específica de comando - manual do usuário
# git help <command_here>
$ git help add
$ git help commit
$ git help init
```
### status
Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de
copiar/repo) e a HEAD commit corrente.
```bash
# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças
$ git status
# Para saber outras "tid bits" sobre git status
$ git help status
```
### add
Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não
der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão
incluídos em commits!
```bash
# Adicionar um arquivo no seu diretório de trabalho atual
$ git add HelloWorld.java
# Adicionar um arquivo em um diretório aninhado
$ git add /path/to/file/HelloWorld.c
# Suporte a expressões regulares!
$ git add ./*.java
```
### branch
Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando.
```bash
# Lista ramos e controles remotos existentes
$ git branch -a
# Criar um novo ramo
$ git branch myNewBranch
# Apagar um ramo
$ git branch -d myBranch
# Renomear um ramo
# git branch -m <oldname> <newname>
$ git branch -m myBranchName myNewBranchName
# Editar a descrição de um ramo
$ git branch myBranchName --edit-description
```
### checkout
Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no
índice, ou árvore especificada.
```bash
# Finalizar um repo - padrão de ramo mestre
$ git checkout
# Checa um ramo especificado
$ git checkout branchName
# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>"
$ git checkout -b newBranch
```
### clone
Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona
filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre
a um ramo remoto.
```bash
# Clone learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
```
### commit
Armazena o conteúdo atual do índice em um novo "commit". Este commit contém
as alterações feitas e uma mensagem criada pelo utilizador.
```bash
# commit com uma mensagem
$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
```
### diff
Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits.
```bash
# Mostrar diferença entre o seu diretório de trabalho e o índice.
$ git diff
# Mostrar diferenças entre o índice e o commit mais recente.
$ git diff --cached
# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente.
$ git diff HEAD
```
### grep
Permite procurar rapidamente um repositório.
Configurações opcionais:
```bash
# Obrigado ao Travis Jeffery por isto
# Configure os números de linha a serem mostrados nos resultados de busca grep
$ git config --global grep.lineNumber true
# Fazer resultados de pesquisa mais legível, incluindo agrupamento
$ git config --global alias.g "grep --break --heading --line-number"
```
```bash
# Procure por "variableName" em todos os arquivos java
$ git grep 'variableName' -- '*.java'
# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
Google é seu amigo; para mais exemplos
[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
### log
Mostrar commits para o repositório.
```bash
# Mostrar todos os commits
$ git log
# Mostrar um número X de commits
$ git log -n 10
# Mostrar somente commits mesclados
$ git log --merges
```
### merge
"Merge" em mudanças de commits externos no branch atual.
```bash
# Mesclar o ramo especificado para o atual.
$ git merge branchName
# Gera sempre uma mesclagem commit ao mesclar
$ git merge --no-ff branchName
```
### mv
Renomear ou mover um arquivo
```bash
# Renomear um arquivo
$ git mv HelloWorld.c HelloNewWorld.c
# Mover um arquivo
$ git mv HelloWorld.c ./new/path/HelloWorld.c
# Força renomear ou mover
# "ExistingFile" já existe no diretório, será substituído
$ git mv -f myFile existingFile
```
### pull
Puxa de um repositório e se funde com outro ramo.
```bash
# Atualize seu repo local, através da fusão de novas mudanças
# A partir da "origem" remoto e ramo "master (mestre)".
# git pull <remote> <branch>
# git pull => implícito por padrão => git pull origin master
$ git pull origin master
# Mesclar em mudanças de ramo remoto e rebase
# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>"
$ git pull origin master --rebase
```
### push
Empurre e mesclar as alterações de uma ramificação para uma remota e ramo.
```bash
# Pressione e mesclar as alterações de um repo local para um
# Chamado remoto "origem" e ramo de "mestre".
# git push <remote> <branch>
# git push => implícito por padrão => 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)
Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo.
* Não rebase commits que você tenha empurrado a um repo público *.
```bash
# Rebase experimentBranch para mestre
# git rebase <basebranch> <topicbranch>
$ git rebase master experimentBranch
```
[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing)
### reset (CAUTELA)
Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge),
puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também
perigoso se não saber o que se está fazendo.
```bash
# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado)
$ git reset
# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado
$ git reset --hard
# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado)
# Todas as alterações ainda existem no diretório.
$ git reset 31f2bb1
# Move a ponta ramo atual para trás, para o commit especificado
# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits
# Após o commit especificado).
$ git reset --hard 31f2bb1
```
### rm
O oposto do git add, git rm remove arquivos da atual árvore de trabalho.
```bash
# remove HelloWorld.c
$ git rm HelloWorld.c
# Remove um arquivo de um diretório aninhado
$ git rm /pather/to/the/file/HelloWorld.c
```
# # Mais informações
* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
* [git-scm - Video Tutorials](http://git-scm.com/videos)
* [git-scm - Documentation](http://git-scm.com/docs)
* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html)

52
pt-br/json-pt.html.markdown Normal file
View File

@ -0,0 +1,52 @@
---
language: json
contributors:
- ["Anna Harren", "https://github.com/iirelu"]
translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
lang: pt-br
filename: learnjson-pt.json
---
Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o
"Learn X in Y minutes" mais simples existente.
JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores
aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto,
tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
```json
{
"números": 0,
"strings": "Olá, mundo. Todo o padrão UNICODE é permitido, junto com \"escapando\".",
"possui booleano?": true,
"nada": null,
"número grande": 1.2e+100,
"objetos": {
"comentário": "A maior parte da sua estrutura virá de objetos.",
"array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5],
"outro objeto": {
"ccomentário": "Estas coisas podem ser aninhadas, muito úteis."
}
},
"tolice": [
{
"fonte de potássio": ["bananas"]
},
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, "neo"],
[0, 0, 0, 1]
]
],
"que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.".
}
```