1.1. Install GIT in a GNU/Linux Debian based OS system:
sudo apt-get install git1.2. Setup GIT user
git config --global user.name "nombre_usuario"
git config --global user.email "email_id"1.3. Check current GIT setup:
git config -lmkdir my_project
cd my_project
git init .3.1. Use a web browser and go to remote GIT platform (Github, Gitlab, other...), then create a repository for the project with the same name that you current local repository.
3.2. In your system, go to your local repository:
cd Repositorio3.3. Select all repository files to be added to your next GIT commit (stage) (you can add specific files or directories using their names instead of the "."):
git add .3.4. Check the current selected files to be added to the next commit:
git status3.5. Create a commit of the selected files and add a commit title (message) to it:
git commit -m "Added first project files"3.6. Set the remote repository address:
git remote add origin https://github.com/User/my_project.git3.6. Send the local GIT repository (current branch named as "main") commits to the remote repository:
git push origin main4.1. Download and get (clone) a remote repository to your system:
git clone https://github.com/User/my_project.git4.2. Enter to the local repository and make all the needed changes in files.
4.3. Add all modified files and create a commit for them:
git add --all .
git commit -m "Added first version files"4.4. Send (push) the local GIT repository (current branch named as "main") commits to the remote repository:
git push origin main5.1 List all branch in a repository:
git branch -a5.2. Create a new branch named "new-branch":
git branch new-branch5.3. Go to (checkout) to the new branch:
git checkout new-branch5.4. Make all the needed changes in files.
5.5. Add all modfied files and create a commit for them:
git add --all .
git commit -m "Added more changes"5.6. Send (push) the local GIT repository new branch commits to the remote repository:
git push origin new-branch6.1. Nos posicionamos en la rama principal:
git checkout master
6.2. Fusionamos la Rama "rama" con la rama principal:
git merge rama
6.3. Subimos al repositorio remoto los cambios producidos por la fusión:
git push
6.4. (opcional) Borrar la Rama del repositorio local (ya que se ha fusionado con la rama principal):
git branch -d rama
6.5. (opcional) Borrar la Rama del repositorio remoto (ya que se ha fusionado con la rama principal):
git push origin --delete test
7.1. Accedemos a Github mediante un navegador web y creamos un Fork del repositorio remoto que nos interese.
7.2. Clonamos en local el repositorio remoto:
git clone https://github.com/Nombre_proyecto/Proyecto.git
7.3. Accedemos al directorio generado y realizamos los cambios que se requieran en el nuevo Fork.
7.4. Añadimos los cambios al índice de subida y especificamos los detalles:
git add .
git commit -m "Cambios realizados"
7.5. Subimos los cambios realizados:
git push origin master
8.1. Hacemos una Bifurcación (Fork) del repositorio original en el cual queremos contribuir.
8.2. Clonamos en local el repositorio, y accedemos a el:
git clone https://github.com/Nombre_proyecto/Proyecto.git
cd Proyecto
8.3. Creamos una rama (Branch) con un nombre relacionado con la característica que se va a añadir/modificar:
git checkout -b caracteristica-nueva
8.4. Realizar los cambios correspondientes que se requieran en el proyecto.
8.5. Registrar los cambios con un nuevo Commit:
git commit -m "Añadida nueva caracteristica X"
8.6. Subir el nuevo commit de dicha rama al repositorio remoto:
git push origin caracteristica-nueva
8.7A. Hacer un Pull-Request desde nuestro repositorio de Github (Compare & pull request) y añadir en el un comentario para el autor original del proyecto.
8.7B. Hacer un Pull-Request con Git, desde nuestro repositorio local:
git pull-request
8.8. Esperar a que el autor del proyecto acepte el pull-request y lo añada a su proyecto original.
9.1. Consultar el estado actual del repositorio (si hay cambios en algún archivo que requieran de un nuevo commit):
git status
9.2. Consultar los cambios actuales, antes de añadirlos al índice de subida y hacer el commit de ellos:
git diff
9.3. Consultar los cambios actuales, antes de hacer el commit de ellos, pero despues de añadirlos al índice de subida (git add):
git diff HEAD
9.4. Consultar las ramas que hay en un repositorio y en cual nos encontramos posicionados actualmente:
git branch
9.5. Consultar el historial de commits de la rama actual en la que nos encontramos:
git log
9.6. Consultar el historial de commits realizados por el autor "J-Rios", desde el día 20-08-2017 en adelante (notar que se debe de especifica 1 día antes de la fecha inicial, en este caso el 19):
git log --author=J-Rios --since="2017-08-19"
9.7. Comparar cambios entre dos commits concretos:
git diff COMMIT_OLD COMMIT_NEW
9.8. Comparar cambios en un archivo entre dos ramas distintas:
git diff RAMA1 RAMA2 -- archivo.c
9.9. Consultar las diferencias pero exclusivamente de los archivos modificados:
git diff --diff-filter=M
10.1. Descartar los cambios realizados en un archivo que aún no haya sido añadido al índice de cambios ("stageado"):
git checkout <archivo>
10.2. Revertir los cambios de un archivo concreto a un commit especifico:
git checkout <commit_hash> -- <file>
10.3. Revertir el proyecto a un commit anterior, manteniendo el registro histórico. Se generará un nuevo commit y se mantendrá en el registro todos los commits anteriores:
git revert <commit>
10.4. Revertir el proyecto a un commit anterior, eliminando del registro histórico los commits posteriores al que se vaya a restaurar. Se restaurará la versión del proyecto en el punto temporal correspondiente al commit del registro histórico (Atención, hay que tener en cuenta que este comando es muy peligroso, ya que puede hacernos perder trabajo realizado de forma irrecuperable, pues se eliminan commits del registro):
git reset --hard <commit>
11.1. Crear un nuevo repositorio remoto en la plataforma a la que se quiere hacer la migración (Github).
11.2A. Configurar en el repositorio local la dirección del repositorio remoto al que debe apuntar, y subir el repositorio:
git remote set-url origin https://github.com/J-Rios/new-project
git push
11.2B. O configurar en el repositorio local un "mirror" al nuevo repositorio remoto al que se quiere hacer la migración, y subir el repositorio:
git remote add github https://github.com/J-Rios/new-project
git push --mirror github
- Crear un TAG/Release del commit actual en el que se encuentre el proyecto:
git tag -a v1.0 -m "First stable version."
- Consultar la lista de TAGS disponibles en un repositorio (i.e. las versiones estables):
git tag -l
- Eliminar un TAG/Release, del repositorio en local y en remoto:
git tag -d tagName
git push --delete origin tagName
- Crear un Tag de un commit anteriormente realizado y aádirlo al repositorio remoto:
git checkout <COMMIT_HASH>
git tag tagName
git push origin --tags
- Clonar una Rama (Branch) específica de un repositorio:
git clone -b nombreRama --depth 1 https://github.com/Nombre_proyecto/Proyecto.git
- Establecer permisos de ejecución a scripts (si no se hace esto, aunque el archivo tenga el permiso, este se pierde al subirse al repositorio remoto):
git update-index --chmod=+x ruta/del/script.sh
- Añadir un repositorio remoto como un submodulo del repositorio actual:
git submodule add https://github.com/Nombre_proyecto/ProyectoAIncluir.git
- Clonar un repositorio remoto con todos sus submodulos de forma recursiva:
git clone --recurse-submodules https://github.com/Nombre_proyecto/Proyecto.git
- Eliminar un submodulo existente en el repositiorio:
git submodule deinit -f path/to/submodule
rm -rf .git/modules/path/to/submodule
git rm -f path/to/submodule
- Añadir al Commit anterior (que acabamos de hacer), algún cambio que se nos haya pasado por añadir:
git commit -m 'Commit inicial'
git add archivo_olvidado
git commit --amend
- Eliminar los cambios realizados en los archivos que no han sido aún añadidos a la lista de subida (git add):
git checkout -- .
- Eliminar el último índice de subida (comando add) antes de haber hecho el commit:
git reset
- Revertir el último commit realizado (pero manteniéndolo en el registro histórico de commits. Se crea un nuevo commit):
git revert HEAD
- Revertir completamente un proyecto localizado en un un repositorio remoto (por ejemplo, Github) a un commit anterior, eliminando del registro histórico los commits posteriores al que se vaya a restaurar [Atención, a parte de ser peligroso, esto solo debe ser utilizado en un proyecto en el que no haya colaboradores, pues al eliminar parte del historial, habrá colaboradores que se queden con la versión anterior del proyecto y esto pueda ocasionar conflictos graves]:
git reset --hard <commit>
git push origin HEAD --force
- Invertir un archivo concreto a la versión que tenía en un commit anterior concreto
git checkout <COMMIT> -- <ARCHIVO>
- Consultar la configuración del repositorio remoto al que apunta el repositiorio local:
git remote -v
- Cambiar la URL del repositorio remoto al que apunta un repositorio local:
git remote set-url <remote-name(i.e. origin)> <remote-url>