Crea un repositorio de Git y haz tu primer commit

¿No te funciona el comando code en tu terminal?

• Abre Visual Studio Code
• Presiona cmd + shift + p ó si estás en windows ctrl + shift + p
• Busca una opción que diga lo siguiente: Shell Command: Install 'code' command in $PATH
• Selecciónala

Y listo, podrás utilizar dicho comando.

comandos de git aprendidos en esta clase:

• git init: lo usamos para determinar la carpeta en la que vamos a trabajar.

• git status: lo usamos para saber si tenemos un archivo añadido o borrado en nuestro proyecto, para saber en la rama en la que estamos y si tenemos commits.

• git add: es para añadir un archivo a nuestra rama seguidamente ponemos entre comillas el nombre de nuestro archivo o poner un punto para añadir todos los archios de nuestra carpeta.

• git rm: lo usamos para borrar un archivo que hayamos añadido, para eliminarlo por completo de nuestra rama usamosgit rm --cached.

• git commit: se usa para añadir un commit a nuestra rama, también podemos ponerle un -m seguidamente ponemos entre comillas nuestro ensaje.

• git config: muestra configuraciones de git también podemos usar –list para mostrar la configuración por defecto de nuestro git y si añadimos --show-origin inhales nos muestra las configuraciones guardadas y su ubicación.

• git config --global user.name: cambia de manera global el nombre del usuario, seguidamente ponemos entre comillas nuestro nombre.

• git config --global user.email: cambia de manera global el email del usuario, seguidamente ponemos entre comillas nuestro nombre.

• git log: se usa para ver la historia de nuestros archivos, los commits, el usuario que lo cambió, cuando se realizaron los cambios etc. seguidamente ponemos el nombre de nuestro archivo.

inhales again

uuuuuuffff si que me costó escribir esto

Espero les sea de ayuda! 😄

Freddy: La carpeta proyecto1

Yo: no lo digas, no lo digas

Yo:

DATO

Ese numero largo (40 caracteres) se llama SHA (Secure Hash Algorithm, Algoritmo de Hash Seguro) y es un ID unico que se crea para cada commit.

Quizás no sea muy estético XD, pero es un breve resumen de algunos de los comandos utilizados hasta el momento.

Primera versión de historia.txt aquí: https://github.com/freddier/hyperblog/tree/ab1f35ead47ab653bf2b680333cffee4409d48bb

Segunda versión aquí:
https://github.com/freddier/hyperblog/tree/9748f6531ec74adead2b2a4a03a55b7f6e379059

Buena frase: “La Gente que NO sabe GIT es porque no sabe que hacer ante los Errores”

dure media hora, pero lo logre ❤🤘.
Cuando le das el comando
$git config --list
Git te pide… no se que te pide sale toda la configuracion y solicita algun comando, supongo, le das Q + : para que te saque y te deje seguir escribiendo comandos.
Advertencia, no se si sea configuracion mia o qué, estoy haciendo el curso paso a paso con windows. Si te estancas, dale lo anterior y sigue xd

Cambios atómicos.

Aquí un pequeño resumen de los comandos usados frecuentemente en Git

Comandos en Git (La guía completa)

Hola les dejo mis apuntes de la clase.
Flujo de trabajo de Git en nuestro repositorio local.

Mi resumen de esta clase:

$ git init  //Inicia Git dentro de la carpeta raíz de nuestro proyecto
$ git config // ver la configuración actual de git
$ git config --global  user.email "[email protected]" //Configurar tu email
$ git --global user.name "Tu Nombre" //Configura tu nombre de usuario
$ git code // Abre Vscode en Windows
$ git status //Muestra el estado acual de la base de datos 
$ git add _myfile.txt _//Agrega el archivo en Staging
$ git add .// Sube todo los archivos de la carpeta actual
$ git rm -- cached _myfile.txt_  // Elimina el archivo de la RAM sin eliminarlo de la carpeta
$ git commit -m "Primer commit de este archivo" //Sube el archivo al repositorio
$ git log _my file.txt_ //Puede ver todas las modificaciones del archivo asi como ver quien las hizo

Cuando instala por primera vez git debes hacer una configuración básica y éstas son las siguientes:

1. git config --global user.name “Aquí va tu nombre”

2. git config --global user.email “Aquí tu correo electrónico”

3. git config --global color.ui true Sirve para colorear la mayor parte de los resultados como por ejemplo git log.

4. git config --list

Ahora si por algún motivo te equivocaste en el nombre o email lo puedes modificar de la siguiente manera:

git config --global --replace-all user.name “Aquí va tu nombre modificado”

O si lo deseas eliminar y añadir uno nuevo
git config --global --unset-all user.name :Elimina el nombre del usuario
git config --global --add user.name “Aquí va tu nombre”

• pwd: Nos muestra la ruta de carpetas en la que te encuentras ahora mismo.
• mkdir: Nos permite crear carpetas (por ejemplo, mkdir Carpeta-Importante).
• touch: Nos permite crear archivos (por ejemplo, touch archivo.txt).
• rm: Nos permite borrar un archivo o carpeta (por ejemplo, rm archivo.txt).
Mucho cuidado con este comando, puedes borrar todo tu disco duro.
• cat: Ver el contenido de un archivo (por ejemplo, cat nombre-archivo.txt).
• ls: Nos permite cambiar ver los archivos de la carpeta donde estamos ahora mismo.
Podemos usar uno o más argumentos para ver más información sobre estos archivos (los argumentos pueden ser – + el nombre del argumento o - + una sola letra o shortcut por cada argumento).

-ls -a: Mostrar todos los archivos, incluso los ocultos.

-ls -l: Ver todos los archivos como una lista.
cd: Nos permite navegar entre carpetas.

- cd /: Ir a la ruta principal:

- cd o cd ~: Ir a la ruta de tu usuario

- cd carpeta/subcarpeta: Navegar a una ruta dentro de la carpeta donde estamos ahora mismo.

- cd … (cd + dos puntos): Regresar una carpeta hacia atrás.

