Introducción a Git

1

¿Por qué usar un sistema de control de versiones como Git?

2

¿Qué es Git?

3

Instalando GitBash en Windows

4

Instalando Git en OSX

5

Instalando Git en Linux

6

Editores de código, archivos binarios y de texto plano

7

Introducción a la terminal y línea de comandos

Comandos básicos en Git

8

Crea un repositorio de Git y haz tu primer commit

9

Analizar cambios en los archivos de tu proyecto con Git

10

¿Qué es el staging?

11

¿Qué es branch (rama) y cómo funciona un Merge en Git?

12

Volver en el tiempo en nuestro repositorio utilizando reset y checkout

13

Git reset vs. Git rm

Flujo de trabajo básico en Git

14

Flujo de trabajo básico con un repositorio remoto

15

Introducción a las ramas o branches de Git

16

Fusión de ramas con Git merge

17

Resolución de conflictos al hacer un merge

Trabajando con repositorios remotos en GitHub

18

Cómo funcionan las llaves públicas y privadas

19

Configura tus llaves SSH en local

20

Uso de GitHub

21

Cambios en GitHub: de master a main

22

Tu primer push

23

Git tag y versiones en Github

24

Manejo de ramas en GitHub

25

Configurar múltiples colaboradores en un repositorio de GitHub

Flujos de trabajo profesionales

26

Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master

27

Flujo de trabajo profesional con Pull requests

28

Utilizando Pull Requests en GitHub

29

Creando un Fork, contribuyendo a un repositorio

30

Haciendo deployment a un servidor

31

Hazme un pull request

32

Ignorar archivos en el repositorio con .gitignore

33

Readme.md es una excelente práctica

34

Tu sitio web público con GitHub Pages

Multiples entornos de trabajo en Git

35

Git Rebase: reorganizando el trabajo realizado

36

Cómo usar Git Stash: guarda cambios temporalmente

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits antiguos al head del branch

Comandos de Git para casos de emergencia

39

Git Reset y Reflog: úsese en caso de emergencia

40

Reconstruir commits en Git con amend

41

Buscar en archivos y commits de Git con Grep y log

Bonus sobre Git y Github

42

Comandos y recursos colaborativos en Git y GitHub

43

Tu futuro con Git y GitHub

Aprende Inglés, Programación, AI, Ciberseguridad y mucho más.

Antes: $249

Currency
$209
Suscríbete

Termina en:

5 Días
8 Hrs
19 Min
59 Seg

¿Por qué usar un sistema de control de versiones como Git?

1/43
Recursos
Transcripción

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.

  • El comando para iniciar nuestro repositorio, o sea, indicarle a Git que queremos usar su sistema de control de versiones en nuestro proyecto, es git init.
  • El comando para que nuestro repositorio sepa de la existencia de un archivo o sus últimos cambios es 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).
  • El comando para almacenar definitivamente todos los cambios que por ahora viven en el staging area es 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".
  • Por último, si queremos mandar nuestros commits a un servidor remoto, un lugar donde todos podamos conectar nuestros proyectos, usamos el comando git push.

Comandos básicos de git

  • git init: inicializa un repositorio de GIT en la carpeta donde se ejecute el comando.
  • git add: añade los archivos especificados al área de preparación (staging).
  • git commit -m “commit description”: confirma los archivos que se encuentran en el área de preparación y los agrega al repositorio.
  • git commit -am “commit description”: añade al staging area y hace un commit mediante un solo comando. (No funciona con archivos nuevos)
  • git status: ofrece una descripción del estado de los archivos (untracked, ready to commit, nothing to commit).
  • git rm (. -r, filename) (–cached): remueve los archivos del index.
  • git config --global user.email [email protected]: configura un email.
  • git config --global user.name : configura un nombre.
  • git config --list: lista las configuraciones.

Analizar cambios en los archivos de un proyecto Git

  • git log: lista de manera descendente los commits realizados.
  • git log --stat: además de listar los commits, muestra la cantidad de bytes añadidos y eliminados en cada uno de los archivos modificados.
  • git log --all --graph --decorate --oneline: muestra de manera comprimida toda la historia del repositorio de manera gráfica y embellecida.
  • git show filename: permite ver la historia de los cambios en un archivo.
  • git diff : compara diferencias entre en cambios confirmados.

Volver en el tiempo con branches y checkout

  • git reset --soft/hard: regresa al commit especificado, eliminando todos los cambios que se hicieron después de ese commit.
  • git checkout : permite regresar al estado en el cual se realizó un commit o branch especificado, pero no elimina lo que está en el staging area.
  • git checkout – : deshacer cambios en un archivo en estado modified (que ni fue agregado a staging)

