Apuntes Git

Git es un software de control de versiones diseñado por Linus Torvalds, pensando en la eficiencia y la confiabilidad del mantenimiento de versiones de aplicaciones cuando éstas tienen un gran número de archivos de código fuente. 

Wikipedia

¿Qué es un control de versiones, y por qué debería importarte? Un control de versiones es un sistema que registra los cambios realizados en un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante. Aunque en los ejemplos de este libro usarás archivos de código fuente como aquellos cuya versión está siendo controlada, en realidad puedes hacer lo mismo con casi cualquier tipo de archivo que encuentres en una computadora.

Hemos elaborado unos apuntes sobre Git que iremos ampliando según vayamos anotando nuevas funcionalidades. Como comprobaréis son unos apuntes básicos y esquemáticos elaborados a partir del libro Pro Git y solamente es una documentación/guía rápida para usar git.

Para aprender a instalar Git en tu equipo visita el siguiente enlace: https://git-scm.com/book/es/v2/Inicio---Sobre-el-Control-de-Versiones-Instalaci%C3%B3n-de-Git

GIT: https://git-scm.com/

FUENTE: https://git-scm.com/book/es/v2

Última revisión, mayo 2018


All content is licensed under the Creative Commons Attribution Non Commercial Share Alike 3.0 license


Configurando git

  • git config --global user.name "John Doe"

  • git config --global user.email johndoe@example.com

  • git config --global core.editor emacs

  • git config --global merge.tool vimdiff

  • git config --list

  • git config --global credential.helper cache (caché de credenciales)

Iniciando git

  • git init

  • git add *.c

  • git add README

  • git commit –m 'versión inicial del proyecto’



Clonar repositorio

  • git clone git://github.com/schacon/grit.git

Comprobar el estado de los archivos

  • git status

  • git status -s short

  • Añadiendo archivos:

  • git add benchmarks.rb


Ignorando archivos, crear archivo .gitignore

  • cat .gitignore

# ignora los archivos terminados en .a

*.a

# pero no lib.a, aun cuando había ignorado los archivos terminados en .a en la línea anterior

!lib.a

# ignora únicamente el archivo TODO de la raiz, no subdir/TODO

/TODO

# ignora todos los archivos del directorio build/

build/

# ignora doc/notes.txt, pero este no doc/server/arch.txt

doc/*.txt

# ignora todos los archivos .txt el directorio doc/

doc/**/*.txt


https://github.com/github/gitignore 

Ver los cambios preparados y sin preparar:

git diff

git diff --cached para ver que has preparado hasta ahora


Confirmando cambios:

git commit ejecuta el editor para añadir el mensaje

git commit -m "Story 182: Fix benchmarks for speed"

git commit -a -m 'added new benchmarks' salta el área de preparación


Guardado rápido:

git stash


Eliminar archivos

rm grit.gemspec “Changes not staged for commit” (esto es, sin preparar)

git rm grit.gemspec Prepara la eliminación del archivo, desaparece del próximo commit

git rm --cached readme.txt Mantener el archivo pero ignorar el seguimiento


Eliminar tipos de archivos

git rm log/\*.log

git rm \*~


Renombrar archivos

git mv file_from file_to 


Histórico de confirmaciones

git log

git log –p -2 Muestra las diferencias introducidas y las dos últimas entradas del histórico

git log --stat Muestra algunas estadísticas

git log --since=2.weeks


Ramas

git log --oneline --decorate muestre a dónde apunta cada rama

git log --oneline --decorate --graph --all mostrará el historial de tus confirmaciones, indicando dónde están los apuntadores de tus ramas y como ha divergido tu historial.


Visualizador gráfico: gitk


Más sobre log: https://git-scm.com/book/es/v2/Fundamentos-de-Git-Ver-el-Historial-de-Confirmaciones

Deshacer cosas

Modificando tu última confirmación

git commit --amend

git commit -m 'initial commit'
git add forgotten_file
añadimos un fichero que falta y hacemos commit --amend
git commit --amend 


Deshacer un Archivo Preparado

  (use "git reset HEAD <file>..." to unstage)

git reset HEAD CONTRIBUTING.md


Deshacer un Archivo Modificado

use «git checkout -- <archivo>...» para descartar cambios en el directorio de trabajo

Cualquier cambio que le hayas hecho a ese archivo desaparecerá - acabas de sobreescribirlo con otro archivo. Nunca utilices este comando a menos que estés absolutamente seguro de que ya no quieres el archivo.

Remotos

git remote

git remote -v lista las url de los remotos


Añadir Repositorios Remotos

git remote add [nombre] [url] → para asociar nombre a repo remoto

git remote add remoto ssh://usuario@servidor:puerto/var/www/git/remoto.git


Traer y Combinar Remotos

git fetch [remote-name]

git fetch base1


Actualizar remoto en local

git pull origin master


Enviar a Tus Remotos

git push origin master


Inspeccionar un Remoto

git remote show [nombre-remoto]


Renombrar Remotos

git remote rename pb paul


Eliminar Remotos