• git init: Se crea staging en memoria ram y en el repositorio en HDD
• git add: trakea cambios en el staging
• commit: cambios en el repositorio
• checkout: atrae cambios de alguna rama
• git config --global user.email "[email protected]"
• git config --global user.name “Tu Nombre”

Si quieren crear una carpeta y al mismo tiempo inicializar un repositorio lo hacen con el comando

$ git init nombreCarpeta

git init -->Para inicializar el repositorio git y el staged
git add nombre_del_archivo.txt → Enviar el archivo al staged
git status -->ver el stado, si se requiere agregar al starget o si se requiere commit
git conf -->para ver las posibles configuraciones
git conf --list -->para ver la lista de configuraciones hechas
git conf --list --show-origin -->para mostrar las configuraciones y sus rutas

Cuando instala por primera vez git debes hacer una configuración básica y éstas son las siguientes:
git config --global user.name “Aquí va tu nombre”
git config --global user.email “Aquí tu correo electrónico”
git config --global color.ui true Sirve para colorear la mayor parte de los resultados como por ejemplo git log.
git config --list
Ahora si por algún motivo te equivocaste en el nombre o email lo puedes modificar de la siguiente manera:
git config --global --replace-all user.name “Aquí va tu nombre modificado”
O si lo deseas eliminar y añadir uno nuevo
git config --global --unset-all user.name :Elimina el nombre del usuario
git config --global --add user.name “Aquí va tu nombre”

git rm --cached nombre_del_archivo.txt → para eliminar el archivo del staged(ram)
git rm nombre_del_archivo.txt → para eliminar del rep

Por Buena practica ahora no se usa la rama (master) en cambio se usa la rama (main) en la documentación habla de que al momento de crear el repositorio desde la carpeta y en la linea de comando se pone :
git branch -M main
or
git branch -M master main
pero a mi no me permitió hacerlo así, asi que si alguien presenta el mismo problema, que hice yo…
me fui a la carpeta oculta de .git ==> al archivo HEAD lo abri con block de notas y cambie la palabra master por main así queda:

le das atrás (cd …) y luego entras de nuevo a la carpeta del repo y ya veras los cambios de la palabra master por main

Para quienes usan Max o linux “ls -la” tiene una version resumida utilizando “ll” (ele, ele) (>‿◠))

Aquí les dejo mis apuntes:

Comandos git:
git init: crea repositorio en carpeta actual: .git/
git status: ver estado del proyecto
git add <nombrearchivo> envia archivo a staging (nota: usando . puedes mandar toda la carpeta a staging)
git rm --cached <nombrearchivo> remueve el archivo de staging
git commit -m <mensaje>: envia el staging a repositorio con el mensaje
git config: configuraciones de git
– list: lista configuraciones basicas de git
–show-origin : ubicacion de las configuraciones
– global user.name <nombre> cambiar nombre del usuario
– global user.email <email> cambiar email del usuario
git log <nombre archivo>: historial de commits del archivo

Nota

• para letras de acceso rapido a un comando
  – para palabras comando

Comandos usados y aprendidos

   54  pwd
   55  git init
   56  code
   57  git status
   58  git add historia.txt
   59  git status
   60  git rm historia.txt
   61  git status
   62  git rm --cached historia.txt
   63  git status
   64  git add historia.txt
   65  git status
   66  git status
   67  git config --list
   68  git --list --show-origin
   69  git config --global user.name "Xtian"
   70  git config --global user.email "[email protected]"
   71  git --list
   72  git config
   73  git config list
   74  git config --list
   75  git commit -m "Este es mi primera versión de mi historia"
   76  git status
   77  code historia.txt
   78  git status
   79  git add historia.txt
   80  git status
   81  git commit -m "agregando edad y gustos"
   82  git status
   83  git log historia.txt
   84  history

Solamente les comento que en el comando git log existe el siguiente argumento:

git log --oneline

el cual mostrará la información más resumida, con cada commit en una sola línea

$git init: inicializa el repositorio
$ls -al: lista los archivos ocultos creados después de inicializar repositorio
$git status: verificar el estado del repositorio(ver si hay cambios o no)
$git add file.txt: agrega el archivo a staging(RAM)
Nota:para sacar el file.txt de RAM, ejecutar **$git rm --cached file.txt rm(remover), indica remover de RAM, pero no eliminar archivo

$git config: muestra todas las configuraciones que tiene git.

Para conocer qué usuario hizo commits
$git config --global user.name “John Doe”
$git config --global user.email "[email protected]"
**$git log file.txt:**historia de los commits hechos

Tip: Es buena práctica dejar un mensaje a cada commit que se envía.

La práctica y el compartir conocimiento te convertirá en un profesional destacado
Latam para el mundo

Mis apuntes :3

para los que quieran poner atom desdes el terminal 😄
https://vortexbird.com/configuracion-para-abrir-atom-desde-la-consola-o-terminal-en-osx/

Comparto para repasar un poco los comandos.
https://github.com/susannalles/MinimalEditions/wiki/Lista-Comandos-Terminal

git init: activa git
ls- al: Muestra los archivos ocultos
code: abrir visual studio code
git status: muestra el estado del proyecto
git add: manda el archivo a memoria
git rm: elimina el archivo
git --cached: elimina de memoria el archivo(quita el add)
git commit -m “mensaje”: Envia los cambios a repositorio
git config: configurar git
git config --list:muestra la configuración
git config --list --origin: muestra donde esta guardada la configuración
git config --global --user.name: introduce nombre de usuario
git config --global --user.email: introduce el correo
git log <archivo>: muestra el historial de cambios

Hola hice un paso a paso de clase

1. Creamos una carpeta llamada proyecto1
2. Le damos el comando git init
3. Le damos el comando ls -al y podemos ver las carpetas vacías y comprobar que efectivamente tenemos la de git
4. Abrimos visual studio code y guardamos un archivo de texto y lo guardamos en la carpeta,
5. Le damos git status y ahi vemos cuales son los archivos que aún no se han trackeado
6. Luego la damos git add para empezar a trackearlo
7. Lo sacamos dandole git rm —cached

