Mis aportes 😃
Introducción a Git
¿Por qué usar un sistema de control de versiones como Git?
¿Qué es Git?
Instalando Git y GitBash en Windows
Instalando Git en OSX
Instalando Git en Linux
Editores de código, archivos binarios y de texto plano
Introducción a la terminal y línea de comandos
Comandos básicos en Git
Crea un repositorio de Git y haz tu primer commit
Analizar cambios en los archivos de tu proyecto con Git
¿Qué es el staging y los repositorios? Ciclo básico de trabajo en Git
¿Qué es un Branch (rama) y cómo funciona un Merge en Git?
Volver en el tiempo en nuestro repositorio utilizando reset y checkout
Git reset vs. Git rm
Flujo de trabajo básico en Git
Flujo de trabajo básico con un repositorio remoto
Introducción a las ramas o branches de Git
Fusión de ramas con Git merge
Resolución de conflictos al hacer un merge
Trabajando con repositorios remotos en GitHub
Cambios en GitHub: de master a main
Uso de GitHub
Cómo funcionan las llaves públicas y privadas
Configura tus llaves SSH en local
Conexión a GitHub con SSH
Tags y versiones en Git y GitHub
Manejo de ramas en GitHub
Configurar múltiples colaboradores en un repositorio de GitHub
Flujos de trabajo profesionales
Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master
Flujo de trabajo profesional con Pull requests
Utilizando Pull Requests en GitHub
Creando un Fork, contribuyendo a un repositorio
Haciendo deployment a un servidor
Hazme un pull request
Ignorar archivos en el repositorio con .gitignore
Readme.md es una excelente práctica
Tu sitio web público con GitHub Pages
Multiples entornos de trabajo en Git
Git Rebase: reorganizando el trabajo realizado
Git Stash: Guardar cambios en memoria y recuperarlos después
Git Clean: limpiar tu proyecto de archivos no deseados
Git cherry-pick: traer commits viejos al head de un branch
Comandos de Git para casos de emergencia
Git Reset y Reflog: úsese en caso de emergencia
Reconstruir commits en Git con amend
Buscar en archivos y commits de Git con Grep y log
Bonus sobre Git y Github
Comandos y recursos colaborativos en Git y GitHub
Tu futuro con Git y GitHub
Un sistema de control de versiones como Git nos ayuda a guardar el historial de cambios y crecimiento de los archivos de nuestro proyecto.
En realidad, los cambios y diferencias entre las versiones de nuestros proyectos pueden tener similitudes, algunas veces los cambios pueden ser solo una palabra o una parte específica de un archivo específico. Git está optimizado para guardar todos estos cambios de forma atómica e incremental, o sea, aplicando cambios sobre los últimos cambios, estos sobre los cambios anteriores y así hasta el inicio de nuestro proyecto.
git init
.git add
. Este comando no almacena las actualizaciones de forma definitiva, únicamente las guarda en algo que conocemos como “Staging Area” (área de montaje o ensayo).git commit
. También podemos guardar un mensaje para recordar muy bien qué cambios hicimos en este commit con el argumento -m "Mensaje del commit"
.git push
.Este comando nos ayuda a eliminar archivos de Git sin eliminar su historial del sistema de versiones. Esto quiere decir que si necesitamos recuperar el archivo solo debemos “viajar en el tiempo” y recuperar el último commit antes de borrar el archivo en cuestión.
git rm no puede usarse por sí solo, así nomás. Se debe utilizar uno de los flags para indicar a Git cómo eliminar los archivos que ya no se necesitan en la última versión del proyecto:
Con git reset volvemos al pasado sin la posibilidad de volver al futuro. Borramos la historia y la debemos sobreescribir.
Al crear una nueva rama se copia el último commit en esta nueva rama. Todos los cambios hechos en esta rama no se reflejarán en la rama master hasta que hagamos un merge.
Aporte creado por: Franco Coloccini
Aportes 767
Preguntas 69
Mis aportes 😃
Espero les sea de ayuda! 😄
git init- inicializa el repositorio de git
git add . – Agrega todos los cambios en todos los archivos al área de staging
git status – Para ver el estado de la BD sí se han hecho cambios, pero no se han agregado, ahí saldrá
git show - Muestra todos los cambios históricos hechos y sus detalles (qé cambió, cuándo y quién los hizo)
git commit -m -Agrega definitivamente los cambios hechos al repositorio, se puede poner un comentario para indicar que cambió
git push -envía los cambios al repositorio remoto
git pull -Agrega los cambios del commit más nuevo al repositorio local
Este comentario está basado en el video, comentarios de éste mismo video y wikipedia.
Personalmente recomiendo leer y guardar el comentario. No se asusten, es sólo un resumen para que no tengan que hacerlo luego.
Git es un sistema de control de versiones, pensado para la eficiencia y la confiabilidad del mantenimiento de versiones en un proyecto. Su propósito es llevar un registro de los cambios en archivos de computadora y coordinar el trabajo que varias personas realizan sobre archivos compartidos.
Git permite guardar únicamente los cambios realizados en algún archivo o proyecto y nos permite saber dónde, quién o cuándo se han realizado los cambios.
Los comandos básicos en Git son los siguientes:
git init
: Permite iniciar el repositorio (lugar donde se almacenarán los cambios).
git add <nombre_archivo>
: Git comienza a “trackear”, comienza a hacerle un seguimiento archivo en cuestión.
git commit
: Envía los últimos cambios del archivo a la base de datos del sistema de control de versiones. Una buena práctica al usar este comando es añadir -m
; al hacer esto, podemos escribir un mensaje que nos permita recordar los cambios que hicimos en ese momento.
git add .
: Es un comando que nos permite agregar al repositorio todos los archivos a los cuales se le haya hecho algún cambio.
git status
: Permite ver el estado de la base de datos. Por ejemplo, podemos ver si hay algunos cambios que no se han guardado en el repositorio, y si no hay nada nos dirá que todo esta bien.
git show
: Mostrara todos los cambios que hemos hecho, esto incluye las líneas que hemos cambiado, cuando y quien hizo dicho cambios.
git log <nombre_archivo>
: Muestra todo el historial del archivo.
git push
: Permite enviar los cambios realizados a un servidor remoto.
git push origin <nombre_rama>
: Sube la rama “nombre_rama” al servidor remoto.
git fetch
: Descarga los cambios realizados en el repositorio remoto.
git merge <nombre_rama>
: Impacta en la rama en la que te encuentras parado, los cambios realizados en la rama “nombre_rama”.
git pull
: Unifica los comandos fetch y merge en un único comando.
git checkout -b <nombre_rama_nueva>
: Crea una rama a partir de la que te encuentres parado con el nombre “nombre_rama_nueva”, y luego salta sobre la rama nueva, por lo que quedas parado en esta última.
git checkout -t origin/<nombre_rama>
: Si existe una rama remota de nombre “nombre_rama”, al ejecutar este comando se crea una rama local con el nombre “nombre_rama” para hacer un seguimiento de la rama remota con el mismo nombre.
git branch
: Lista todas las ramas locales.
git branch -a
:Lista todas las ramas locales y remotas.
git branch -d <nombre_rama>
: Elimina la rama local con el nombre “nombre_rama”.
git push origin <nombre_rama>
: Commitea los cambios desde el branch local origin al branch “nombre_rama”.
git remote prune origin
: Actualiza tu repositorio remoto en caso que algún otro desarrollador haya eliminado alguna rama remota.
git reset --hard HEAD
: Elimina los cambios realizados que aún no se hayan hecho commit.
git revert <hash_commit>
: Revierte el commit realizado, identificado por el “hash_commit”.
Cuando se habla de “quedar parado”, se refiere a donde estás posicionado, dónde o en qué ruta estás realizando los comandos en la terminal.
Algunos comandos y sus funciones:
git init : Empieza en tu carpeta un repositorio para guardar los cambios.
git add “nombre del archivo” : Agrega ese archivo o cambio al "Staging Area"
git commit -m “Versión 1” : Agrega finalmente el cambio realizado y le agrega un mensaje con -m
git add . : Agrega todos los archivos a ese Staging Area
git commit -m “Cambios a v1” : Aplica los cambios realizados.
git status : Muestra el estado de tu respositorio
git show : Muestra el historico de los cambios hechos
git log “nombre del archivo” : Muestra el historial de ese archivo
git push : Envia hacia un repositorio remoto
git pull : Trae de un repositorio remoto a tu local
Apuntes 📚
No conocía el comando git show Aquí se ve la importancia de estar realizando los cursos que actualizan para aprender nuevas cosas.
Qué bien explica Freddy. Tomar un curso de el es muy diferente que cualquier otro curso con otro profesor.
No es que los demas sean malos, nada de eso, pero Freddy realmente hace la diferencia y es el único que me haría preferir Platzi por sobre Googlear / leer / YouTube
a fredy no se le puede colocar 1.25x, este men ya lo tiene por defecto xd !
Les dejo una guía de la clase 😄 https://drive.google.com/file/d/1ADhTgqUuDQRXriN3HXkOpHhOctDuzB2J/view?usp=sharing
Algo genial de Freddy es que recomienda siempre las buenas practicas
Comandos básicos de git
git init -> empieza un repositorio
git add biografia.txt -> agrega un archivo en especifico
git commit –m “versión 1” -> guarda los cambios y se le agrega un nombre
git add . -> agrega todos los archivos
git commit –m “versión 2” -> guarda los cambios y se le agrega un nombre
git status -> muestra el estado del repositorio
git show -> Muestra los cambios históricos hechos
git log -> Mustra la historia de los archivos
git push -> envía a un servidor remoto
git pull -> trae los archivos del servidor remoto
$ git init */arranca repositorio/*
$ git add biografia.txt */arranca archivo/*
$ git commit -m "versión 1" */envia los ultimos cambios a la base de datos del sistema de control de versiones/*
$ git add . */agrega todos los archivos que hayan cambiado en la carpeta actual/*
$ git commit -m "Cambios a v1" */cambios hechos y grabados/*
$ git status */visualizar status de bases de datos/*
$ git show */muestra todos los cambios historicos hechos/*
$ git log biografia.txt */ver historia entera de un archivo/*
$ git push */envia hacia otro repositorio remoto lo que hice/*
Mi resumen
Comandos basicos de Git
$ git init iniciar un repositorio
$ git add añadir y/o agregar un archivo
$ git commit Enviar los cambios
$ git commit - m “” Enviar un mensaje
$ git add. ** Agregar todos los archivos que hayan cambiado a la carpeta donde estoy
$ git status estado de cambios
$ git show todos os cambios historicos que se hayan hecho y quien los hizo
$ git log La historia de un archivo, muestra toda la información del archivo
$ git push Enviar los cambios de un repositorio local a uno remoto
** $ Git pull Traer un reppositorio remoto a uno local
Hola aquí les dejo mis apuntes de que es Git y por qué usarlo?
Les dejo toda le teoría y los comandos utilizados durante el curso en el siguiente link, pásense!!
$ git init: Da inicio al repositorio de Git.
$ git add biografia.txt: Agrega el archivo al repositorio.
$ git commit -m “versión 1”: Agrega los últimos cambios realizados al archivo. Es posible colocar el nombre de su versión con el fin de tener una buena higiene en el trabajo.
$ git add .: Agrega los archivos modificados a la carpeta en la que nos encontramos trabajando.
$ git commit -m “Cambios a v1”: Realizamos un nuevo commit. Renombramos los cambios para tenerlo a mano.
$ git status: Nos permite observar el estado de la base de datos.
$ git show: Nos muestra el historial de cambios.
$ git log biografia.txt: Muestra toda la historia del archivo.
$ git push: Envía el archivo a un repositorio remoto.
$ git pull: Trae el archivo desde un repositorio remoto.
¡Excelente clase para irnos adentrando en Git!
$ git init
Inicia un repositorio o base de datos que almacenará todos los cambios realizados a X archivo.
$ git add archivo.txt
Añade el archivo al repositorio y ahora éste sabe que existe.
$ git commit -m "Version 1"
Se guardan los cambios realizados en el repositorio.
$ git add .
Se guardan todos los archivos que hayan cambiado en la carpeta donde se hizo init.
$ git status
Conocer el estado de modificaciones.
$ git log archivo.txt
Historial de modificaciones.
$ git push
Para enviar el repositorio a un servidor.
Anotaciones:
Existen 3 tipos de VCS (Sistema Control de Versiones), los locales (aquellos que no estan subidos a internet o fuera de nuestro dispositivo de computo), los centralizados (no dependen de nuestro dispositivo de computo, sino del hospedaje donde se encuentra almacenado el Core de nuestro proyecto) y los distribuidos (los mas preferidos por la comunidad, ya que cada dispositivo de computo interviene como repositorio y si alguno deja de funcionar, puede ser reemplazado por otro componente y no afectara al proyecto en general).
git help
Muestra una lista con los comandos más utilizados en GIT.
git init
Crear localmente un repositorio con GIT y así utilizar todo el funcionamiento que GIT ofrece.
git add + path
Agrega al repositorio los archivos que indiquemos.
git add -A
Agrega al repositorio TODOS los archivos y carpetas que estén en nuestro proyecto, los cuales GIT no está siguiendo.
git commit -m “mensaje” + archivos
Hace commit a los archivos que indiquemos, de esta manera quedan guardados nuestras modificaciones.
git commit -am "mensaje"
Hace commit de los archivos que han sido modificados y GIT los está siguiendo.
git checkout -b NombreDeBranch
Crea un nuevo branch y automaticamente GIT se cambia al branch creado, clonando el branch desde donde ejecutamos el comando.
git branch
Nos muestra una lista de los branches que existen en nuestro repositorio.
git checkout NombreDeBranch
Sirve para moverse entre branches, en este caso vamos al branch que indicamos en el comando.
git merge NombreDeBranch
Hace un merge entre dos branches, en este caso la dirección del merge sería entre el branch que indiquemos en el comando, y el branch donde estémos ubicados.
git status
Nos indica el estado del repositorio, por ejemplo cuales están modificados, cuales no están siendo seguidos por GIT, entre otras características.
git clone https://www.example.com/name.git NombreProyecto
Clona un proyecto de git remoto en la carpeta NombreProyecto.
git push origin NombreDeBranch
Luego de que hicimos un git commit, si estamos trabajando remotamente, este comando va a subir los archivos al repositorio remoto, específicamente al branch que indiquemos.
git pull origin NombreDeBranch
Hace una actualización en nuestro branch local, desde un branch remoto que indicamos en el comando
git init -> “inicia” nuestro repositorio, es decir arranca es sistema de control de versiones en la carpeta ubicada.
git add -> “agrega” el archivo especificado o los cambios del mismo.
git add . -> “agrega” todos los archivos modificados
git commit -> “compromete”/guarda los cambios realizados de manera local.
- m -> para agregar un mensaje a la modificación y mantener un proyecto limpio y organizado | higiénico.
git status -> ver estatus
git show -> muestra todos los cambios históricos realizados
git log -> ver historial de un archivo específico.
git push -> “Empujar” tu/tus archivos/cambios del archivo al mundo cruel/al infinito y más allá.
git pull -> “traer” | jalar archivos del mundo cruel a tu repositorio local.
$ git init: Da inicio al repositorio de Git.
$ git add biografia.txt: Agrega el archivo al repositorio.
$ git commit -m “versión 1”: Agrega los últimos cambios realizados al archivo. Es posible colocar el nombre de su versión con el fin de tener una buena higiene en el trabajo.
$ git add .: Agrega los archivos modificados a la carpeta en la que nos encontramos trabajando.
$ git commit -m “Cambios a v1”: Realizamos un nuevo commit. Renombramos los cambios para tenerlo a mano.
$ git status: Nos permite observar el estado de la base de datos.
$ git show: Nos muestra el historial de cambios.
$ git log biografia.txt: Muestra toda la historia del archivo.
$ git push: Envía el archivo a un repositorio remoto.
$ git pull: Trae el archivo desde un repositorio remoto.
¡Excelente clase para irnos adentrando en Git!
Comandos de vistos en esta clase!
git init: Indicar a git que queremos utilizar su sistema de control de versiones.
git add / git add . : para que el repositorio sepa la existencia de un archivo y sus ultimos cambios (Staging Area).
git commit -m “comentario”: almacenar los cambios.
git status : revisar el estatus si tengo algun cambio no agregado me lo mostrara.
git show : Mostrara todos los cambios históricos hechos.
git log archivo.txt :
git push: Enviar nuestros commits a un servidor remoto.
$ git init //inicia el repositorio en carpeta
$ git add biografia.txt //Agrega el archivo al repositorio
$git commit -m "version 1" // Agrega los ultimos cmabios hechos en el archivo
$ git add . //Agrega todos los archivos modificados en la carpeta donde te encuentras trabajando
$ git status //Muestra el status de la base de datos
$ git show // Muestra todos los cambios historicos hechos
$ git log biografia.txt // Muestra toda la historia de ese archivo. Que se modifico, cuando y quien
$ git push // Envia a otro respositorio remoto
$ git pull // Trae de otro repositorio
Yea! con Freddy 😊
Ya me veo haciendo el…
$ git push Jarvis_Main_IA_Mark_299.py
git init//inicia el repositorio
git add biografia.txt//arranca el archivo
git commit -m "version 1"// es el que envia los ultimos cambios
git add . // agrega todos los archivos que se encuentran en la carpeta
git commit -m "cambios a v1" nos permite agregar los cambios que hemos hecho
git status
git show//nos indica todos los cambios historicos hechos, lineas codigos, quien lo hizo
git log biografia.txt// nos permite ver la historia completa de un archivo.
git push // nos permite enviar los cambios a otro repositorio remoto.
Sistema control de versiones
Es un sistema que nos ayuda a registrar los cambios realizados sobre un archivo o conjunto de archivos de nuestro proyecto a lo largo del tiempo.
Comandos usados
git init : Crea un repositorio de manera local en la dirección donde estemos posicionados.
git add: Agrega un archivo/carpeta o sus últimos cambios al “Staging Area”
git commit -m : Almacena definitivamente los cambios que por ahora viven en el Staging Area. También podemos guardar un mensaje agregando -m "Contenido del mensaje" para recordar bien los cambios realizados en ese commit
git add . : Agrega todos los archivos que tuvieron cambios al “Staging Area”
git status : Muestra el estado de los archivos en la base de datos
git show : Muestra el historial de cambios en es repositorio
git log : Muestra el historial de cambios de un archivo
Ahora github pertenece a microsoft, de ahí es que las nuevas versiones de visual studio ofrecen en el intellisense una “estrella” con los métodos más usados. Esto lo logró microsoft analizando todos los repositorios de github.
Aquí la info por si alguein quiere saber más : Visual Studio IntelliCode
**$git init: **Crea un repositorio
**$git add archivo: **Añade a la Base de Datos el documento para realizar los cambios
$git commit -m “mensaje”: Envía los cambios del archivo a la BD del Sistema de Control de Versiones
$git add: Agrega todos los archivos que hayan cambiado en la carpeta actual
**$ git status: ** Ver el estado del repositorio
**$ git show: ** Muestra los cambios históricos hechos, incluidos las líneas de código
**$ git log archivo: ** Muestra los cambios históricos de un archivo
**$ git push: ** Subir el repositorio a un servidor remoto
Git -> Es un sistema de control de versiones creado por Linus Torvalds.
Para ver más adelante en detalle, los siguientes:
Mi primer aporte de apuntes en una clase. Si algo no se entiende o es incorrecto por favor dejenme una respuesta con la corrección para tenerlo en cuenta y actualizar mis apuntes.
git init… empecemos este curso!!!
No sabia lo de git log sobre un archivo especifico…que chevere
Los sistemas de control de versiones (SCV) guardan los cambios realizados a un archivo y dejan claro donde y cuando ocurrieron, quién los hizo y muchas más cosas.
A continuación algunos comandos de Git en la terminal:
$git init (arranca el repositorio)
$git add _archivo _(arranca el archivo)
$git commit (envía los últimos cambios a la base de datos)
$git add. (arranca todos los archivos que hayan cambiado en la carpeta actual)
$git status (Muestra el estado de los archivos)
$git show (muestra todos los cambios históricos realizados)
$git log _archivo_ (muestra los cambios realizados al archivo)
$git push (envía a un repositorio remoto)
Vengo del futuro y para los que apenas van a empezar por favor antes de iniciar todo donde freddy hace con la palabra master en los comandos cambiarlo por main
Freddy: seguramente le ponen V2 a tus archivos cuando haces cambios
yo:
Les comparto mis apuntes 😃
Hola!
Les comparto esta imagen para reforzar conceptos
Espero les sirva 😃
Compañeros les comparto este resumen de la clase, espero que les ayude
Comandos básicos de Git:
git init: Se usar para iniciar un repositorio de git en el directorio deseado.
git add nombreArchivo.extension: Se usa para agregar los archivos deseados al stage.
**git add . **: Se usa para agregar todos los archivos que tengan cambios pendientes o por agregar al stage.
git commit -m “descripcion del o los cambios”: Se usa para agregar todos los cambios en el stage a la base de datos del repositorio.
git status: Se usa para saber el estatus actual de la base de datos, para saber si existen cambios.
git show: Muestra todos los cambios históricos hechos en el repositorio.
git log nombreArchivo.extension: Mostrará la historia entera de un archivo.
git push: Se usa cuando se van a enviar los archivos a un repositorio remoto
git init : inicializa el repositorio git.
git add nombreArchivo.extencion : Agrega un archivo puntual.
git add . : Agrega todos los archivos con cambios.
git commit -m “Hice cambios” : Comentar los cambios que hiciste.
git status: estado actual del repositorio
git log nombreArchivo.extencion :historia completa de un archivo puntual.
git show: Te muestra todos los cambios y tambien quien lo hizo.
vamos con git por 5 vez
Freddy enseña de afán.Que velocidad tan aterradora.Hay que hacer un curso que sea :“como seguir un curso en Platzi de Freddy y no morir en el intento”
Imprimi estas dos hojas y las tengo en frente de mi escritorio por si alguien las ocupa tambien.
Salud y saludos raza!
**Mis aportes para ustedes **
Apuntes del curso 👉🏻 acá
Apuntes de la clase 👇🏻
Comparto los apuntes que he estado realizando durante todo el curso, espero que más de alguna persona le sirva de apoyo.
Este repositorio lo he ido trabajando con lo que he ido aprendiendo en el curso.
https://github.com/Z4N4T3/Git-y-GitHub/blob/master/Git-GitHub.md
git init
→ iniciar en la carpeta un repositorio
git add biografía.txt
→ con eso el sitema sabe de la existencia del archivo
git commit-m “version 1”
para enviar los útimos cambios del archivo a la base de dato de gestión de versiones, pora generar un mensaje -m “mensaje”
git add
. para agregar todos los archivos cambiados al repositorio
git commit -m
“cambios a V1”
git status
, para ver el estatus de la base de datos.
git show
mostrará todos los cambios hechos y quien los hizo
git log biografia.txt
para ver toda la historia del archivo
git push
para enviar nuestros archivos a un servidor remoto
git pull
para traer archivos de un servidor remoto
soy nuevo estudie ing en informatica pero muy pobre la educacion. aprovechare la cuarentena para estudiar muy a fondo ing… ya que hoy en dia no la ejerzo, soy importador con varias marcas de productos creados en venezuela 😃 pero hoy en cuarentena toda mi cadena de distribuicion a parado! el arte de reinventarse se dice ! quiero crear una app para mi empresa y ofrecer mis productos al mayor a mis precios bajos para todos!
- Si carpeta A contiene a carpeta B y C, y B tiene archivos que han sido modificados y desde B se hacen commits, los demás archivos modificados fuera de B, no formarán parte del commit
- Se recomienda realizar commits NO desde la carpeta raíz de todo el project, sino desde las carpetas que contienen de manera directa los archivos modificados.
$ git init
Crea un repositorio
$ git add archivo
Añade a la Base de Datos el documento para realizar los cambios
$ git commit -m “mensaje”
Envía los cambios del archivo a la BD del Sistema de Control de Versiones
**$ git add . **
Agrega todos los archivos que hayan cambiado en la carpeta actual
$ git status
Ver el estado del repositorio
$ git show
Muestra los cambios históricos hechos, incluidos las líneas de código
$ git log archivo
Muestra los cambios históricos de un archivo
$ git push
Subir el repositorio a un servidor remoto
Git es un sistema de control de versiones (VCS visual control system),
.
Registra los cambios realizados sobre un archivo o conjunto de archivos a lo largo del tiempo, por lo tanto no tendrás versiones como tarea.txt, tarea2.txt, tarea2-final.txt tarea2-final2.txt tarea2-final2-esteeselbueno.txt
, además de que envés de guardar los archivos completos sólo se guardan sólo los cambios.
.
Git es algo así como el Ctrl+Z
(deshacer) de los programadores, suponiendo que el Ctrl Z
guardara todo el historial de modificación de los archivos, ya que con git puedes moverte en la historia (algo así como una máquina del tiempo).
git init Empieza un repositorio de manera local y lo hará en la carpeta donde estamos posicionados o se le puede pasar [nombre_de_la_carpeta] y creará la carpeta con ese nombre.
Pero, ¿Ahora le decimos a Git que existe nuestro archivo?
git add [archivo] Nos agrega al archivo al Staging Area, tener en cuenta que este comando no almacena las actualizaciones de forma definitiva
Entonces ¿Cómo almaceno de manera definitiva los cambios?
Git commit -m [“mensaje”] Almacena definitivamente los cambios, tener en cuenta que es bueno ser descriptivos con el mensaje para saber lo que se hizo en ese commit y para informar al resto de personas.
¿Por qué usar un sistema de control de versiones como Git?
Usamos Git por que es un sistema de control de versiones que nos permite guardar únicamente los cambios que realicemos en algún archivo o proyecto que estemos realizando de manera propia o de manera colaborativa, ya que si no existiera Git tendríamos que guardar multiplex veces el mismo archivo, pero con algunos cambios, que en su mayoría son pequeños. Además, podemos saber dónde, quien o cuando se realizaron cambios; podemos regresar a alguna versión anterior, etc.
Los comandos básicos en Git son los siguientes:
Por qué usar un sistema control de versiones
Hoy en día usar un sistema control de versiones es muy importante ya que podemos llevar una diferente versión de nuestro proyecto sin afectar el mismo
Con esto tenemos claro:
Dónde ocurrió
Cuando ocurrió
Quién hizo los cambios
Podemos volver a las versiones anteriores
$ git init : iniciamos un repositorio
$git add + nombre de archivo : agregamos el archivo a staying area
$git commit -m “version 1”: sube nuestra versión
$git add . : Subimos todos los archivos
$git status: vemos en qué estado está nuestro proyecto
$git show : nos muestra todos los cambios históricos hechos nos muestra que ha cambiado cuando ha cambiado y quién los hizo
$git log + nombre de archivo: nos muestra los cambios hechos en ese archivo
$git push: nos permite subir nuestro proyecto a un repositorio remoto
$git pull: podemos traer el repositorio
Comando Básicos de Git
git init -> iniciailizar un repositorio
git add file.txt -> agrega el archivo al repositorio
git commit -m “comentario acerca de lo realizado” -> envia los datos o cambios a la base de datos del repositorio
git add . -> agrega todo los archivos modificados o nuevos
git commit -m “comentario” -> agregar al stage
git status -> estado de los archivos
git log file.txt -> historial de cambios realizados
git push -> enviar al repositorio
git pull -> obtener archivos del repositorio
✨ Un sistema de control de versiones nos permite mantener un histórico de todo el desarrollo del proyecto. Añade trazabilidad al desarrollo de software, ya que se puede ver qué cambios se han hecho en el código en cada versión.
Pueden hacer pruebas de git desde la web donde también aprenderán muchos comandos y les permitiran aprender mas de git.
-“Underscore”
–Ulala señor frances.
-Entonces como se dice?
–“Raya al piso” :V
Aprender Github en esta cuarentena!
Pueden descargar hojas resumen de git en:
https://www.git-tower.com/blog/git-cheat-sheet/
GIt: Es un sistema de control de versiones, la cual nos permite guardar con todo el detalles solo los cambios ocurridos en un determinado archivo.
--------------Comandos----------------------------
git init: me permite abrir (inicializar) mi repositorio local
git add: Le digo al repositorio que este archivo existe, no es añadir sino como un "poner a escuchar"
git commit: Envío los últimos cambios del archivos. Es recomendable siempre adjuntar un comentario con el comando -m "mensaje"
git status: Me permite saber como va mi base de datos, si por ejemplo me hace falta hacer commit o por el contrario todo está bien.
git show: todos los cambios históricos realizados
la misma función se puede realizar con el comando git log -nombre de archivo-
---------------Conceptos----------------------------
repositorios: lo podemos definir como una base de datos que tendrá en cuenta todos los cambios que realizamos en nuestro código
Resumen
Comandos git:
**$ git init ** empezar en tu carpeta un repositorio, que es la base de datos donde van a guardar los cambios de cualquier archivo
$ git add “nombre del archivo” con esto la base de control de cambios sabe que existe el archivo “nombre del archivo”
$ git commit - m “versión 1” envía los últimos cambios del archivo a la base de datos del sistema de control de versiones.
$ git add . guardar los cambios en el repositorio, agregas todos los archivos que hayan cambiado en la carpeta donde en ese momento estas.
$ git commit - m “cambios a la v1” indicas que le hiciste unos cambios a la versión 1, quedando esos cambios hechos y grabados.
git status puedes ver como esta el status de tu base de datos
git show te va a mostrar los cambios históricos hechos, tal como: lineas de código, lineas de textos, lineas de cualquier archivo que hayas añadido, cuando se han hecho esos cambios y quien lo realizó en el repositorio.
git log “nombre del archivo” puedes ver la historia entera del archivo
git push para llevar el archivo a un servidor remoto (repositorio en internet)
git pull para traer un archivo que se encuentra en un servidor remoto.
Estoy super animada para utlizar git en todos los proyectos que haga de hoy en adelante 😄
En esta clase está el resumen de lo que Freddy avisa que es lo más usado por los devel en el campo laboral, Creo que se va a aprender bastanteeee !
Esto de crear archivos con diferentes nombres se solía hacer en la U con muchos proyectos. A la final uno terminaba confundido con tantos archivos o carpetas.
Esta nueva intro es muchísimo más agradable, especialmente para los oídos.
segun el profesor de diseño de paginas web este es el siguiente curso a tomar
https://git-scm.com/book/es/v2 link del libro de Git de 500 paginas
Como dice Freddy es muy importante mantener "buenas practicas" que faciliten el entendimiento del código, en este caso de los cambios, ya que nosotros trabajamos con personas y debe ser una prioridad buscar el mejor entendimiento posible para mejorar el desempeño como equipo.
Llevo mas de 2 años usando Git para mis proyectos y aun hay cosas que no se, espero aprender muchas cosas nuevas aquí.
Tipos de repositorio
**Notas de Clase **
Git init : git init es un comando que se utiliza una sola vez durante la configuración inicial de un repositorio nuevo. Al ejecutar este comando, se creará un nuevo subdirectorio .Git en tu directorio de trabajo actual. También se creará una nueva rama principal.
**Git add: **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
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.
**Git status: **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
**Git log: **A veces necesitamos examinar la secuencia de commits (confirmaciones) que hemos realizado en la historia de un proyecto, para saber dónde estamos y qué estados hemos tenido a lo largo de la vida del repositorio. Esto lo conseguimos con el comando de Git “log”.
Una vez tenemos el listado en nuestro terminal podemos observar los mensajes de los commits y su identificador, pero también podríamos obtener más información de un commit en concreto, sus modificaciones en el código, o tener la referencia para moverse hacia atrás en el histórico de commits.
De un commit podemos ver diversas informaciones básicas como:
• Identificador del commit
• Autor
• Fecha de realización
• Mensaje enviado
Git push: 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.
Comandos (los espacios cuentan)
git init : Empieza un repositorio, base de datos donde se van a guardar los cambios de cualquier archivo (arranca el repositorio)
git add nombreDelArchivo.txt : con esto git sabe que existe el archivo (arranca el archivo)
git commit –m “aquí va un mensaje—versión 1” : agregarlo a la base de datos (envía los cambios a la base de datos)
git add . : agrega todos los archivos que hayan cambiado en la carpeta donde en ese momento este
git commit –m “cambios a versión 1” : agrega los cambios
git status : para ver el status de nuestra base de datos
git show : muestra todos los cambios históricos hechos
git log nombreDeArchivo.txt : ver historia entera de un archivo
git push : enviar hacia otro repositorio remoto
git pull : traer
Git: Sistema que maneja el Kernel de Linux
COMANDOS BÁSICOS EN GIT
git init - Empieza en mi carpeta un repositorio
git add biografia.txt - Tu repositorio tiene que saber que el archivo que vas a subir existe, entonces lo haces con este comando
git commit -m “versión 1” - Envía el archivo a la base de datos, para colocar el comentario escribes -m y colocas el comentario dentro de comillas
git add . - Agregas todos los archivos que hayas cambiado en la carpeta que te encuentras
git commit -m “cambios a la v1” - Ya con este otro comando estaría indicando que he realizado cambios, y coloco otro comentario
git status - Para verificar el estado de mi base de datos (Por ejemplo: si hemos un cambio y no lo hemos añadido, podremos visualizarlo desde ahí)
git show - Te muestra todos los cambios históricos hechos en el repositorio, y quién hizo esos cambios
git log biografía.txt - Para visualizar el historial completo de un archivo
git push - Permite enviar hacia otro escritorio remoto nuestro archivo
Sistema de Control de Versiones! suena potente no?
Genial! no sabia de la existencia del comando git show
Ritmo de la clase al más puro estilo Fredy. A este paso le quedan 3 videos más para acabar el curso.
El curso que empecé con Leonidas Esteban es genial, ahora uno con Freddy refuerza con énfasis en aspectos que explica de manera muy práctica para que cualquiera pueda entenderlo.
Intentare usar git para la tesis …
git log --oneline nos da el historial de una manera mas fácil de entender
Tengo años usando git (lo básico) y no conocía el comando show, maravilloso!!
Extrañaba a Freddy 😊
$ git init = Empieza en tu carpeta un repositorio (es el que arranca el repositorio).
$ git add biografia.txt = Con esto el sistema de control de versiones, ahora sabe que existe biografia.txt.
$ git commit -m “versión 1” = Es el que envía los últimos cambios del archivo a la base de datos del sistema de control de versiones para controlar los cambios que se hallan hecho.
$ git add . = Esta es otra opción para agregar archivos, cuando le agregas el punto lo que haces es que agregas todos los archivos que hallan cambiado en la carpeta donde en ese momento estás.
$ git statud = Sirve para ver el estatus de tu base de datos.
$ git show = Muestra todos los cambios históricos que hallas hecho.
$ git log biografia.txt = El comando log sirve para ver la historia entera de un archivo.
$ git push = El comando push sirve para re enviar hacia otro repositorio remoto lo que estás haciendo.
Apuntes
$ git init: Empieza un repositorio(base de datos) donde se guardan datos
$ git add (nombre del archivo): Arranca el archivo, git sabe que existe el archivo
$ git commit -m “version 1”: Envia los cambios del archivo
$ git add . : Agrega todos los archivos que hayan cambiado en la carpeta donde estas
$ git commit -m “Cambios a v1”
$ git status : Ver como está el status
$ git show : Muestra el historial de cambios
$ git lob (nombre del archivo) : Ver historia entera de un archivo
$ git push : Envia tus archivos hacia un repositorio remoto
Freddy eres el mejor explicando por favor mas cursos como este en platzi.
Uno puede creer que sabe lo suficiente pero realmente uno no sabe nada , me emociona mucho este curso y la explicación es muy clara .
yo hice el 60% de este curso hace 8 meses! y aqui estoy de nuevo! JAJAJAJ !
Se explica paso x paso, complemento al curso de “Prework”
Antes de poder utilizar git debes instalarlo, si están en un sistema operativo linux lo puedes hacer desde tu consola utilizando sudo apt install git
Empezamos a utilizar GIT
git init
git add archivo.txt
git commit -m "Version 1"
git add .
git commit -m "Version 2"
git status
git show
git log archivo.txt
git push
git pull
Git es muy poderoso. Vaya, lo es tanto que es imprescindible para los proyectos de hoy en día. Me gustaría ver sus utilidades más allá del control de versiones del software. Estoy seguro que las veré. Gracias Freddy.
Un sistema de control de versiones como Git es de mucha eficiencia ya que nos permite guardar nuestro historial de cambios y crecimiento de los archivos de nuestro proyecto.
Muchas veces las diferentes versiones de nuestros proyectos pueden tener muchas similitudes, en ocasiones los cambios pueden ser solo una simple palabra o determinada parte especifica de un archivo. Git esta optimizado en guardar todos esos cambios de forma atómica e incremental, este sobrepone cambios sobre los últimos cambios, de los cambios anteriores y así hasta el inicio de nuestro proyecto.
Comandos de repositorio:
Git init Arranca el repositorio en Git
Git add Arranca nuestro archivo. Ojo, este comando no almacena las actualizaciones de forma definitiva, solo las almacena en algo que conocemos como “Staging Area”.
Git commit Almacena los últimos cambios en la base de datos para llevar un control, en otras palabras aquí se almacena todo lo que esta en “Staging area”.
Git commit -m Es lo mismo de arriba, la diferencia es el argumento -m nos permite guardar un mensaje para recordar que cambios hicimos, es importante no olvidar que el mensaje tiene que ir entre comillas.
Git status Nos permite ver el estado de nuestros repositorios
Git show Muestra todos los cambios históricos hechos.
Git log biografia.(nombre del archivo) Deja que veamos la información e historia del archivo que elijamos.
Git push Nos permite mandar nuestro repositorio a un servidor remoto, donde todos podamos conectar con nuestros proyectos.
Git pull Trae de vuelta nuestro repositorio del servidor
git init
git add [.]
git commit -m
git push
git status
git log
git clone
¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.