Introducción a Git

1

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

2

¿Qué es Git?

3

Instalando Git y 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 y los repositorios? Ciclo básico de trabajo en Git

11

¿Qué es un 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

Cambios en GitHub: de master a main

19

Uso de GitHub

20

Cómo funcionan las llaves públicas y privadas

21

Configura tus llaves SSH en local

22

Conexión a GitHub con SSH

23

Tags y versiones en Git y 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

Git Stash: Guardar cambios en memoria y recuperarlos después

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits viejos al head de un 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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Introducción a las ramas o branches de Git

15/43
Recursos

Las ramas son la forma de hacer cambios en nuestro proyecto sin afectar el flujo de trabajo de la rama principal. Esto porque queremos trabajar una parte muy específica de la aplicación o simplemente experimentar.

La cabecera o HEAD representan la rama y el commit de esa rama donde estamos trabajando. Por defecto, esta cabecera aparecerá en el último commit de nuestra rama principal. Pero podemos cambiarlo al crear una rama (git branch rama, git checkout -b rama) o movernos en el tiempo a cualquier otro commit de cualquier otra rama con los comandos (git reset id-commit, git checkout rama-o-id-commit).

Cómo funcionan las ramas en GIT

Las ramas son la manera de hacer cambios en nuestro proyecto sin afectar el flujo de trabajo de la rama principal. Esto porque queremos trabajar una parte muy específica de la aplicación o simplemente experimentar.

  • git branch -nombre de la rama-: Con este comando se genera una nueva rama.

  • git checkout -nombre de la rama-: Con este comando puedes saltar de una rama a otra.

  • git checkout -b rama: Genera una rama y nos mueve a ella automáticamente, Es decir, es la combinación de git brach y git checkout al mismo tiempo.

  • git reset id-commit: Nos lleva a cualquier commit no importa la rama, ya que identificamos el id del tag., eliminando el historial de los commit posteriores al tag seleccionado.

  • git checkout rama-o-id-commit: Nos lleva a cualquier commit sin borrar los commit posteriores al tag seleccionado.

Aporte creado por: Carlos Eduardo Diaz

Aportes 760

Preguntas 192

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Dejo esto por aquí. Nota relacionada a la clase:

¡Nunca pares de aprender! (Y practicar)🦄

Comparto mis apuntes.

Slds!

Un comando super útil que estuve utilizando mucho últimamente es:

git checkout -b "nombre_rama"

Este comando es una fusión entre “git branch” y “git checkout”, y su funcionamiento es el siguiente:
- Crea una rama llamada “nombre_rama”
- Hace un checkout de la rama “nombre_rama”


Hola, comparto esta imagen ilustrativa que indica los distintos movimientos de Git checkout y las variantes de Reset 😃

Lo vi dos veces, la primera para entender la teoría, luego lo hice por mi cuenta y volví a ver el material para confirmar que estuviera igual 😄
Les comparto como quedó mi css