** Nota
Cached - Significa que esta en memoria RAM - no en GIT

1. Le damos Commit y enviamos al repositorio
2. Configuramos quien somos nosotros para poder determinar quien hizo que
3. Le damos el siguiente comando Git config - para mostrar la configuración

** Nota

Git Config - nos da los comandos principales de GIT

1. Le damos el comando GIT config - - list para poder ver la configuración por defecto de nuestro Git - esto para ver el nombre y correo del usuario
2. Le damos el comando GIT config - - list - - origin y ahi sabemos donde están guardadas las configuraciones - casos más avanzados
3. Le damos GIT consigo - - global eso lo usamos para cambiar todos los usuarios global
4. Para cambiar el nombre en la configuración y el email le damos el siguiente comando:
5. Cambiamos el archivo historia.txt - eso lo podemos hacer con el comando CODE
6. Usamos el comando CAT historia.txt - para ver el contenido del archivo - pero no puedo modificarlo
7. Hacemos los cambios y guardamos - ahora cuando hacemos git status el reconoce que se modifico el archivo
8. Hacemos un nuevo commit - PERO NO PASA NADA! SIEMPRE LOS CAMBIOS DEBEMOS AGREGARLOS CON EL BOTON DE ADD
9. Hacemos el comando ADD . -> El punto al final lo que hace es que agregamos todos los archivos de una vez
10. Ahora si podemos entrar a hacer el commit
11. Para ver toda la historia le damos git log historia.txt

Yo… no tengo ni idea de que esta pasando 😃

Me devuelvo hasta acá para ahorrarles un dolor de cabeza más adelante 😂 Por la clase 18 se van a enterar que GitHub cambió algunas palabras clave. Entre esas, cambió el nombre de la rama principal, pasando de llamarse master a llamarse main. Esto les causará unos conflictos más adelante, que pueden evitar desde ahora ejecutando este comando antes de iniciar cualquier repositorio:

git config --global init.defaultBranch main

¿Por qué?. El asunto aquí es que Git (a diferencia de GitHub) sigue manejando master como rama principal default, y luego se toparán con problemas por este conflicto con los nombres. Ejecutando el comando de arriba evitarán ese problema.

Lo que hace este comando es configurar su Git para que la rama principal por defecto de todos los repositorios que inicien sea main. Así estará sincronizado con GitHub cuando lleguen a esa parte y se ahorrarán un dolor de cabeza por ese conflicto. Si lo hacen, cada que Freddy se refiera a master, saben que ahora es main.

RESUMEN

1. Cuando estamos en la carpeta o directorio principal de nuestros archivos podemos ejecutar el comando:

git init

1. Si queremos abrir Visual Studio Code desde el terminal Git Bash podemos ejecutar el comando:

code

1. Si quermos ver si hay algun archivo que se tenga que añadir o nos muestre que se a modificado un archivo etc. podemos ejecutar el comando:

git status

1. Si queremos que nuestro archivo viva temporalmente en la memoria RAM podemos ejecutar el comando:

git add <nombre_archivo>

1. Si queremos mandarlo a nuestro repositorio enviando un mensaje, ejecutamos

git commit -m "Mensaje"

1. Cuandi un archivo esta viviendo en la RAM y queremos retirarlo, ejecutamos el comando:

git rm --cached <nombre_archivo>

pasos para agregar la terminal de git en windows a visual Studio code

1.-primero encontrar la ruta de la terminal

2.-darle click derecho y darle en propiedades para copiar la dirección de git-bash.exe

3.-entrar en configuracion de Visual Studio Code (CTRL+,) o desde la pestaña file en la parte de preferencias

4.-buscar en configuracion: Integrated Automation Shell Windows y entrar

5.-añadir al archivo json lo sig ( “terminal.integrated.git”: ) y pegar la ruta de la terminal de git

listo asi de facil puedes abrir la terminal git-bash desde visual studio code 😄

AQUI MIS APUNTES DE ESTA CLASE, ESPERO Y LES SIRVAN 😄
Para crear un repositorio tienes que decir donde esta la carpeta central de tus archivos ( por ejemplo normalmente cuando desarrollas una pagina web es donde esta un archivo index.html )
git init Es para inicializar un repositorio.
git status Es para saber el estado del proyecto en ese momento.
git add Es para incluir los archivos en el stage area y empezar a hacer un seguimiento (tracked).
git rm --cached Sirve para quitar algún archivo de tu base de datos de git, básicamente quita un archivo de el stage area (untracked).
git commit Es el que envia los cambios al repositorio, es posible hacer commit y ya pero esto es una mala practica!, lo correcto es dejar un mensaje antes de enviarlo al repositorio: git commit -m “Tu mensaje”.
git config Sirve para configurar git.
git config --list Podremos ver la configuración por defecto de tu git, así como las cosas que te faltan configurar.
git config --list --show-origin Para ver donde están las configuraciones guardadas (casos avanzados).
git config --global user. name “Tu nombre” Sirve para cambiar tu nombre de usuario en git.
git config --global user. email “Tucorreo @correo. com” Sirve para cambiar tu email en git.
git log Para ver la historia de cambios de tu archivo.
HEAD Es la versión mas actual o la que esta en cabecera.

Si olvidan poner mensaje al commit y entran al editor de texto vim, solo se oprime i para comenzar a escribir, Escape para salir del modo edición, :w para guardar y :q para salir.

Con el comando git config --unset puedes borrar la propiedad que quieras borrar de la configuración.
Por ejemplo:
git config --global --unset color.ui
git config --global --unset core.editor
recuerda esto modifica el entorno global, es decir aplica para todos tus repositorios, para hacerlo de forma local (solo en el repositorio actual) agrega --local antes del --unset.

Tip: Estas configuraciones se encuentran en archivos de texto que igual puedes editar de forma directa si así lo deseas, sólo ten mucho cuidad podrías romper algo

