Skip to content

Latest commit

 

History

History
613 lines (474 loc) · 13.4 KB

git-cheat-sheet-es.md

File metadata and controls

613 lines (474 loc) · 13.4 KB
Raw

Git Cheat Sheet Spanish Awesome

Índice

Configuración

Mostrar la cofiguración actual:
$ git config --list
Mostrar la configuración local:
$ git config --local --list
Mostrar la configuración global:
$ git config --global --list
Mostrar la configuración del sistema:
$ git config --system --list
Establecer un nombre que es identificable de crédito cuando se revise el historial de versiones:
$ git config --global user.name “[nombre apellido]”
Establecer una dirección de email que será asociada con cada marca histórica:
$ git config --global user.email “[email-válido]”
Establecer coloreado automático de la línea de comandos de Git para una fácil revisión:
$ git config --global color.ui auto
Establecer el editor global para commits:
$ git config --global core.editor vi

Archivos de Configuración

Archivo de configuración específico del repositorio [--local]:
<repo>/.git/config
Archivo de configuración específico del usuario [--global]:
~/.gitconfig
Archivo de configuración del sistema [--system]:
/etc/gitconfig

Crear

Clonar un repositorio existente:

Existen dos maneras:

Vía SSH

$ git clone ssh://[email protected]/repo.git

Vía HTTP

$ git clone http://dominio.com/usuario/repo.git
Crea un nuevo repositorio local:
$ git init

Cambios Locales

Cambios en el directorio de trabajo:
$ git status
Cambios en archivos rastreados:
$ git diff
Agregar todos los cambios actuales al siguiente commit:
$ git add
Agregar algunos cambios de <archivo> para el siguiente commit:
$ git add -p <archivo>
Realizar un commit de todos los cambios locales en los archivos rastreados:
$ git commit -a
Realizar un commit de los cambios previamente almacenados en el área de pruebas (stage area):
$ git commit
Realizar un commit con un mensaje:
$ git commit -m 'aquí el mensaje'
Realizar un commit saltándose el área de pruebas y agregando un mensaje:
$ git commit -am 'aquí el mensaje'
Realizar un commit a alguna fecha anterior:
git commit --date="`date --date='n day ago'`" -am "Mensaje del commit"
Cambiar último commit:

¡No modificar commits ya publicados!

$ git commit -a --amend
Cambiar fecha del último commit:
GIT_COMMITTER_DATE="date" git commit --amend
Cambiar fecha del autor del último commit:
git commit --amend --date="date"
Mover cambios no confirmados (uncommitted changes) de la rama actual a otra rama:
git stash
git checkout branch2
git stash pop
Restaurar cambios del área de pruebas (stage area) a la rama actual:
git stash apply
Eliminar la última serie de cambios del área de pruebas (stage area):
git stash drop

Buscar

Un texto en todos los archivos del directorio:
$ git grep "Hola"
Un texto en cualquier versión:
$ git grep "Hola" v2.5

Historial de Commits

Mostrar todos los commits, empezando por los más recientes (se mostrará el hash, información sobre el autor, fecha y título del commit):
$ git log
Mostrar todos los commits (sólo se mostrará el hash y el mensaje del commit):
$ git log --oneline
Mostrar todos los commits de un usuario específico:
$ git log --author="usuario"
Mostrar los cambios a través del tiempo de un archivo específico:
$ git log -p <archivo>
Mostrar commmits que están presentes sólamente en remote/branch al lado derecho:
$ git log --oneline <origin/master>..<remote/master> --left-right
Quién cambió, qué y cuándo en <archivo>:
$ git blame <archivo>
Mostrar reference log:
$ git reflog show
Borrar reference log:
$ git reflog delete

Ramas & Etiquetas