git rm y git reset

git rm:

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:

  • git rm --cached : elimina los archivos del área de Staging y del próximo commit, pero los mantiene en nuestro disco duro.
  • git rm --force : elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos aplicar comandos más avanzados).

git reset

Con git reset volvemos al pasado sin la posibilidad de volver al futuro. Borramos la historia y la debemos sobreescribir.

  • git reset --soft: Vuelve el branch al estado del commit especificado, manteniendo los archivos en el directorio de trabajo y lo que haya en staging considerando todo como nuevos cambios. Así podemos aplicar las últimas actualizaciones a un nuevo commit.
  • git reset --hard: Borra absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.
  • git reset HEAD: No borra los archivos ni sus modificaciones, solo los saca del área de staging, de forma que los últimos cambios de estos archivos no se envíen al último commit. Si se cambia de opinión se los puede incluir nuevamente con git add.

Ramas o Branches en git

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.

  • git branch : crea una nueva rama.
  • git checkout : se mueve a la rama especificada.
  • git merge : fusiona la rama actual con la rama especificada y produce un nuevo commit de esta fusión.
  • git branch: lista las ramas generadas.

Aporte creado por: Franco Coloccini

Aportes 914

Preguntas 110

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Apuntes 📚

Git

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

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 !

No conocía el comando git show Aquí se ve la importancia de estar realizando los cursos que actualizan para aprender nuevas cosas.

Hola aquí les dejo mis apuntes de que es Git y por qué usarlo?

