https://www.freecodecamp.org/espanol/news/10-comandos-de-git-que-todo-desarrollador-deberia-saber/
Git es importante si programas a diario (especialmente si trabajas en equipo) y se usa extensamente en la industria de sw.
Dominar git requiere tiempo. Pero -solo- algunos comandos son los más frecuentes (algunos a diario varias veces).
Podriamos (para github) usar git con un cliente mas moderno, como gh pero vamos a usar el comando git clasico, dandole soporte con ssh: un buen recetario es este.
Siguen comandos de Git rutinarios -normales en devel workflow- -más usados-
Se puede hacer de muchos modos, pero vamos a usar este:
- hacemos login en github
- Hacemos un fork de [este repo] (https://github.com/rsancho64/git.n.github.101) y ya tenemos nuestra copia del repo (Es otro repo: homonimo, pero de otro usuario)
- En local, sin ssh como prerequisito (solo git) ya podemos hacer un acceso al repo. Sea por ejemplo https://github.com/USUARIO/git.n.github.101. Entonces:
mkdir folder
cd folder
git init
git remote add origin https://github.com/USUARIO/git.n.github.101
git fetch
git checkout main
ls # README.md en localCambiamos la linea 1 de este fichero para personalizarla un poco con nuestro nombre
-- # Git 101 rsancho Edicion ++ # Git 101 USUARIO edicion.
En la instalacion de debian 11 ya tengo openssh-client (no hace falta -server); y tengo comandos:
$ apropos ssh
rcp (1) - OpenSSH secure file copy
rlogin (1) - OpenSSH remote login client
rsh (1) - OpenSSH remote login client
scp (1) - OpenSSH secure file copy
sftp (1) - OpenSSH secure file transfer
slogin (1) - OpenSSH remote login client
ssh (1) - OpenSSH remote login client
ssh-add (1) - adds private key identities to the OpenSSH authenticat...
ssh-agent (1) - OpenSSH authentication agent
ssh-argv0 (1) - replaces the old ssh command-name as hostname handling
ssh-copy-id (1) - use locally available keys to authorise logins on a re...
ssh-keygen (1) - OpenSSH authentication key utility
ssh-keyscan (1) - gather SSH public keys from servers
ssh-keysign (8) - OpenSSH helper for host-based authentication
ssh-pkcs11-helper (8) - OpenSSH helper for PKCS#11 support
ssh-sk-helper (8) - OpenSSH helper for FIDO authenticator support
ssh_config (5) - OpenSSH client configuration file
XtIsShell (3) - obtain and verify a widget's classreceta: connecting-to-github-with-ssh
receta: generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent:
ssh-keygen -t ed25519 -C "rsancho@iesrioarba.es"
# Generating public/private ed25519 key pair.
# Enter file in which to save the key (~/.ssh/id_ed25519):
# Enter passphrase (empty for no passphrase): *****************
# Enter same passphrase again: *****************
# Your identification has been saved in ~/.ssh/id_ed25519
# Your public key has been saved in ~/.ssh/id_ed25519.pub
# The key fingerprint is:
# SHA256:5CPr7vDfdBd+6O1sVWsUFWOjaECPuUQxav2RxGBw9kA rsancho@iesrioarba.esls -l ~/.ssh
# total 12K
# -rw------- 1 ray ray 464 sep 13 17:30 id_ed25519
# -rw-r--r-- 1 ray ray 103 sep 13 17:30 id_ed25519.pub
# -rw-r--r-- 1 ray ray 884 sep 13 18:38 known_hostsde aqui
eval "$(ssh-agent -s)" # start ssh-agent in background
# Agent pid 26914
ssh-add ~/.ssh/id_ed25519
# Enter passphrase for ~/.ssh/id_ed25519: *****************
# Identity added: ~/.ssh/id_ed25519 (USUARIO@iesrioarba.es)git config --global user.name "name-in-github" # "USUARIO"
git config --global user.email "email-in-github" # "USUARIO@iesrioarba.es"
git config --global color.ui truesudo apt install wl-clipboard # the WayLand copypaster 4 deb11
wl-copy < ~/.ssh//id_ed25519.pub # copy to clipboardnow ++ & label ssh public key -onlogin- at account settings https://github.com/settings/keys](https://github.com/settings/keys)
$ ssh -T git@github.com
Your password: *****************
Hi rsancho64! You've successfully authenticated, but GitHub does not provide shell access.de [aqui] https://kbroman.org/github_tutorial/pages/routine.html
clone descarga el código fuente existente desde un repositorio remoto (como Github, por ejemplo). Realiza una copia idéntica de la última versión de un proyecto en un repositorio, y la guarda en tu ordenador.
Hay un par de formas de descargar el código fuente, pero clonar con https es cómodo: desde Github, clic en botón verde (clonar o descargar), copiar la URL de la caja y pegarla en CLI:
git clone <https://url-repo.git>Esto hará una copia del proyecto en local y se podrá trabajar ahi.
Las ramas (branch) son esenciales en git. Usandolas varios desarrolladores pueden trabajar en paralelo en el mismo proyecto (simultáneamente). Una buena explicacion.
NOTA: un branch no es lo mismo que un fork:
-
Un branch -rama o ruta(de un repo))- es un objeto ligero, que puede ser temporal y puede terminar desapareciendo, o no. Fisicamente es una anotación solo de los camibios relativos a su rama padre.
-
Un fork (clon separado) es una copia completa (profunda) de un repo (tomada en un momento dado, lo es de su ultima versión). Fisicamente es una copia completa de su repo padre. A partir de su creación, evolucionan independientemente.
cd <folder> # en la raiz del repo, donde hay una subcarpeta .git
git branch <nombre-de-la-rama> # nueva rama (solo en local)Ejemplo: creamos la rama fooBranch (en local)
$ git branch fooBranch
$ git branch
fooBranch
* mainPara enviar la nueva rama al repo remoto, hará falta un push, pero antes usamos branch sin argumentos (listar ramas) y status
$ git status
En la rama main
Tu rama está actualizada con 'origin/main'.
Cambios no rastreados para el commit:
(usa "git add <archivo>..." para actualizar lo que será confirmado)
(usa "git restore <archivo>..." para descartar los cambios en el directorio de trabajo)
modificado: README.md
Archivos sin seguimiento:
(usa "git add <archivo>..." para incluirlo a lo que se será confirmado)
git101.md
sin cambios agregados al commit (usa "git add" y/o "git commit -a")
$ git add README.md
$ git status
En la rama main
Tu rama está actualizada con 'origin/main'.
Cambios a ser confirmados:
(usa "git restore --staged <archivo>..." para sacar del área de stage)
modificado: README.md
Archivos sin seguimiento:
(usa "git add <archivo>..." para incluirlo a lo que se será confirmado)
git101.md
$ git add git101.md
```bash
```bash
git push <nombre-remoto> <nombre-rama>OOOPS desde August 13, deprecated passw authentication...
$ git push
Username for 'https://github.com': rsancho64
Password for 'https://rsancho64@github.com':
remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.
fatal: Autenticación falló para 'https://github.com/rsancho64/rsancho64.git/',,: hace falta operar en https:
git push https://<GITHUB_ACCESS_TOKEN>@github.com/<GITHUB_USERNAME>/<REPOSITORY_NAME>.git
$ git push https://ghp_************************************@github.com/rsancho64/rsancho64.git
Enumerando objetos: 5, listo.
Contando objetos: 100% (5/5), listo.
Compresión delta usando hasta 4 hilos
Comprimiendo objetos: 100% (2/2), listo.
Escribiendo objetos: 100% (3/3), 549 bytes | 549.00 KiB/s, listo.
Total 3 (delta 0), reusado 0 (delta 0), pack-reusado 0
To https://github.com/rsancho64/rsancho64.git
39342cd..3392dcd main -> mainVisualización de ramas:
git branch
git branch --list
Borrar una rama:
git branch -d <nombre-de-la-rama>
Este es también uno de los comandos más utilizados en Git. Para trabajar en una rama, primero tienes que cambiarte a ella. Usaremos git checkout principalmente para cambiarte de una rama a otra. También lo podemos usar para chequear archivos y commits.
git checkout <nombre-de-la-rama>
Hay algunos pasos que debes seguir para cambiarte exitosamente entre ramas:
- Los cambios en tu rama actual tienen que ser confirmados o almacenados en el guardado rápido (stash) antes de que cambies de rama.
- La rama a la que te quieras cambiar debe existir en local.
Hay también un comando de acceso directo que te permite crear y cambiarte a esa rama al mismo tiempo:
git checkout -b <nombre-de-tu-rama>
Este comando crea una nueva rama en local (-b viene de rama (branch)) y te cambia a la rama que acabas de crear.
El comando de git status nos da toda la información necesaria sobre la rama actual.
git status
Podemos encontrar información como:
- Si la rama actual está actualizada
- Si hay algo para confirmar, enviar o recibir (pull).
- Si hay archivos en preparación (staged), sin preparación(unstaged) o que no están recibiendo seguimiento (untracked)
- Si hay archivos creados, modificados o eliminados
Cuando creamos, modificamos o eliminamos un archivo, estos cambios suceden en local y no se incluirán en el siguiente commit (a menos que cambiemos la configuración).
Necesitamos usar el comando git add para incluir los cambios del o de los archivos en tu siguiente commit.
Añadir un único archivo:
git add <archivo>
Añadir todo de una vez:
git add -A
Si revisas la captura de pantalla que he dejado en la sección 4, verás que hay nombres de archivos en rojo - esto significa que los archivos sin preparación. Estos archivos no serán incluidos en tus commits hasta que no los añadas.
Para añadirlos, necesitas usar el git add:
****Importante:** El comando git add no cambia el repositorio y los cambios que no han sido guardados hasta que no utilicemos el comando de confirmación git commit.**
Este sea quizás el comando más utilizado de Git. Una vez que se llega a cierto punto en el desarrollo, queremos guardar nuestros cambios (quizás después de una tarea o asunto específico).
Git commit es como establecer un punto de control en el proceso de desarrollo al cual puedes volver más tarde si es necesario.
También necesitamos escribir un mensaje corto para explicar qué hemos desarrollado o modificado en el código fuente.
git commit -m "mensaje de confirmación"
****Importante: Git commit** guarda tus cambios únicamente en local.**
Después de haber confirmado tus cambios, el siguiente paso que quieres dar es enviar tus cambios al servidor remoto. Git push envía tus commits al repositorio remoto.
git push <nombre-remoto> <nombre-de-tu-rama>
De todas formas, si tu rama ha sido creada recientemente, puede que tengas que cargar y subir tu rama con el siguiente comando:
git push --set-upstream <nombre-remoto> <nombre-de-tu-rama>
or
git push -u origin <nombre-de-tu-rama>
****Importante: Git push** solamente carga los cambios que han sido confirmados.**
El comando git pull se utiliza para recibir actualizaciones del repositorio remoto. Este comando es una combinación del git fetch y del git merge lo cual significa que cundo usemos el git pull recogeremos actualizaciones del repositorio remoto (git fetch) e inmediatamente aplicamos estos últimos cambios en local (git merge).
git pull <nombre-remoto>
Esta operación puede generar conflictos que tengamos que resolver manualmente.
A veces, necesitaremos deshacer los cambios que hemos hecho. Hay varias maneras para deshacer nuestros cambios en local y/o en remoto (dependiendo de lo que necesitemos), pero necesitaremos utilizar cuidadosamente estos comandos para evitar borrados no deseados.
Una manera segura para deshacer nuestras commits es utilizar git revert. Para ver nuestro historial de commits, primero necesitamos utilizar el git log -- oneline:
Entonces, solo necesitamos especificar el código de comprobación que encontrarás junto al commit que queremos deshacer:
git revert 3321844
Después de esto, verás una pantalla como la de abajo -tan solo presiona shift + q para salir:
El comando git revert deshará el commit que le hemos indicado, pero creará un nuevo commit deshaciendo la anterior:
La ventaja de utilizar git revert es que no afecta al commit histórico. Esto significa que puedes seguir viendo todos los commits en tu histórico, incluso los revertidos.
Otra medida de seguridad es que todo sucede en local a no ser que los enviemos al repositorio remoto. Por esto es que git revert es más seguro de usar y es la manera preferida para deshacer los commits.
Cuando ya hayas completado el desarrollo de tu proyecto en tu rama y
todo funcione correctamente, el último paso es fusionar la rama con su
rama padre (dev o master). Esto se hace con el comando git merge.
Git merge básicamente integra las características de tu rama con todos los commits realizados a las ramas dev (o master). Es importante que recuerdes que tienes que estar en esa rama específica que quieres fusionar con tu rama de características.
Por ejemplo, cuando quieres fusionar tu rama de características en la rama dev:
Primero, debes cambiarte a la rama dev:
git checkout dev
Antes de fusionar, debes actualizar tu rama dev local:
git fetch
Por último, puedes fusionar tu rama de características en la rama dev:
git merge <nombre-de-la-rama>
Pista:** Asegúrate de que tu rama dev tiene la última versión antes de fusionar otras ramas, si no, te enfrentarás a conflictos u otros problemas no deseados.**
Aquí están mis 10 comandos de git más usados cuando me enfrento a la programación en mi día a día. Hay muchas más cosas que aprender sobre Git y las explicaré más adelante en oros artículos.
Si quieres aprender más sobre el desarrollo web, ¡puedes seguirme en Youtube!
¡Gracias por leerme!
Traducido del artículo de Cem Eygi - 10 Git Commands Every Developer Should Know
$ cd /git.n.github.101
$ git init # produce este warning:
ayuda: Using 'master' as the name for the initial branch. This default branch name
ayuda: is subject to change. To configure the initial branch name to use in all
ayuda: of your new repositories, which will suppress this warning, call:
ayuda:
ayuda: git config --global init.defaultBranch <name>
ayuda:
ayuda: Names commonly chosen instead of 'master' are 'main', 'trunk' and
ayuda: 'development'. The just-created branch can be renamed via this command:
ayuda:
ayuda: git branch -m <name>
Inicializado repositorio Git vacío en ~/git.n.github.101/.git/
$ rm -Rf .git # empezamos de nuevo
$ git config --global init.defaultBranch main
$ git init
Inicializado repositorio Git vacío en ~/git.n.github.101/.git/Creamos el repo vacio en github (rsancho64/git.n.github.101 public)
$ git config receive.denyCurrentBranch ignore
$ ls
-rw-r--r-- 1 ray ray 20K sep 13 23:36 README.md
$ git status
En la rama main
No hay commits todavía
Archivos sin seguimiento:
(usa "git add <archivo>..." para incluirlo a lo que se será confirmado)
<p style="color:red">README.md</p>
no hay nada agregado al commit pero hay archivos sin seguimiento presentes (usa "git add" para hacerles seguimiento)
$ git add README.md
$ git commit
[main (commit-raíz) 5996d07] git n github 101 tutorial
1 file changed, 521 insertions(+)
create mode 100644 README.md
$ git branch -M main
$ git status
...
<p style="color:green">README.md</p>
...
$ git remote add origin https://github.com/rsancho64/git.n.github.101.git
$ git push origin main
Username for 'https://github.com': rsancho64
Password for 'https://rsancho64@github.com':
remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.
fatal: Autenticación falló para 'https://github.com/rsancho64/git.n.github.101.git/'
$ git push https://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@github.com/rsancho64/git.n.github.101.git
Enumerando objetos: 3, listo.
Contando objetos: 100% (3/3), listo.
Compresión delta usando hasta 4 hilos
Comprimiendo objetos: 100% (2/2), listo.
Escribiendo objetos: 100% (3/3), 7.48 KiB | 1.87 MiB/s, listo.
Total 3 (delta 0), reusado 0 (delta 0), pack-reusado 0
To https://github.com/rsancho64/git.n.github.101.git
* [new branch] main -> main