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

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

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

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.

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

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

Apuntes 📚

a fredy no se le puede colocar 1.25x, este men ya lo tiene por defecto xd !

$ 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

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

Les dejo una guía de la clase 😄 https://drive.google.com/file/d/1ADhTgqUuDQRXriN3HXkOpHhOctDuzB2J/view?usp=sharing

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

Yea! con Freddy 😊

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

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

$ 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

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

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

https://github.com/AngelCabrera/git2019

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.

Ya me veo haciendo el…

$ git push Jarvis_Main_IA_Mark_299.py

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… empecemos este curso!!!

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

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

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

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”

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)

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

learngitbranching

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

Compañeros les comparto este resumen de la clase, espero que les ayude

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.

Aprender Github en esta cuarentena!

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

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

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

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

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.

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

Esta nueva intro es muchísimo más agradable, especialmente para los oídos.

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

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.

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

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

$ 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

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.

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

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!

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

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

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

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

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?

Estoy super animada para utlizar git en todos los proyectos que haga de hoy en adelante 😄

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 .

Les comparto mis apuntes 😃

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

Esto me recuerda mi tiempo en diseño, version 1…version final, esta si es la final, etc… jajaja tiempos aquellos 😦

que mejor forma de aprovechar esta cuarentena que aprender una herramienta nueva 😄

Lo único bueno de la cuarentena, es poder dedicarme a Platzi ❤️

Version final_final_final_v4 JAJAJA

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.

Mini resumen 02

¿Por que usar un sistema de control de versiones como Git?

Control de versiones

Solamente guardar los cambios ( como los datos de cuando, donde y quien lo hizo?)

Linea de comando :
$ git init // empezar el repositorio (donde se guardara los cambios)
$ git add biografia.txt // Agregar la existencia de biografia.txt
$ git commit -m “version 1” //Es el que envia los ultimos datos del archivo (guardado de cambios).
//-m"version 1" --> es para que mandes un mensaje del cambio (para ser mas ordenado).

$ git add .// Agregar todos los archivos que hayan cambiado en la carpeta actual.
$ git status // te avisa si hay un cmabio si no lo has añadido
$ git show // Te muestra todos los cambiso hechos , cuando se hizo y quien lo hizo.
$ git log biografia.txt // ver la historia completa de un archivo.
$ git push // enviar repositorio local a remoto
$ git pull // traer repositorio remoto a local.