Mi resultado
![](``
body
{
color: darkcyan;
text-align: center;
font-family: Arial;
font-size: 18px;
margin: 0;
padding: 0;
}
#container
{
width: 50%;
padding: 1em;
border-bottom: 3px solid #fafa;
border-right: 10px solid #FFF233;
border-left: 10px solid #33BEFF;
border-top: 3px solid #FF8533;
text-align: center;
margin: 0 auto;

}```

y Este es mi HTML

<!DOCTYPE html>
<html lang="en">
    <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″ />
<head>
    <title>Maryjose Cobos</title>
    <link rel="stylesheet" href="CSS/estilos.css">
</head>
<body>
    <div id="container">
        <div id="cabecera">
            Cabecera
        </div>
       <div id="post">
            <h1>Hola Comunidad Platzi</h1>
            <p>Esta es mi pequeña contribución, tratando de hacerlo solo un poco diferente para practiar mi HTML y CSS</p>
        </div>
    </div>
</body>
</html>

Aporte

En visual studio code y en otros editores si escriben:
div#cabecera y presionan tab
El resultado es:
<div id="cabecera"></div>

el Head es como el ojo de Sauron, con cheakout tu le indicas donde ver.
$ git checkout Frodo

Freddy me hizo aprender en 10 minutos lo que no aprendí en meses de universidad jajajaja

Para los que quieren tener mas funciones en la terminal en Mac, aqui esta iTerm muy popular, permite personalizar muchas cosas, ademas de mostrar por defecto cosas como las que menciona Freddy como el lugar en donde estamos con el branch.

https://www.iterm2.com/

En ubuntu o distros linux deribados de Debian, recomiendo usar Oh My Zsh para poder tener mejor visibilidad de los comando y ramas de Git

Hola dejo las notas relacionada a la clase.

Hora de aprovechar la cuarentena

## Ramas

Las ramas son la forma de hacer cambios en nuestro proyecto sin afectar el flujo de trabajo de la rama principal. Esto porque queremos trabajar una parte muy específica de la aplicación o simplemente experimentar.

git branch -nombre de la rama-: Con este comando se crea una nueva rama.

git checkout -nombre de la rama-: Con este comando puedes saltar de una rama a otra.

git checkout -b rama: Crea una rama y nos mueve a ella automáticamente, Es decir, es la combinación de git brach y git checkout al mismo tiempo.

git reset id-commit: Nos lleva a cualquier commit no importa la rama, ya que identificamos el id del tag., eliminando el historial de los commit posteriores al tag seleccionado.

git checkout rama-o-id-commit: Nos lleva a cualquier commit sin borrar los commit posteriores al tag seleccionado.

Que bonito es entender jajajaja

No se desilusionen si no entienden mucho, vean el curso de Terminales para acostumbrarse a la terminal (que suele ser el problem de muchos)

Estoy viendo cada vídeo nuevamente, y aportando en las discusiones. Es increíble lo bien que se siente practicar y aprender en serio Git. No solamente se dejen llevar por el diploma o certificados, piensen que de esto vivirán o crearán grandes proyectos.

$git commit -am “mensaje” nos permite agregar y hacer commit al mismo tiempo.

Incluso para la terminal de WSL en Windows pueden instalarle zsh y oh-my-zsh junto con cualquier otro theme o plugins.

El tema que viene por defecto es suficiente para cuando están trabjando con Git. Pero pueden probar algunas como Pure o Spaceship

También funciona para Linux y Mac.

De esta manera cuando cambien de rama sabrán en cuál están y podrán están más confiados de viajar en el tiempo.

Para ver mejor las ramas prueben a escribir:

  • git log --graph
    o para que sea más bonito:
  • git log --graph --pretty=’%Cred%h%Creset -%C(auto)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset’

PD: Con el plugin git de oh my zsh solo tienes que escribir en el terminal **glgg **para la primera forma y glol para la segunda (Para mi es mi favorita).

Estos son mis apunte:

Tambien revise la documentacion de ramas de git https://git-scm.com/docs/git-branch para ver que mas opciones se tienen con las ramas

La primera ves que vi esto, casi lloro de emoción, realmente es increíble las cosas que facilita esto.
Se siente como una escuela de magos, donde freddy es el brujo supremo, explicando la magia de git, a novatos.

excelente me gusto mucho esta clase, tuve que parar miles de veces el vídeo. para poder anotar y ponerlo en practica. y darme cuenta al momento alguna inquietud, incluso tuve que retroceder varias veces porque cuando le daba al ($ git show) no encontraba como salir de ahí y cerré varias veces. porque no supe salir viendo tanto el vídeo escuche la Q jajajajaja fue lo máximo, lo bueno que tenia que hacer todo de nuevo porque cerraba todo y asi agarraba mas de practica, me encanto. y me quedo en la mente la Q. jajajaja

![](

Excelente clase para la explicación de Ramas (Branches) de Git, por acá comparto el articulo de la documentación oficial de git en donde se habla también del tema.
Nota: Hay un comando que nos permite realizar la creación de una rama y cambiarnos inmediatamente a ella. El comando es

git checkout -b <nombre-rama>

En donde reemplazamos <nombre-rama> por el nombre de la rama que queremos crear.

Con:

git checkout -b <NOMBRE_DE_LA_NUEVA_RAMA>

Además de crear la rama, hacemos “checkout” a ella, es decir, quedamos cambiados a esa rama automáticamente.

checkout significa “Revisar” por lo que tiene mucho sentido que hacer checkout a un commit o branch sea cambiar a el para ir a revisarlo.

Comparto mis apuntes con ustedes 😄

-** git commit -am** --> es lo mismo que hacer un git add y git commit -m fusionados, lo unico que hay que tener en cuenta es que solo funciona cuando lo que hacemos es modificar archivos, si hemos agregado nuevos archivos no nos vale , tendríamos que hacer git add o git add . y luego git commit.

¿No te funcionan las tiles correctamente? Agrega ese meta tal cual y te funcionarán 😄

HEAD apunta al commit más reciente de la rama en la que estoy trabajando.

Esta es la cuarta vez que veo esta clase, y de verdad esta vez sí la entendí perfectamente.
Practicar, practicar, practicar, practicar. Esa es la clave !!!

Si queremos crear una rama y movernos directamente a ella, podemos usar:

git checkout -b cabezera

¡Espero les sea útil!

Si ves esto al inicio de la clase, por favor hazlo igual que yo, para practicar! Haciendo le ejercicio me puse de pro-activo y copie el html y el css desde el inicio… pues resulta que eso ya estaba listo y no me di cuenta, entonces en el master me quedo la cabecera… Me toco hacer un reset hard del commit en el master, irme a cabecera, hacer el add y el commit y asi medio dejar el ejercicio mas o menos como el de Freddy. Siento que de verdad estoy aprendiendo! aunque al principio me daba pereza el curso, esta gennial!!!

  • git commit -am “MENSAJE” = agrega y manda el mensaje es deciar hace el git add y git commit -m , este solo aplica para archivos ya existentes en el repositorio
  • git branch “nombre de la rama” = se crea la rama teniendo en cuenta que uno se debe de posicionar en la rama que se necesita copiar.
  • git checkout “nombre d ela rama” = aqui se cambia la rama que se le indico

Genial, ahora comienzo a ver las ventajas de GIT… No imaginan la sonrisa que me salió cuando cambiamos de la rama cabecera y pasamos a la rama master y vi que ya no estaba la cabecera, la cabeza casi me estalla pensando todo lo que uno puede hacer con eso, pruebas, nuevas funcionalidades, ajustes!!! y todo eso sin estar duplicando el proyecto, sin tener mil carpetas regadas en el computador y luego sin saber exactamente donde esta todo. Wow 😃

con el comando:

git checkout <nombre rama> 

podemos ingresar a las ramas que tenemos creadas, un método que me permite volver directamente a la rama master en digitando

git switch -
``

Si escribes git branch unicamente sin pasar algún nombre te lista todas las ramas que tienes disponible en el “working directory” y tu rama actual tiene un color de fuente diferente diferenciandose de las demás.

Para instalar zsh en linux utilice los siguientes comandos:

>sudo apt-get install zsh
>sudo apt-get install git-core
>wget https://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | zsh
>chsh -s `which zsh`

y luego reiniciar la terminal

git checkout nos permite desplazarnos entre las ramas creadas por git branch. Al ejecutar la operación de cambio de rama, se actualizan los archivos en el directorio de trabajo.

Si solo ponen $ git branch les va a mostrar todas las ramas que existen y a marcar con un * en cual rama se encuentran.

Estuve leyendo un poquito sobre los branches, y eso es lo que diferencia a git de todos, las ramas son formas elegantes de hacer cambios.

Otra forma de ver la ramas, no sé si sea una buena práctica.
Comenten 😃

Los comandos básicos más utilizados Git, http://www.7sabores.com/blog/git-comandos-basicos

Les dejo el enlace del libro Pro Git https://git-scm.com/book/es/v2 para que lo tengan como libro de consulta

Tambien existe para poder cambiar las ramas en las que estamos posicionados siendo creado como una “mejor forma” de trabajarlas sin embargo cualquiera de las 2 hace el trabajo, siendo asi les dejo este apartado que tiene informacion al respecto

git swtich branchname 

Checkout es el comando que se utiliza para moverse entre diferentes ramas / branches

Les comparto:

_git commit -am: _ git add, git commit -m, aunque solo sirve para archivos a los que se le había hecho add previamente, es decir, archivos que viven en stage area.

Para crear una rama:

  1. Se crean las modificaciones al archivo y se guardan.
  2. También se guardan en la rama master (_git commit -am _)
  3. Se crea la rama nueva con el comando _git branch <nombre de la rama> _(el último commit, está mapeado en la nueva rama)
  4. Ahora, nos movemos a la rama nueva con git checkout <nombre de la rama>
  5. Disfrute su nueva rama (:
  • Las ramas son la forma que tenemos para efectuar cambios sin alterar el master.
  • Antes de cambiar de rama es necesario hacer commit para no perder los cambios hechos.
  • El HEAD es un indicador del commit en el que nos encontramos actualmente, al cambiar de ramas el head también cambia respectivamente.
  • $ git commit -am efectúa un commit en los útlimos cambios en archivos sin tener que ejecutar $ git add

Un pequeño repaso de los comandos:
-**git commit -am “Mensaje”: **Con esto podemos agregar los archivos a nuestro repositorio local si ya han sido trackeados previamente.
-**git branch nueva-rama: ** Podemos crear una nueva rama
-**git checkout -b rama: **Creamos una nueva rama y de forma automáticamente le aplicamos el checkout a esta.
-**git reset id o git checkout rama-o-id-commit: **Para posicionarnos el Head en la rama especificada

Para ver el nombre de la cabecera en ubuntu 16.04 basta con instalar la última versión estable de Git con los siguientes comandos:

# add-apt-repository ppa:git-core/ppa 
# apt update
# apt install git

con el superlog te deja ver en donde esta apuntando el header

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"

Si tengo archivos que ya habia creado y agregado al repo previamente, y estoy agregando nuevos cambios para ellos puedo hacer:

git commit -am "mensaje"

De esta manera pueden crear una rama nueva y hacer checkout al mismo tiempo, muy útil cuando quieres desplegar un parche que parte desde la última versión de master, por ejemplo:

git checkout -b <branch_name>

Freddy tiene caligrafía de Google Fonts :p

Muy chingona la clase, en serio. Gracias.

Me siento como cuando de niño veía un mago y me dejaba boquiabiertado XD
Ahora Freddy es el mago y yo sigo siendo el niño.
Otra estupenda clase @freddier

Como borrar una rama de nuestro repositorio loca?
git branch -d “Nombre de cabecera”

---- me toco borrar esta rama y repetir esta clase, porque tuve problemas en las siguientes dos clases
😃

Si solo pones $git branch , te aparecerán todas las ramas que tiene tu repositorio

Existen dos maneras de hacer ramas o branches:
Como lo mencionó Freddy:

git branch cabecera

git checkout cabecera

Pero hay otra manera de de realizar esos dos pasos en un solo comando:

git checkout -b cabecera

Este último comando genera la rama y automáticamente te envía a esa rama.

Tambien encontre un tema para git bash, creo que es mas comoda la visualizacion de ramas con el. (Tema powerline-multiline)

▲Documentacion
---->https://github.com/Bash-it/bash-it
▲Vistas previas de tema
–>https://github.com/Bash-it/bash-it/wiki/Themes
▲Instalacion
–>https://youtu.be/wUihwgB9fBc

git commit -am “Mensaje del commit” Agrega sólo los archivos que ya han sido seguidos previamente

Maravilloso

Esto es fascinante, había oido de control de versiones pero no sabía que se podía tener tanto control y orden como una rama, y no vamos ni a la mitad.

no olviden usar la letra “Q” para salir de un proceso de listado en la terminal.

Freddy Presidente ✌️

Que super genial estuvo esta clase, me gustó un montón, que bien se siente saber cambiar de ramas jajajaja.

Solo para recordar, comandos git usados hasta ahora:

git init~iniciar git
git status~estado actual de git
git add “archivo”~añadir el archivo al repositorio local de git
git rm “archivo”~eliminar el archivo del repositorio local de git
git rm “archivo” --cached~eliminar el archivo del repositorio local y del área de staging
git rm “archivo” --force~eliminar el archivo de git y del disco duro
git commit -m “mensaje”~guardando los cambio que estan en el staging
git config~ver como configurar git
git config --list~la configuracion actual de tu git
git config --list --show-origin~la configuracion actual de tu git con la ruta en tu equipo
git config --global user.name~cambiar el nombre en git
git config --global user.email~cambiar el email en git
git log “archivo”~historial de commits sobre el archivo
git log --stat~historial de commits y cambio en el proyecto
git show “archivo”~cambios realizados sobre el archivo
git diff tagId1 tagId2~diferencia entre los commits
git diff~diferencia entre lo que esta en staging y lo cambios realizados
git reset tagId --hard~devolver a ese commit
git reset tagId --soft~devolver a ese commit, manteniendo el staging
git reset HEAD~sacar archivos del área de staging
git checkout tagId “archivo”~devuelve los cambios aplicados en archivo hasta el commit indicado
git checkout rama “archivo”~devuelve el archivo al estado actual en la rama
git branch -m new-name~cambiar el nombre de una rama

Aquí dejo para el que quiera reforzar un poco más.

https://learngitbranching.js.org/?locale=es_ES

Espero que les sirva!

Hola! Acá se puede practicar ‘git branching’ de manera muy divertida:

https://learngitbranching.js.org

Espero a alguien le sirva!

Hola Comunidad! El día de ayer vi la pregunta de un compañero que decía algo así: ¿Se pueden crear varias ramas en base a una rama master? Otros compañeros de la comunidad habían respondido que efectivamente puedes crear las ramas que desees.
.
Esto trajo otra pregunta a mi mente: ¿Cuántas ramas como máximo se pueden crear en un repositorio git?
.
Estuve indagando y pude encontrar estos dos interesantes conceptos:

  1. Git es un sistema escalable. Es decir está preparado para soportar el uso de un gran número de ramas.
  2. Las ramas y demás referencias como los tags por ejemplo, no son nada más que archivos o registros en archivos dentro de otros archivos en la carpeta .git. Para más detalle puedes revisar qué son las referencias.

.
Basándonos en el punto 2 podemos inferir que el máximo número de ramas que git puede permitir no depende de alguna configuración límite dentro del sistema git sino depende de la capacidad del sistema de archivos de nuestro sistema operativo y la capacidad de almacenamiento del que disponga nuestro equipo o el servidor que aloje tal cantidad de ramas.
.
Pero, acaso lo que acabo de decir no plantea otra pregunta: ¿Por qué o en qué casos se deberían crear cantidades exageradas de ramas?
.
Aquí me topé con diferentes casos, algunos más coherentes que otros sobre el hecho de trabajar con cantidades elevadas de ramas sin embargo esto me llevo a leer sobre “plantillas” para crear ramas de un repo git con la finalidad de tener todo organizado para los desarrolladores.
.
Según lo que leí es preferible mantener en el servidor (tu propio server o GitHub) como máximo tres ramas:

  1. Una rama para código estable: Código testeado y listo para producción.
  2. Una rama para código inestable: Código del próximo lanzamiento de la versión.
  3. Una rama mantenimiento: Correcciones de errores de versiones previas.

.
De tal manera que los developers (1, 10 o 1000 devs) puedan crear la cantidad de ramas locales que deseen pero al momento de subir su trabajo lo hagan a cualquiera de las 3 ramas de esta plantilla, según corresponda.
.
Quizá lo que se indico pueda parecer evidente, sin embargo, yo no lo tenía tan claro hasta que me di a la tarea de hacer una revisión un poco más profunda. Lo comparto para los que hayan tenido la misma duda que yo.
.
Si ven que existen errores en algo o todo lo que escribí me lo hacen saber, así aprendemos todos.
.
Saludos!

Con el sólo comando ‘branch’

git branch

Pueden ver que ramas (branches) tienen y señala con un asterizco la rama en la cúal están posicionados.

Les recomiendo mucho estudiar una estructura de datos llamada árboles, ellos usan apuntadores para cada uno de los nodos, los nodos donde está el head se llaman hojas, y así, ese linus torvalds creo git con c, de eso estoy seguro.

Descripción del HEAD

git branch
Este comando lista las ramas creadas en el proyecto, la rama activa se distingue por tener un " * "

Freddy, gracias por explicar como de ser

el curso me sorprende mas y mas, el manejo de ramas y versiones sin tener mas archivos, es excelente

Llegué para aprender Java, pero este curso de Git me parece muy practico ya que el termino es muy escuchado, pero desconocía todo acerca de este; que herramienta tan practica, y sin duda alguna los branches son una forma de organizar mejor el programa manteniendo cada uno de los cambios por separados.

git log --stat // Muestra cuantos cambios fueron realizados al archivo
git brach NombreRama // Crea la rama
git checkout NombreRama //Cambias a la rama deseada

cada vez se va poniendo el curso más bueno

Excelente curso, definitivamente estaba usando mal el “GIT”.

Excelente clase. Me queda una pregunta, cual sería la diferencia entre usar git checkout y git switch para cambiar entre ramas? gracias!

Que locura las ramas, me esta volando la cabeza! jaja

Muy Claro!!

“Cuando uno crea una rama lo que uno hace es básicamente crear una copia del último commit en otro lado y todos los cambios que hagamos durante esta rama no los va a ver la rama master hasta que no la volvamos a funcionar en un proceso que se llama merge”. Freddy Vega.

Muy buena explicación 😄

git checkout -b [nombre_rama]: Nos permite crear una nueva rama sin necesidad de usar branch

Esta es una de mis clases favoritas del curso, cuando generas ramas de tu proyecto 😊👌

Con el comando git checkout -b RAMA_NUEVA creamos una rama nueva y automáticamente hacemos checkout a esta.

Tengo conocimientos básicos de esto pero lo que he visto hasta ahora me hubiece evitado varios conflictos con los que he lidiado, ps con lo visto hasta aquí veo que es mejor trabajar con ramas de desarrollo y luego con un merge acoplar los cambios y pruebas realiazdas a la master me gusta, me gusta, me gusta…

que clase de brujeria es esta xD, esta muy bueno este tema de ramas, en si todo el curso ha estado genial

Alucinante! Me esta encantando el curso. Un potencial tremendo tiene esto!

Introducción a las ramas o branches de Git
Las ramas son la forma de hacer cambios en nuestro proyecto sin afectar el flujo de trabajo de la rama principal. Esto porque queremos trabajar una parte muy específica de la aplicación o simplemente experimentar.

La cabecera o HEAD representan la rama y el commit de esa rama donde estamos trabajando. Por defecto, esta cabecera aparecerá en el último commit de nuestra rama principal. Pero podemos cambiarlo al crear una rama (git branch rama, git checkout -b rama) o movernos en el tiempo a cualquier otro commit de cualquier otra rama con los comandos (git reset id-commit, git checkout rama-o-id-commit).

Tengo “oh-my-zsh” pero cuando uso comandos como git log o git status nuca me sale (HEAD -> master) como a Freddy. Alguien sabe configurar estos comandos para saber en que rama ocurren las modificaciones?

ProyectoGit (cabecera)➤ git log                                        
commit dd5aa156255ff8aa755922170ec6d50d23b793f4
Author: Santiago Huertas <huertas****************>
Date:   Thu May 2322:15:202019-0500

    estructura inicial de la cabecera

commit 78c8179a5ee019b8304cbc8cf74cbdeb000387bd
Author: Santiago Huertas <huertas****************>
Date:   Thu May 2320:56:282019-0500

Comparto las ideas que más resaltaron para mi en este video 😃 :

  • Master es una rama principal, pero podemos crear otra con "git branch ‘NombreDeLaRama’ ".
  • Puedo moverme entre ramas con el comando "git checkout ‘NombreDeLaRama’ ".
  • HEAD es un indicador de cual versión de commit estoy viendo de los últimos archivos.
  • con “git status” podemos comprobar ver en que rama estamos ubicados y si tenemos commits pendientes por realizar.
  • "git commit -am ‘mensajeAEnviar’ " = "git add ‘NombreArchivo.extensión’ " + "git commit -m ‘comentario’ "

estas clases si que requieren su tiempo para procesar todo