Listar todas las ramas locales:
$ git branch
Listar todas las ramas remotas:
$ git branch -r
Cambiar rama HEAD:
$ git checkout <rama>
Crear nueva rama y cambiar a esta:
$ git checkout -b <rama>
Crear nueva rama basada en la rama HEAD actual:
$ git branch <nueva-rama>
Crear nueva rama de seguimiento basada en una rama remota:
$ git branch --track <nueva-rama> <rama-remota>
Eliminar una rama local:
$ git branch -d <rama>
Forzar eliminación de una rama local:

¡Perderás los cambios sin fusionar!

$ git branch -D <branch>
Marcar el commit actual con una etiqueta:
$ git tag <tag-name>
Marcar el commit actual con una etiqueta que incluye un mensaje:
$ git tag -a <etiqueta>

Actualizar & Publicar

Listar todos los remotos configurados actuales:
$ git remote -v
Mostrar información sobre un remoto:
$ git remote show <remoto>
Agregar un nuevo repositorio, nombrado <remoto>:
$ git remote add <remoto> <url>
Descargar todos los cambios de <remoto>, pero no integrarlos al HEAD:
$ git fetch <remoto>
Descargar cambios y fusionarlos/integrarlos directamente al HEAD:
$ git remote pull <remote> <url>
Obtener todos los cambios del HEAD al repositorio local:
$ git pull origin master
Obtener todos los cambios del HEAD al repositorio local sin fusionar:
git pull --rebase <remote> <branch>
Publicar cambios locales en un remoto:
$ git push remote <remoto> <rama>
Eliminar una rama en el remoto:
$ git push <remoto> :<rama> (desde Git v1.5.0) ó $ git push <remoto> --delete <rama> (desde Git v1.7.0)
Publicar tus etiquetas:
$ git push --tags

Fusionar y Rebasar

Fusionar en tu HEAD actual:
$ git merge <rama>
Rabasar tu actual HEAD sobre <rama>:

¡No rebasar commits ya publicados!

$ git rebase <rama>
Aborta un rebase:
$ git rebase --abort
Continuar un rebase después de resolver conflictos:
$ git rebase --continue
Usar tu herramienta de fusión configurada para resolver conflictos:
$ git mergetool
Usar tu editor para manualmente resolver conflictos y (después de resueltos) marcar el archivo como resuelto:
$ git add <archivo-resuelto>

$ git rm <archivo-resuelto>
Aplastando commits (squashing):
$ git rebase -i <commit-just-before-first>

Ahora reemplazando esto,

pick <commit_id>
pick <commit_id2>
pick <commit_id3>

con esto,

pick <commit_id>
squash <commit_id2>
squash <commit_id3>

Deshacer

Descartar todos los cambios locales en tu directorio de trabajo:
$ git reset --hard HEAD
Sacar todos los archivos del área de pruebas (es decir, deshacer el último git add):
$ git reset HEAD
Descartar cambios locales de un archivo específico:
$ git checkout HEAD <archivo>
Revertir un commit (produciendo un nuevo commit con los cambios contrarios):
$ git revert <commit>
Reestablecer tu puntero HEAD a un commit anterior y descartar todos los cambios desde entonces:
$ git reset --hard <commit>
Reestablecer tu putero HEAD al estado actual de una rama remota.
$ git reset --hard <remote/branch> es decir, upstream/master, origin/my-feature
Reestablecer tu puntero HEAD a un commit anterior y preservar todos los cambios en el área de pruebas (stage area):
$ git reset <commit>
Reestablecer tu puntero HEAD a un commit anterior y preservar los cambios locales sin confirmar (uncommitted changes):
$ git reset --keep <commit>
Remover los archivos que fueron accidentalmente agregados al commit antes de ser añadidos al .gitignore:
$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"

Git-Flow

Índice

Configuración