$ 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/*

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

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

Les dejo toda le teoría y los comandos utilizados durante el curso en el siguiente link, pásense!!

https://github.com/AngelCabrera/git2019

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).

El curso no es difícil, pero deberías ir con precaución

De mi experiencia te recomiendo lo siguiente

.

Este curso es de cajón antes de trabajar cualquier cosa (Por eso su nombre)

Curso de Prework: Configuración de Entorno de Desarrollo en Windows

También hay para Linux y MacOs

Este opcional, pero sería muy bueno que también lo hagas

Curso de Introducción a la Terminal y Línea de Comandos

.
.

Tutoriales de Alumnos

.

Te ayudarán a no perderte durante el curso.

.

Los apuntes tienen el nombre de quienes los hicieron, yo solo los recolecte y junte aquí
.

Libro Libre Git Profesional | Libro de 0 a 100
.
TODOS los comandos del curso
.
Guía rápida de Git y GitHub | Resumen Sencillo, (Corto)
.
Git, ramas, buenas prácticas | Historia algo así (Corto)
.
Curso Infografía Verde | Tutorial (Completo)
.
Infografía, Original, Blanca (PDF and/or Canva) | Tutorial Alumno (Completo)

$ 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 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 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.

Yea! con Freddy 😊

Imprimi estas dos hojas y las tengo en frente de mi escritorio por si alguien las ocupa tambien.
Salud y saludos raza!


Ya me veo haciendo el…

$ git push Jarvis_Main_IA_Mark_299.py

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.

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

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

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.
  • git init Inicia el repositorio (Lo crea)
  • git add Agrega los archivos al área de preparación
  • git commit Envía los archivos al SCV
  • git push Envía los archivos del repositorio a un servidor remoto
  • git status Muestra el estado de los archivos
  • git show Muestra los cambios hechos
  • git log Muestra los cambios de los archivos
  • git log --oneline Muestra los commits en una sola línea

$ 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

No sabia lo de git log sobre un archivo especifico…que chevere

Freddy: seguramente le ponen V2 a tus archivos cuando haces cambios
yo:

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 -> Es un sistema de control de versiones creado por Linus Torvalds.

  • $ git init -> Empezar un repositorio en la carpeta en la que estás parado.
  • $ git add [Nombre del Archivo] -> Sirve para agregar el archivo a la base de datos de git. Se da a conocer el archivo a guardar o versionar.
  • $ git commit -m “mensaje descriptivo del cambio” -> Envía los últimos cambios a la base de datos del sistema de control de versiones.
  • $ git add . -> Agrega todos los archivos que hayan cambiado en la carpeta donde estás parado.
    (Después de $ git add . se suele hacer un commit para actualizar la base de datos)
  • $ git status -> Para saber el estado de la base de datos. Te indicará si has hecho un cambio y no lo has añadido o te informará si todo está bien.
  • $ git show -> Te muestra todos los cambios históricos hechos incluyendo cuáles han sido las líneas de código, de texto o líneas de cualquier archivo que esté añadido al repositorio que hayan cambiado, también cuándo se han hecho esos cambios y quién los hizo.
  • $ git log [Nombre del archivo] -> Para ver la historia entera de un archivo.

Para ver más adelante en detalle, los siguientes:

  • $ git push -> Para enviar los archivos o cambios a un servidor remoto.
  • $ git pull -> Para traer los archivos o cambios a un servidor remoto.

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: **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

Hola!
Les comparto esta imagen para reforzar conceptos
Espero les sirva 😃

git init… empecemos este curso!!!

Apuntes del curso 👉🏻 acá
Apuntes de la clase 👇🏻

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)

vamos con git por 5 vez

Les comparto mis apuntes 😃

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”

https://git-scm.com/book/es/v2 link del libro de Git de 500 paginas

Mis apuntes del curso en formato de las Notas de Cornell

Pueden hacer pruebas de git desde la web donde también aprenderán muchos comandos y les permitiran aprender mas de git.

learngitbranching

**Mis aportes para ustedes **

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.

Les dejo un pequeño aporte…

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.

Vengo del futuro cuando ya termine este curso.
Les comparto el enlace al documento que trabaje durante el curso, espero que a alguien le ayude, tome aportes de diferentes personas que dejaron su comentario.

PDF GIT-GITHUB

Hola chicos! Aquí dejo un repositorio que creé con un resumen de los comandos de Git y GitHub.
Estaré actualizandolo para añadir nuevos comandos y/o hacer correcciones de errores que puedan existir…
Bienvenidas vuestras opiniones o sugerencias!
Espero les sea de mucha utilidad 🚀

https://platzi.com/tutoriales/1557-git-github/21103-comandos-de-git-y-github/

hace 3 años tomé este curso y no lo terminé
ahora lo terminaré

Llevo mas de 2 años usando Git para mis proyectos y aun hay cosas que no se, espero aprender muchas cosas nuevas aquí.

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

¿Y qué es git?

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).

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.

-“Underscore”
–Ulala señor frances.
-Entonces como se dice?
–“Raya al piso” :V

Algo similar con mi tesis: versión final, versión final final, versión, final definitiva...

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

¿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:

  • git init: Nos permite iniciar el repositorio (lugar donde se almacenarán los cambios).
  • git add Nombre_archivo: Le indica al repositorio que el archivo existe y lo envía a “Stagin Area”.
  • 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 escribir -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: nos permite ver el estado de nuestra 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: Nos mostrara todos los cambios que hemos hecho, esto incluye las líneas que hemos cambiado, cuando y quien hizo estos cambios.
  • git log Nombre_archivo: nos muestra toda la historia de un archivo.
  • git push: nos permite enviar los cambios que estamos realizando a algún servidor remoto.

Primer curso que vere con Freddy, que bien!

Esta hoja de apoyo brindada por GitHub con los comandos generalmente más utilizados les puede servir, está tanto en español como en inglés por si les interesa 😃

🔹Versión en español

🔹Versión en inglés

Aunque este desactualizado, en esta ocasión vine a ver a Freddy hablar y subirme la moral. bye

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

Extrañaba a Freddy 😊

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

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.

yo hice el 60% de este curso hace 8 meses! y aqui estoy de nuevo! JAJAJAJ !

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 .

Tengo años usando git (lo básico) y no conocía el comando show, maravilloso!!

Que ganas tengo de agregar esto a mi LinkedIn 😂😅

Sistema de Control de Versiones! suena potente no?

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

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.

Aquí te comparto un repositorio que creé con un resumen de todos los comando que vimos con una pequeña descripción. Espero te sea de utilidad:
Comandos de Git y GitHub

Quiero aprender el manejo de Git ya que actualmente se nos pide el comentar en los prs si este puede desplegarse o no a prod para dejar lo manual de a poco, espero finalizarlo integrando a la practica

¿Por qué usarlo? Este es mi aporte 😄

  • GIT es una herramienta mágica que nos permite viajar en el tiempo y deshacer nuestros errores. ¿No sería genial poder hacer lo mismo en la vida real?

  • Con GIT podemos trabajar en equipo sin pisarnos los pies. Cada uno tiene su propia rama donde puede experimentar y crear sin miedo a romper nada. Luego podemos unir nuestras ramas y ver cómo surge la magia.

  • GIT nos ayuda a mantener el orden y la organización en nuestro proyecto. Podemos etiquetar las versiones importantes, crear listas de tareas pendientes, documentar los cambios y seguir el historial de cada archivo. Así evitamos el caos y las confusiones.

Hi 20/02/2023 9:07 am.
Queremos la champions

Me encanta este curso, siempre regreso aquí cada que olvido algún comando o quiero repasar algo xD