git init -> Inicia el repositorio.
git add "nombre del archivo"-> Inicia para agregar el archivo correspondiente.
git commit -m "Aquí va el comentario" -> Envia el repositorio local
git status -> Muestra en que estado se encuentra un archivo
git config --list -> Muestra las configuraciones de git
git rm --cached "nombre del archivo" -> Remueve el archivo del estado de cache, es
decir lo elimina
git log "nombre del archiv" -> Muestra la historia o linea de tiempo de un archivo
git show "nombre del archivo"-> Muestra los cambio echos al archivos de la versión
inicial a la final
git diff "numero del commit realizado, por el metodo git log" -> Muestra las
diferencias entre dos versiones o commits a comparar.
Se toma el número del primer commit y se compara con cualquier otro.
git log --stat -> Muestra de manera más especifica la cantidad de bytes
modificados.
git checkout + id del commit -> Nos permite volver en el tiempo a cualquier versión
especifica de un archivo o de
todo un proyecto
git switch - -> Comando para salir del git checkout y volver a la versión en el
futuro más reciente.
Pasos para volver a una versión anterior y arrancar
---------------------------------------------------
git log
git checkout + id del commit
Ahora puede volver a editar el archivo desde una versión anterior
git add .
git commit -m "nombre de la versión"
OK
---------------------------------------------------
git clone "url" -> Si quiero traer un repositorio remoto a mi area de trabajo y a
mi repositorio local.
git push -> Envía la información al servidor remoto
git fetch -> Obtener nuevos cambios desde el servidor remoto
git merce -> Al realizar el git fetch traigo el cambio que alguien le hizo al
repositorio (archivos) y los dejo ahora
en mi repositorio local.
El git merce, lo que hace es combinar mi archivo y archivo que traje con la
actualización y me lo crea en mi directorio
de trabajo
git pull -> Es la combinación del los comandos fetch y merce, y con esto siempre
tendre una copia actualizada
de los cambios al repositorio remoto (GitHub)
git rm --cached "nombre del archivo" -> Al realizar el git add el archivo queda en
el disco duro listo para subir
al repositorio y con este comando lo ignoramos para que no se suba todavia.
git rm --force: Elimina los archivos de git y del disco duro
git reset "nombre del archivo" --hard -> volvermos pero eliminamos del todo lo
realizado
git reset --soft: Borramos todo el historial y los registros de Git pero guardamos
los cambios que tengamos en Staging,
así podemos aplicar las últimas actualizaciones a un nuevo commit.
git reset HEAD -> Nos permite sacar archivos del área de staging (git add .) y
poder incluirlo es un proximo commit o no
git branch "nombre de la rama" -> Se crea una rama a partir de una rama del último
commit seleccionado
git checkout "nombre de la rama" -> Permite cambiar entre ramas.
git branch -> Para mostrar las ramas que tengo y en cual estoy ubicado
git commit -am -> Combina el git add . con el git commit -m.
git merge "nombre del archivo" -m "nombre del commit" -> El merge es el que permite
combinar las modificaciones que se realizan en una rama paralela al
master, para en un futuro poner unir esas dos versiones.
-----------------------------------------------------
Solucionar conflicto con "merge" al tratar de modificar dos aspectos en diferentes
ramas y unirlos.
1. Modificamos master
2. Guardamos commit
3. Modificamos rama que creamos
4. Guardamos commit
5. Vamos al master
6. git merge cabecera
7. Vemos errores y los solucionamos
8. git commit -am "nombre del commit"
OK
--------------------------------------------------
Enviar archivos del repositorio local git a repositorio remoto GitHub
- git remote add origin URL -> Le dice a git que agregue el repositorio remoto
- git remote -> Muestra origin del remoto
- git remote -v -> Muestra los comando fetch or push para recibir o enviar al
repositorio
- git push origin master -> Envia los archivos del origen al master del remoto
Caso en el que ya se tiene algo en el remoto (Archivos subidos ya en github)
- git pull origin master -> Permite poder recibir los datos de la rama con los
archivos que ya estan en GitHub
y los que quiero subir al mismo.
- git pull origin master --allow-unrelated-histories -> Combina histories de los
archivos en el remoto y en local
-git push origin master -> Se envían los archivos al Repositorio Remoto (GitHub).
----------------------------------------------------
git pull origin master -> Traer los cambios que se realizaron al repositorio remoto
a mi espacio local.
----------------------------------------------------
Crear llave publica y privada
# Encender el "servidor" de llaves SSH de tu computadora:
eval $(ssh-agent -s)
# Añadir tu llave SSH a este "servidor":
ssh-add ruta-donde-guardaste-tu-llave-privada //ssh-add ~/.ssh/id_rsa
------------------------------------------------------------------
//Actualizar el repositorio con SSH
git remote set-url origin -> Cambia la url de donde se envia el remoto
git pull origin master -> Traer la información del repositorio remoto (GitHub),
siempre estar actualizado.
git push origin master enviar la información al master
------------------------------------------------
Mostrar el git log de manera forma más gráfica
git log --all --graph --decorate --oneline
------------------------------------------------
TAG -> Sirve para tener información interna de las versiones en las que va el
codigo
git tag -a v0.1 -m "Mensaje del commit" + ID del commit
git show-ref --tags -> Muestra el id del commit y el tag
git push origin --tags -> Envia los tag al repositorio
git tag -d "nombre del tag" -> Borrar un tag
git push origin :refs/tags/dormido -> Borra el tag del GitHub
--------------------------------------------------
git show-branch -> Muestra los cambios que se han realizado en los branch
gitk -> Muestra los cambios en el tiempo de manera gráfica.
------------------------------------------
Enviar otra rama
git pull origin master
git checkout cabecera
git push origin cabecera
-------------------------------------------------
git clone "SSH del proyecto" -> Sirve para clonar otros repositorios en mi espacio
de trabajo w
-------------------------------------------------
Colarborar con un proyecto y hacer fork (clonar un proyecto público)
watch -> Ver el proyecto y seguirlo.
fork -> Clona el repositorio y lo crea en mis repositorios.
Luego lo tengo que traer a mi espacio local para trabajarlo con git.
git clone SSH o URL -> Clonar el repositorio.
git pull origin master o main -> Traemos lo más nuevo.
git commit -am "title"
git push origin master o main y listo
Luego hacemos un pull request y esperar.
Para seguir contribuyendo he ir actualizado realizo:
git remote add upstream URL o SSH -> Crea un nuevo repositorio remoto
git remote -v -> Los muestra.
git pull upstream master -> Trae los cambios más recientes.
git commit -am "Title" -> De lo que nos trajimos, lo más nuevo.
git push origin master -> Ahora enviamos esos cambios a nuestro repositorio
central.
-----------------------------------------------
Herramienta para hacer un README.MD
https://pandao.github.io/editor.md/en.html
-----------------------------------------------
Git rebase -> Sirve para al crear un rama paraleta al master y en este caso no se
realiza un merge,
sino se sobre escribe sobre la línea de tiempo del master, eliminado la otra rama y
copiando todo al master
Ojo con eso mamin
git branch "nombre de la rama"
git checkout "nombre de la rama"
- Agremos lo pertinente.
- Desde la rama que creamos.
git rebase master -> Ejecuta el comando git rebase
git checkout master
git rebase "nombre de la rama "
-----------------------------------------------
git stash -> Volver a un cambio anterior y guardar los cambios actuales en un
espacio en meroria temporar
para despues recuperarlos.
git stash list -> Se muestra la modificación del stash
git stash branch "nombre de la rama" -> Sirve para guardar ese cambio en una nueva
rama
y luego si se quiere hacer un commit
git stash drop -> Borro definitivamente esos cambios que estaban en espacio de
memoria.
------------------------------------------------
git clean -> Limpiar proyecto de archivos no deseados.
git clean --dry-run -> Muestra todos los elementos que va a borrar
git clean -f -> Borra todos los archivos que se muestran en el anterior comando.
--------------------------------------------------
Guardar Cambios hechos en master a otra rama
git stash
git stash branch "NOMBRE DE LA RAMA"
git commit -am "Nombre del commit con los cambios"
---------------------------------------------
Traer cambios espeficios de una rama a mi rama master or main
Se necesitan al menos dos commits en la rama que se le traeran los cambios
git checkout master or main
git cherry-pick "ID del commit de la rama con el comando log" -> Sirve para sacar
cambios especificos de una rama o commits especificos
de una rama y traerlos al master o main con un merge.
---------------------------------------------
Si se pasa un cambio que se tenia que hacer en un commit
git add
git commit --amend -> Sirve para pegar los cambios al commit anterior.
----------------------------------------------
Si queremos volver a una versión anterior porque todo se rompio
git reset --hard "id del log" -> Retrocede hasta el commit que le indicamos
borrando todo
lo que teniamos en la última versión
git reflog -> Nos permite ver el historia de todo lo que paso, todo.
----------------------------------------------
Comando para buscar elementos especificos de un archivos o de un proyecto
git grep "letra, palabra, etiqueta" -> Busca el elemento exacto
git grep -n "letra, palabra, etiqueta" -> Busca y muestra la línea exacta o
ubicación exacta del elemento
que se esta buscando.
git grep -c "letra, palabra, etiqueta" -> Muestra la cantidad de veces que se
repite.
Comando para buscar cuando un elemento de escrbio en un commit
git log -S "nombre de la rama"
-------------------------------------------------
Muestra la historia del equipo
git shortlog -> Muestra una historia de lo que han hechos los miembros de un
equipo.
git shortlog -sn -> Muestra los commit que han hecho cada uno en el equipo.
git shortlog -sn --all -> Muestra todos los commit incluso los borrados.
git shortlog -sn --all --no-merge -> Muestra los commit menos los merge.
git blame -c "Nombre del archivo" -> Muestra línea por línea quien hizo que cosa.
git blame "Nombre del archivo" "-L35,53 (Número de líneas para saber quien las
escribio)"
--------------------------------------------------
Para configurar comandos en git
git config --global alias."nombre que le quiere poner" "Comando"
---------------------------------------------------
git branch -r -> Muestra las ramas que existen en el remoto.
git branch -a -> Muestra todas la ramas.
preguntas
en un commit los mensajes -> Error
que es un branch o rama -> Error
cherry-pick -> Error
Instalar Gitk-> Error