Necesitas tener Git instalado como prerequisito. Git flow trabaja en OSX, Linux y Windows.
OSX Homebrew:
$ brew install git-flow
OSX Macports:
$ port install git-flow
Linux (basado en Debian):
$ apt-get install git-flow
Windows (Cygwin):
Necesitas wget y util-linux para instalar git-flow.
$ wget -q -O - --no-check-certificate https://github.com/nvie/gitflow/raw/develop/contrib/gitflow-installer.sh | bash

Iniciando

Git flow necesita ser inicializado con el fin de personalizar la configuración de tu proyecto. Empieza usando git-flow inicializándolo dentro de un repositorio git existente:
Inicilizar:
Tendrás que responder un par de preguntas acerca de las convenciones de nombramiento de tus ramas. Es recomendable usar los valores por defecto.
git flow init

Features (características)

Desarrolla nuevos features para próximos lanzamientos. Típicamente sólo existen en los repositorios de desarrolladores.
Iniciar un nuevo feature:
Esta acción crea una nueva rama (feature branch) basada en la rama de desarrollo (develop branch) y cambia a esta.
git flow feature start MIFEATURE
Terminar un feature:
Finalizar el desarrollo de un feature. Esta accion realiza lo siguiente:
1) Fusiona MIFEATURE con la rama de desarrollo (develop branch).
2) Elimina la rama del feature (feature branch).
3) Cambia nuevamente a la rama de desarrollo (develop branch).
git flow feature finish MIFEATURE
Publicar un feature:
¿Estás desarrollando un feature colaborativamente? Publica un feature en el servidor remoto, así puede ser usado por otros usuarios.
git flow feature publish MIFEATURE
Obteniendo un feature publicado:
Obtener un feature publicado por otro usuario.
git flow feature pull origin MIFEATURE
Rastrear un origin feature:
Puedes rastrear un feature en origin usando:
git flow feature track MIFEATURE

Hacer un lanzamiento

Apoya la preparación de un nuevo lanzamiento a producción. Permite la corrección de pequeños bugs y la preparación de metadatos para un lanzamiento.
Empezar un lanzamiento:
Para empezar un lanzamiento, usa el comando "release" de git flow. Este crea una rama de lanzamiento (release branch) de la rama de desarrollo (develop branch). Opcionalmente puedes sustituir el hash sha-1 de un commit [BASE] para empezar el lanzamiento desde este. El commit debe estar en la rama de desarrollo (develop branch).
git flow release start RELEASE [BASE]
Es aconsejable publicar la rama de lanzamiento (release branch) después de crearla para permitir publicar commits de otros desarrolladores. Hazlo de manera similar a publicar un feature con el comando:
git flow release publish RELEASE
(Puedes rastrear un lanzamiento remoto con el comando: git flow release track RELEASE)
Terminando un lanzamiento:
Terminando un lanzamiento es uno de los grandes pasos en la ramificación de git. Realiza varias acciones:
1) Fusiona la rama de lanzamiento (release branch) con la rama master.
2) Etiqueta la publicación con su nombre.
3) Vuelve a fusionar la rama de lanzamiento (release branch) en la rama de desarrollo (develop branch).
4) Elimina la rama de lanzamiento (release branch).
git flow release finish RELEASE
No olvides de publicar tus etiquetas con git push --tags

Hotfixes (revisiones)

Los hotfixes surgen de la necesidad de actuar inmediatamente ante un estado indeseado en una versión de producción en vivo. Puede ser desramificada de la correspondiente etiqueta en la rama master que marca la versión de producción.
Emepezar un hotfix en git flow:
Como los otros comandos de git flow, un hotfix es inicializado con:
$ git flow hotfix start VERSION [BASENAME]
El argumento versión marca el nombre de publicación del nuevo hotfix. Opcionalmente puedes especificar un nombre base desde cual empezar.
Terminar un hotfix:
Al finalizar un hotfix este se fusiona nuevamente con la rama de desarrollo y la rama master. Adicionalmente la fusión master es etiquetada con la versión del hotfix.
git flow hotfix finish VERSION

Comandos

Git

Esquema de git flow

Git