Rutas (Mac y Linux):

• Configuración global: ~/.gitconfig
• Configuración local: ./.git/config

Freddy, el unico profesor en el cual, ademas de no aumentar la velocidad del video, seguramente retrocediste unas 20 veces, lo cual el video de 10 minutos se te hizo de 30

Si alguien hace la cagada que hice yo, de escribir git commit sin los comentarios, esto se guarda y bueno la forma de borrar esto es primero hacer un git status y debemos tipear git rm --cached historia.txt y este te dira el siguiente mensaje $ git status
On branch master
Changes to be committed:
(use “git restore --staged <file>…” to unstage)
deleted: historia.txt

Una vez que haga eso volvemos a hacer el git add historia.txt
y despues hacemos el git add historia.txt

y ya ahora si se creara correctamente, Saludos!

Una forma de salir de la ventana de comando cuando se olvide poner el mensaje al lanzar el commit es:

Dar clic en ESC¨y después escribir :wq

Para abrir un proyecto en sublime text desde la terminal, solo hay que ir desde la terminal a la carpeta que queremos abrir en sublime y escribir “subl .” (sin las comillas) y se abrirá sublime text con el proyecto

git init: para crear el repositorio vacio de git
code: para abir visual studio
git status: para ver el estado de repositorio
git add: ppara saber que hay cambios que tienen que ser enviados
git rm: para borrar
git rm --cached: para borrarlo de la memoria ram
git commit: envia los cambios al repositorio
git commit -m " ": mensaje
git config: todas las opciones que tienen git
git config --list: configuacion por defecto de tu git
git config --list --show-origin: donde estan las configuraciones guardadas
-: para letras
–: para palabras
git config --global user.name " ": para cambiar el nombre
git config --global user.email " ": para cambiar el email
git add .: para agregar a la carpeta actual
git log: para ver todo lo que se ha hecho en el archivo

git add . (Agrega archivo a cache)
git rm --cached (Borra cambio de la cache)
git add .
git commit -m “Comentario” (Guarda Cambios despues de un git add .)
git status (revisa el estado del archivo)
Comandos para identificarte: 
git config --global user.email "[email protected]"
git config --global user.name "Tu Nombre" 
git log (Para ver el historial de cambios)

Iniciar Git

git int

Iniciar Git

Configuración de Git

git config
git config --list
git config --list --show origin
git config --list --show-origin
git config --global
git config --global user.name “SC"
git config --global user.email "[email protected]”

Configuración de Git

Agragar a la zona de preparación

git add Archivo.txt

git add .

Agragar a la zona de preparación

Ver estado

git status

Ver estado

Quitar de la zona de preparación*********

git rm --cached archivo.txt (Quitar de la zona de preparación).

Quitar de la zona de preparación*********

Realizar commint

git commit -m “Este es el pimer commit de este archivo”

Realizar commint

Ver el historial de cambios del archivo

git log
git log Archivo.txt

Ver el historial de cambios del archivo

git show

vamos yo puedo yo puedo , no me voy a rendir … ufff

En git el uso de (-)
–: palabra
-: un comado.

Fam. Guzman Gonzalez@DESKTOP-IDM3MVO MINGW64 /c/users
$ mkdir proyecto2/
mkdir: cannot create directory ‘proyecto2/’: Permission denied

eso me indica cuando quiero hacer mi carpeta
¿Quien me puede ayudar?

Si quieren saltarse el paso de hacer el add, solo agreguen la bandera -a. Por ejemplo:

git commit -a -m "Freddy es un año mas viejo"

Y automáticamente se hace el add y el commit en un solo comando

Los comandos a utilizar basicos son los siguiente:

-git init : Para iniciar el repositorio.
-git add: para agregar a cached los cambios realizados a tu archivo.
-git commit: para agregar los cambios al repositorio (Es importante utilizar "git commit -m “MENSAJE” para agregrar un mensaje al agregar cambios al repositorio.
-git log: para verificar las diferentes versiones y cambios que le haz realizado a tu documentos (verificar commits).
-git config --global user.name: para cambiar el nombre.
-git config global user.email: para cambiar el email

A-tó-mi-co, Se dice a-tó-mi-co 😄

Hola a todos yo tenía un lio, no se ejecutaba visual studio code desde git bash, hice la configuración agregando de la ruta y nada, el tema es que yo instalé Visual Studio Code - Insiders y para ejecutarlo hay que invocarlo como (Code-Insiders) espero les ayude este pequeño aporte😎👍

⚙ git config permite definir valores de configuración de Git a nivel de un proyecto global o** local**.

Haciendo commit

• Nos situamos en la carpeta del proyecto nuevo
• Comando git init para iniciar un repositorio que guardara el historial de cambios del proyecto.
• Automáticamente se crea una capeta oculta llamada .git
• Creamos los archivos archivo.txt
• Comando git status para ver los cambios que faltan agregar al repositorio
• Comando git add <archivo.txt> para agregar un archivo en especifico al stedsh
• Comando git add . para agregar todos los archivos disponibles al stedsh
• Comando git rm --cached archivo.txt retira el archivo agregado del stedsh
• Comando git commit -m "Este es un mensaje" para confirmar que agregue los cambios al repositorio y va acompañado de un mensaje (Colocar un mensaje es una buena practica para tener un seguimiento de los cambios que se han realizado)

Configurar GIT

Es importante configurar los datos para saber quien esta haciendo los cambios.
Si no configuramos los datos nos enviará variables por defecto de windows

• Comando git config nos muestra todas las configuraciones disponible de GIT
• Comando git config --list muestra la configuración por defecto o información de los datos ya configurados.
• Comando git config --list --show-origin muestra el lugar (ruta) donde esta guardada la configuración
• Comando git config --global user.name "Tu nombre" para cambiar el nombre de usuario
  (–global, se va a cambiar la configuración global de todos los usuarios)
  – Comando git config --global user.email "Tu correo" para configurar el correo del usuario

Haciendo cambios a los archivos

• Después de realizar cambios revisamos el status comando git status y nos mostrara los archivos modificados
• Realizamos un “commit” para agregar los cambios al repositorio

Ver la historia de los archivos

• Comando git log <archivo.txt> Para ver los cambios
  • Se muestra el nombre de quien hizo los cambios y cuando fueron hechos
  • Se muestratag es el código interno para nombrar los cambios

Algunos desarrolladores creen que porque el hash está compuesto por 40 caracteres (160 bits) es posible encontrar 2 commits con el mismo hash. Sobre todo cuando se hacen miles de commits en proyectos tan grandes como linux (más de 4M de commits).
Pero este riesgo es realmente mínimo, casi que insignificante. Un script a calculado la probabilidad de caer sobre una colisión a lo largo de la vida de un repositorio con más de 200 mil millones de commits. Esta probabilidad es inferior a 1.3x10e-26.
Es más probable que un meteorito caiga sobre tu cabeza ( 1.96x10e-15 ) que de encontrar un conflicto en los objetos de Git.
En pocas palabras, el riesgo de conflicto es extremadamente insignificante que no debería tenerse en consideración.

Resumen de la clase en términos de los comandos:

$git init (crea el repositorio)
$git  status (muestra el estado de la carpeta)
$git  add _archivo_ (agrega a archivo a Staging)
git rm --cached _archivo_ (Elimina al archivo de Staging)
$git commit (guarda los cambios en la base de datos)
$git add . (agrega a staging todos los archivos de la carpeta)
$git  log (muestra la historia en cuanto a commits del proyecto)
$git  log _archivo_ (muestra la historia en cuanto a commits de archivo)

En log encontraremos una serie de caractéres extraños, este es el tag del commit, su nombre de referencia. El commit que contenga (Head->master) será el más reciente.

Espero que les sirva.

Configurar git

Ver configuraciones de git

Git config

Ver configuración por defecto en forma de lista

Git config --list

Creando repositorio

Iniciar repositorio.

Git init

Agregar archivo a estado de staging (estado temporal)

Git add index.html

Agregar todos los archivos

Git add .

Remover o sacar de staging

Git rm index.html

Para borrar

Git rm –cached index.html

Para ver el status del proyecto

Git status

Agregar el archivo al repositorio “-m” para escribir un mensaje

Git commit -m “este es el primer commit”

Trae los cambios a la carpeta

Checkout

Lanzar vs code desde la terminal

Code

Abir un archivo en en vs code

Code index.php

Para ver el contenido de un archivo utilizo

Cat index.html

Para ver la historia de un archivo

Git log index.php

Gracias por el vídeo, Freedy. Continuo aprendiendo cosas nuevas, al principio del vídeo cuando explico lo relacionado al commit, Git me permitió hacerlo sin ningún problema y después me di cuenta que un usuario y correo ya se habían asignado, supongo que esto se debía a la configuración que se creo cuando use GitHub de escritorio. Acá dejo una imagen:

Saludos Freddy. Me encantan todos tus cursos pero quisiera decir algo en particular con respecto a este, yo vi el curso pasado de GiT con Leonidas y de verdad fue mi mejor experiencia dentro de Platzi y creo que hay varias fallas aqui(con mucho respeto) creo que si queremos empezar algun proyecto en git debemos empezar por las bases y creo que una de las primeras clases es detallar la importancia del git config --global y la importancia de este. preparar bien nuestro entorno y empezar a trabajar. creo que mas alla de comandos de git como add rm status log primero deberiamos aprender a crear desde el bash, comandos como touch, mkdir y ver un poco mas a detalle… todo lo digo con animos de mejorar y por que comparando este curso con el de Leonidas el anterior en 10 clases ya te atrapa el curso y no te deja salir… en cambio este es como que sabes que estas viendo una buen película pero todavía sientes la intriga que no sabes que pasara… espero que puedas tomar mi opinión de la mejor forma por que tenia necesidad de decirla

Entendido

git init
git config --list
git config --list --show-origin 
git config --global user.name "DBZ"
git config --global user.email "[email protected]"

git status
git add historia.txt
git rm historia.txt
git rm --cached historia.txt
git commit -m "Este es el primer commit de este archivo"
git add ,
git commit -m "Cambio para reflejar la edad correcta"
git log historia.txt

Una buena practica en platzi seria por cada curso crear un archivo apuntes.txt e e irlo trackeando en git en conjunto con los archivos del curso

Para este curso veo los videos dos veces y voy anotando todos los comandos en un Wordpad 😄

A veces podremos tener algún tipo de archivo que no quieres que Git añada automáticamente o más aún, que ni siquiera quieras que aparezca como no rastreado. Este suele ser el caso de archivos generados automáticamente como trazas o archivos creados por tu sistema de compilación. En estos casos, puedes crear un archivo llamado .gitignore que liste patrones a considerar. Este es un ejemplo de un archivo .gitignore:

$ cat .gitignore
  *.[oa]
  *~

La primera línea le indica a Git que ignore cualquier archivo que termine en “.o” o “.a” - archivos de objeto o librerías que pueden ser producto de compilar tu código. La segunda línea le indica a Git que ignore todos los archivos que terminen con una tilde (~), la cual es usada por varios editores de texto como Emacs para marcar archivos temporales.

Comandos de GIT

git config --list //Lista las configuraciones
git config --global user.name "Mr Internauta"
git config --global user.email "[email protected]"
git init //Inicializar un directorio como un proyecto git
git add nombreArchivo.txt //añadir un archivo al staging
git add . //añadir todos los archivos al staging
git commit -m "mensaje (version1)" //Añadir los cambios a la rama master(Se puede realizar el commit sin el mensaje pero es mala practica)
git status //ver el estado actual del proyecto
git log //ver los cambios del proyecto
git log nombreArchivo.txt //Se pueden ver los cambios de un archivo en particular

Si el archivo lo quieren modificar ahi mismo en consola, usen el comando “vi” seguido del nombre del archivo, modifican y para salir pulsan esc :wq

Si ingresan en la terminal:

git config --global alias.superlog "log --graph --abbrev-commit --decorate --date=relative --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all"

cada que ejecuten git superlog se ve más cómodo

Les anexo una liga de comandos elementales para git:

https://www.hostinger.mx/tutoriales/comandos-de-git

Excelente, la verdad git me tenia frustrada… pero ya entendi mejor 😄

git add . (Agrega archivo a cache)
git rm --cached (Borra cambio de la cache)
git add .
git commit -m “Comentario” (Guarda Cambios despues de un git add .)
git status (revisa el estado del archivo)

Me parece que hay un error en la explicación, el comando “git rm” (sin --cached) provoca un error en la terminal y no causa ningún cambio en el archivo involucrado, creo que la única forma de deshacer el proceso de “git add <file>” es con “git rm --cached <file>”.

*Los $ no debes escribirlos

1)Añade tu usuario y email