git remote rm paul


Etiquetado

Listar Tus Etiquetas

git tag

git tag -l 'v1.8.5*'


Crear Etiquetas

Etiquetas ligeras: Una etiqueta ligera es muy parecido a una rama que no cambia - simplemente es un puntero a un commit específico. Para crear una etiqueta ligera, no pases las opciones -a, -s ni -m.

git tag v1.4-lw
git tag


Etiquetas Anotadas: las etiquetas anotadas se guardan en la base de datos de Git como objetos enteros.

git tag -a v1.4 -m 'my version 1.4'

git show v1.4


Etiquetado Tardío

git tag -a v1.2 9fceb02(checksum del commit o parte de él)

Compartir Etiquetas

git push origin v1.5 envía una etiqueta

git push origin --tags envía todas las etiquetas que no estén en el servidor


Alias de Git

  • git config --global alias.co checkout

  • git config --global alias.br branch

  • git config --global alias.ci commit

  • git config --global alias.st status

  • git config --global alias.unstage 'reset HEAD --'

  • git config --global alias.last 'log -1 HEAD'

  • git config --global alias.visual "!gitk"

Ramificaciones

https://git-scm.com/book/es/v2/Ramificaciones-en-Git-%C2%BFQu%C3%A9-es-una-rama%3F

Crear una Rama Nueva

git branch testing

Cambiar de Rama

git checkout testing


Saltar entre ramas cambia archivos en tu directorio de trabajo

Es importante destacar que cuando saltas a una rama en Git, los archivos de tu directorio de trabajo cambian. Si saltas a una rama antigua, tu directorio de trabajo retrocederá para verse como lo hacía la última vez que confirmaste un cambio en dicha rama. Si Git no puede hacer el cambio limpiamente, no te dejará saltar.


  • git checkout -b [rama] crea y cambia a la rama automáticamente

  • git merge [rama] incorpora los cambios a la rama master

  • git branch -d [rama] eliminar rama

  • git branch -v ver la última confirmación de cambios en cada rama

  • git branch --merged ver las ramas que han sido fusionadas en la rama activa

  • git branch --no-merged todas las ramas que contienen trabajos sin fusionar

  • git push origin serverfix →“coge mi rama local serverfix y actualiza con ella la rama serverfix del remoto”

  • git checkout -b serverfix origin/serverfix traer la rama remota a local

  • git checkout --track origin/serverfix 

  • git checkout -b sf origin/serverfix Así, tu rama local sf traerá (pull) información automáticamente desde origin/serverfix.

  • git branch -u origin/serverfix Si ya tienes una rama local y quieres asignarla a una rama remota que acabas de traerte, o quieres cambiar la rama a la que le haces seguimiento,

  • git branch -vv ver las ramas de seguimiento que tienes asignado

  • git fetch --all; git branch -vv tener los cambios por delante y por detrás actualizados

  • git push origin --delete serverfix borrar la rama serverfix del servidor

  • git rebase puedes coger todos los cambios confirmados en una rama, y reaplicarlos sobre otra.

  • git rebase --onto master server client “Activa la rama client, averigua los cambios desde el ancestro común entre las ramas client y server, y aplicalos en la rama master”

  • git rebase [rama-base] [rama-puntual]

Los Protocolos
Local Protocol  el repositorio remoto es simplemente otra carpeta en el disco

  • git clone /opt/git/project.git

  • git clone file:///opt/git/project.git

  • git remote add local_proj /opt/git/project.git


HTTP

  • cd /var/www/htdocs/
    git clone --bare /path/to/git_project gitproject.git
    cd gitproject.git
    mv hooks/post-update.sample hooks/post-update
    chmod a+x hooks/post-update

  • git clone https://example.com/gitproject.git


SSH


  • git clone ssh://user@server/project.git

  • git clone ssh://usuario@servidor/home/garber/base1.git


git clone user@server:project.git (sintaxis scp)

Configurando Git en un servidor

Crear repositorio

git clone --bare base1 base1.git


Subir repositorio al servidor

scp -r -P puerto base1.git usuario@servidor:/home/garber/base1.git


Clonar repositorio a local

git clone ssh://usuario@servidor:puerto/ruta/al/directorio/git

git init --bare --shared añade los permisos de escritura automáticamente 


Acceso SSH

Crear un solo usuario git en la máquina, preguntar a cada usuario de quién se trata para otorgarle permisos de escritura para que te envíe una llave SSH pública, y agregar esa llave al archivo ~ / .ssh / authorized_keys de tu nuevo usuario git. En ese momento, todo el mundo podrá acceder a esa máquina mediante el usuario git. Esto no afecta a los datos commit de ninguna manera - el usuario SSH con el que te conectas no puede modificar los commits que has registrado.


Generando tu clave pública SSH


Verificar si tenemos las claves:

cd ~/.ssh
ls
authorized_keys2  id_dsa       known_hosts
config            id_dsa.pub


Generar claves ssh:

ssh-keygen


Configurando el servidor

Próximamente


Identificarse dejar un comentario
Extraer palabras de un string php