$ git config --global user.name “” añades usuario.
$git config --global --unset-all user.name para eliminar el usuario.
$git config --global user.email “” añades tu correo.
$git config --global --unset-all user.email para eliminar el correo.
$git config -l o $git config –global --list si quieres verificar que lo hiciste bien.

2)Crea el directorio

cd ~ para ir a la carpeta de tu usuario.
mkdir para crear el directorio.

3)Luego crea el repositorio (master) y staging.

$git init para crear el repositorio y staging, recuerda hacerlo en el directorio que creaste.
$rm -rf .git para eliminar el repositorio y staging.

4)Crea un archivo

$touch (recuerda añadir la extensión de archivo: .txt)

5)Escribe en ese archivo

Puedes hacerlo desde tu editor de código o en el bloc de notas (NUNCA en Word).

6)Guarda el archivo en staging

$git add

7)Guarda el archivo en el repositorio(master)

$git commit -m “” (recuerda dejar un mensaje).
$git commit . -m “” para guardar todos los archivos que estén en staging en el repositorio.
$git commit historia.txt -m “” para guardar un archivo especifico en el repositorio.

8)Verifica 

$git status para verificar el estado del archivo, debe decir “nothing to commit, working tree clean”

9)Cambia el archivo a unstaged 	

Luego de realizar el commit vuelve a modificar el archivo, guárdalo y verifica su status, esto hará que esté unstaged (El archivo está tracked, pero git desconoce qué cambios hay), para solucionarlo repite los pasos 6 y 7

proyecto 1 no era un grupo de merengue?..disculpem, era solo el chiste malo del dia…

Lo mejor de este curso es que puedo aprender a mi ritmo, pausando y adelantando cuanto quiero. Gracias Freddy, buena clase.

En

git config --list

da la misma con -l

git config -l

En octubre de 2020, GutHub cambió el branch por defecto de “master” a “main” para evitar referencias a la esclavitud:

https://www.xataka.com/aplicaciones/master-blacklist-mundo-software-se-rebela-referencias-a-esclavitud

https://www.zdnet.com/article/github-to-replace-master-with-main-starting-next-month/

muy bueno!! yo realice los cambios en el archivo desde vim, para aplicar lo visto en la clase de linea de comandos, igualmente con la creación de ese mismo

Recuerda que Git está optimizado para trabajar en equipo, por lo tanto, debemos darle un poco de información sobre nosotros. No debemos hacerlo todas las veces que ejecutamos un comando, basta con ejecutar solo una sola vez los siguientes comandos con tu información:

git config --global user.email "[email protected]"
git config --global user.name “Tu Nombre”

Crea un repositorio de Git y haz tu primer commit

• Al utilizar el comando git init se crea la estructura de carpetas utilizada por git para el repositorio
  • La carpeta se llama .git y es una carpeta oculta, podemos verla con el comando ls -al
• Al crear un archivo podemos ver con git status en que estado se encuentran dichos archivos y git nos indica si aún no se ha agregado con git add o si ya están en la staging area
• git rm —cached <archivo>: cached significa que está en memoria ram (staging), sirve para quitar los cambios añadidos con git add del staging
• git config: muestra todos los posibles usos del comando para configurar git
  • --list: muestra una lista con la configuración actual
  • --list --show-origin: muestra donde están guardados los archivos de configuración (usuarios avanzados)
  • --global user.name "<usuario>": configura un nombre de usuario en git para ser usado en todos los repositorios
  • --global user.email "<correo>": configura el correo del usuario para ser usado en todos los repositorios

Es necesario configurar el nombre de usuario y el correo en git para poder realizar commits

• git log <archivo>: muestra un historial de todos los commits realizados en dicho archivo

• Para crear un repositorio usamos el comando

<$git init>

Una vez ejecutado el comando, podemos verificar la creción del repositorio solicitando a la consola que nos muestre el contenido del directorio, incluido los archivos ocultos, usando el comando

<$ls -al>

• Para visualizar el estatus del proyecto utilzamos el comando

<$git status>

• Para cambiar el estado de un archivo de “untracked” a “tracked” usando el comando

<$git add archivo.txt>

• Para cambiar del estado actual al estado anterior un archivo usamos el comando

<$git rm --cached archivo.txt>

• Para mover el archivo al repositorio usamos commit, una buena práctica es dejar un comentario para inidicar los cambios realizados, el comentario se agrega utilizando un argumento especial (-m), y el comentario debe ir entre comillas

<$git commit -m "Comentario">

Para poder ejecutar un commit correctamente, es necesario completar las configuraciones de usuario de git

• Para visualizar los comandos disponibles en la configuración de git utilizamos

<$git config>

• Para visualizar las configuraciones actuales usamos

<$git config --list>

• Para visualizar la ubicación de las configuraciones de git utilizamos

<$git config --list --show-origin>

• Para cambiar el usuario de git utilizamos

<$git config --global user.name "Nombre de Usuario">

El nombre de usuario que se usará debe estar dentro de comillas

• Para cambiar el correo electrónico del usuario de git utilzamos

<$git config --global user.email "Correo electrónico">

El correo electrónico que se usará debe estar dentro de comillas, en ambos casos la palabra –global indica el cambio en todos los usuarios globales de git

• Para visualizar el contenido de un archivo desde la consola usamos el comando

<$cat archivo.txt>

• Para registrar correctamente los cambios realizados dentro de un archivo en git y que estos se vean reflejados en el repositorio es necesario seguir ejecutar los comando en el siguiente orden

<$git add arcihvo.txt
$git commit -m "comentarios de cambios">

• En caso de que queramos ejecutar un comando a todos el contenido de un directorio, podemos utilizar el signo punto (.), ya que en git punto es sinónimo del directorio actual en el que estemos ubicados

<$git add .>

• Para revisar el historial de cambios de un archivo en git, usamos el comando

<$git log>

Notas adicionales

• En git el uso de un solo guión (-) indica el uso de un comando de acceso rápido

<$-al
$-m>

• En git el uso de un dos guiones (–) indica el uso de palabras

<$git config --global user.name
$git config --list>

• El uso de la palabra –cached hace referencia a algo ubicado en la memoria RAM

al fin una explicación sobre lo que significa un guión y dos guiones

Aquí les dejo un post sobre cómo escribir el comentario para su commit.

¡Recomendación! 😭

Esta es la segunda vez que hago este curso. La verdad es que, si bien entendía la lógica en las clases, no me sentía cómodo con mi nivel, ni hablar con el uso de la terminal.

Entonces, seguí para adelante, tome el curso de Introducción a la Terminal y ahora tengo otro entendimiento, de esa manera, capto mejor este curso.

Recomiendo que vayan al curso de Terminal de Linux y luego sigan con este. 😁

Crear un repositorio de Git y primer commit

.

Creación del repositorio

Primero debemos abrir la terminal de Git Bash y navegar hasta el directorio raíz donde queremos crear el repositorio utilizando el comando cd. Una vez en el directorio raíz, debemos inicializar el repositorio de Git con el comando git init. Esto creará un directorio oculto que contiene toda la información necesaria para que Git pueda realizar un seguimiento de los cambios en tus archivos.
.

Configuraciones importantes previas

Es recomendable realizar unas configuraciones antes de agregar carpetas o archivos a nuestro repositorio para asegurarnos de que el historial de cambios se registre adecuadamente y evitar errores comunes en el flujo de trabajo. Algunas de ellas son las siguientes:
.

• Establecer el nombre y correo electrónico del usuario: Git utiliza esta información para identificar quién realizó los cambios en el código. Se puede configurar el nombre y correo electrónico usando los siguientes comandos:

git config --global user.name "Nombre Apellido"
git config --global user.email "[email protected]"

• Configurar la rama predeterminada: Es importante indicar la rama en la que se va a trabajar en el repositorio, lo que ayuda a evitar confusiones y errores al momento de hacer commits y fusiones. Por lo general, la rama predeterminada es "main" o "master". Para configurar la rama predeterminada, se puede usar el siguiente comando:

git config --global init.defaultBranch main

• Configurar un editor de texto: Cuando se utiliza Git en la línea de comandos, es posible que necesite editar mensajes de commit o resolver conflictos de merge. Para ello, es recomendable configurar un editor de texto predeterminado. Por ejemplo, para utilizar el editor Vim se puede usar el siguiente comando: git config --global core.editor vim
• Ignorar archivos innecesarios: Git permite ignorar archivos que no deben ser versionados, como archivos temporales o de configuración que no son relevantes para el proyecto. Para ello, se puede crear un archivo llamado .gitignore en la raíz del proyecto, en el cual se especifican los patrones de archivos a ignorar. Por ejemplo, para ignorar archivos de log se puede agregar la siguiente línea al archivo .gitignore:

*.log

Agregar archivos al repositorio

Es importante destacar que los cambios que se realizan en los archivos solo son rastreados por Git después de haberlos agregado al área de preparación (staging area) y haber hecho un commit. Además, es recomendable escribir mensajes descriptivos y concisos en cada commit para mantener un historial claro y entendible del desarrollo del proyecto.
.

• Crear un archivo o modificar uno existente en el directorio raíz donde se hizo el git init.
• Agregar los cambios al área de preparación con el comando git add <archivo> o git add. Para agregar todos los archivos modificados en la carpeta.
• Realizar un commit con el comando git commit -m "mensaje de commit" para guardar los cambios en el historial del repositorio.
• Repetir los pasos 2 a 4 para cada cambio que se quiera agregar y rastrear en el repositorio.
  .

Dejar de rastrear archivos

En ocasiones, no queremos rastrear algún archivo que agregamos al repositorio. Para dejar de rastrearlo, debemos sacarlo del área de preparación, lo que significa que los cambios en el archivo ya no se incluirán en el siguiente commit.
.
Los pasos son los siguientes:

1. Utiliza el comando git rm --cached seguido del nombre del archivo que deseas dejar de rastrear. Por ejemplo, si deseas dejar de rastrear el archivo archivo.txt, deberías escribir el siguiente comando:

git rm --cached archivo.txt

1. Ejecuta el comando git status para ver el estado del repositorio. Deberías ver que el archivo archivo.txt se ha eliminado del área de staging.
2. Realiza un commit para guardar los cambios. Utiliza el comando git commit -m seguido de un mensaje descriptivo que explique los cambios realizados. Por ejemplo:

git commit -m "Dejar de rastrear el archivo.txt"

😄😄😄😄😄

• Un programador novato crea un repositorio de Git para su proyecto de fin de curso, pero se olvida de añadir el archivo .gitignore y sube todos sus archivos temporales y contraseñas al repositorio público.

• Una pareja de desarrolladores decide usar Git para gestionar su relación amorosa. Cada uno tiene una rama propia donde puede hacer cambios sin afectar al otro. Pero cuando intentan fusionar sus ramas, se encuentran con muchos conflictos y tienen que resolverlos manualmente.

• Un hacker malicioso crea un repositorio de Git falso que parece contener el código fuente de una aplicación popular. Cuando los usuarios curiosos clonan el repositorio y ejecutan el código, se infectan con un virus que les roba sus datos personales.

• Un fanático de Star Wars crea un repositorio de Git para su fanfic sobre la saga galáctica. Su primer commit es una introducción donde explica que su historia es una versión alternativa donde Luke Skywalker se une al lado oscuro y Darth Vader se redime.

• Una empresa de software usa Git para gestionar sus proyectos internos. Su primer commit es un archivo README.md que contiene las normas básicas de colaboración, como usar mensajes descriptivos, seguir el estilo de código y hacer revisiones periódicas. Sin embargo, nadie lee el archivo y pronto el repositorio se convierte en un caos.

Comparto mis apuntes en el formato Notas de Cornell

Un consejo que nadie pidio pero que todos necesitan
La metodologia para aprender en platzi. Esta es basada en el ecoding, tecnica de estudio que nos recomienda el coach en aprendizaje Justin Sung.
(Identifica si es importante y el nivel de dificultad)

1. Tendencias Index
   a. Video 2.0X
   b. Aplica el ecoding high order learning (no
   memorices ni comprendas, relaciona, compara y
   organiza)
   b. Idenfitica los puntos claves
   c. Simplificalos en menos puntos que englocen todo.
2. Aprendizaje Atopico (Revision rapida mutliples fuentes)
   a. Revision del Foro
   b.Revision toda las fuentes
   b.Aplica Ecoding high order learning
   c. Organiza la informacion dentro de tus puntos
   claves del index
3. Comprension y aplicacion practica
   a. Video 1.0X
   b. Enfocate en comprender ahora si
   c. Aplica cada cierto tiempo durante la clase.
4. Diseño Sistema de Organizacion
   a. Crea un esquema que simplifique la clase
   b. Expresa los puntos claves
   c. Utiliza simbolos o ilstraciones
   d. SIMPLIFICALO AUN MAS
5. Revision para la recuperacion
   a. Usa active recall y spaced repetition
   b. El ecoding te permitira revisar pocas veces el
   contenido
   c. Revisa tu esquema
   d. Resuelve un proyecto asignado por ti mismo.
   Espero les funcione…

Me siento muy orgullo de mi primer commit, en verdad

Holaaaa a todos les dejo mis apuntes 😄

Datos✍🏻

📌 Cambios atómicos

Significa que cada cambio se guarda de manera independiente

Notas 📒

✏️ Crear un repositorio

Ir a la carpeta del proyecto, por ejemplo en el desarrollo web es donde está el archivo index.html.
Estando en ella se ejecuta git init . Esto crea una carpeta oculta llamada .git adentro de ella está la base de datos que registrará todos los cambios atómicos.

✏️ Abrir VSC desde la terminal

Ejecutar el comando code

También se pude colocar el nombre del archivo a crear, por ejemplo: code miHistoria.txt

Del mismo modo si hay un archivo que deseas abrir con VSC ejecuta code nombreArchivo

✏️ Añadir/quitar archivos a staging area

Añadir con git add nombreArchivo o git add . añadiendo todo lo de la carpeta actual.

Para quitar un archivo se ejecuta git rm --cached archivo o para quitar todos git rm -r --cached * (el atributo -r se coloca para aquellos archivos que estén en subcarpetas)

✏️ Configurar git para commits

Con git config se imprime las opciones de configuración que tiene git

Con git config --list se imprime las opciones actuales de git. 💡 Si te muestra la con otra interfaz a la de la clase, ejecutar de este modo git config --list | cat

Con git config --list --show-origin se muestra la ruta de donde se encuentran los archivos de configuración.

Para agregar nuestro nombre y correo (y así poder ejecutar un commit) se ejecuta: git config --global user.name "Tu nombre" y git config --global user.email "Tu correo"

✏️ Ejecutar commit

Se ejecuta git commit -m "Mensaje relevante"

✏️ Ver historial de commits

Se ejecuta git log

Cada commit muestra esta información:

Les comparto mis notas de la clase

Hasta ahora esto es lo que yo sé de git, ¡de aquí en adelante todo será nuevo!

Para empezar tenemos que saber que es un repositorio y un commit.
ㅤㅤ
Un repositorio es una base de datos de nuestro proyectos, es decir el conjunto de datos que conforman el proyecto.
ㅤㅤㅤㅤ
Un commit son los cambios en uno o mas archivos en nuestro proyecto.
ㅤㅤ
Para crear un repositorio vamos usar git init.
ㅤㅤㅤㅤㅤㅤ
Para añadir archivos a nuestro proyecto vamos a usar git add.
ㅤㅤ
Para ver el estado de nuestro repositorio usamos git status.
ㅤㅤㅤㅤ
Cuando hagamos un cambio en nuestros archivos usamos git add <nombre_del_archivo> para que git pueda registrar sus cambios.
ㅤㅤ
Luego para hacer el commit usaremos git commit -m "<Descripción>" y se añadirá.

A la hora de ejecutar

git status

me daba el error fatal: not a git repository (or any of the parent directories): .git .

Lo pude solucionar con ejecutando el comando

git init

Espero que les funcione.

Hola, si tienen problema con los directorios que tienen espacios, por ejemplo: "Curso de Platzi"
lo que pueden hacer para entrar a este directorio con el git Bash es hacer lo siguiente:
ejemplo: cd ‘Curso de Platzi’ y listo, el uso de las comillas les ayudara a entrar en archivos que tengan espacios.

Buenas. A mí no me funciona a la hora de hacer commit.

Esto es lo que me sale una vez lanzo el comando commit más el mensaje editable.

$ git commit -m ´´Este es primer commit de este archivo´´
error: pathspec ‘es’ did not match any file(s) known to git
error: pathspec ‘primer’ did not match any file(s) known to git
error: pathspec ‘commit’ did not match any file(s) known to git
error: pathspec ‘de’ did not match any file(s) known to git
error: pathspec ‘este’ did not match any file(s) known to git
error: pathspec ‘archivo´´’ did not match any file(s) known to git