Git fundamental - Aprende lo importante desde cero

Este curso de Git te enseña de manera sencilla cómo usar la herramienta profesionalmente así como el portal Github
4.4 (32 ratings) Instead of using a simple lifetime average, Udemy calculates a
course's star rating by considering a number of different factors
such as the number of ratings, the age of ratings, and the
likelihood of fraudulent ratings.
451 students enrolled
$19
$20
5% off
Take This Course
  • Lectures 24
  • Length 2.5 hours
  • Skill Level All Levels
  • Languages Spanish
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 9/2014 Spanish

Course Description

Cientos de estudiantes satisfechos han tomado este curso especialmente diseñado para principiantes y le han dado 5 estrellas de promedio y excelentes reviews:

  • "Acabo de finalizar el curso, lo recomiendo 100%."
  • "Es de los temas que cualquier desarrollador tendría que saber y Jorge lo explica muy bien!"
  • "Claramente explicado y de una forma muy simple y agradable."

Inscríbete ya y aprende Git de una vez por todas y conviértete en un desarrollador completo.


Git se ha convertido en el sistema más importante y fundamental para el desarrollo de cualquier tipo de aplicación. Gracias a que es totalmente gratis y con el respaldo de la comunidad open source, ningún desarrollador, ingeniero en computación o gerente de proyectos debe ignorar este conocimiento. Git permite tener mejor control sobre el proyecto, facilita la cooperación entre miembros del proyecto y se convierte en un método avanzado de respaldo.

Este curso te introduce, desde el nivel más básico y a través del poder del video, los fundamentos de Git desde cómo instalarlo hasta cómo usar las herramientas avanzadas y el portal Github.

Si buscas en internet, puedes encontrar cientos de cursos, videos y otros recursos gratis, pero es un trabajo increíblemente tedioso y deja más dudas que respuestas. En este curso podrás aprender, de manera sencilla y sin saltos, los conceptos de Git, desde lo más básico hasta lo más avanzado junto con una comunidad de estudiantes que están aprendiendo el mismo concepto. Adicionalmente los instructores responden las preguntas que tengas en cada lección si te quedas atascado en cualquier lugar del curso.

El curso está dividido en 6 secciones:

  • Introducción
  • Fundamentos de Git
  • Repositorios remotos
  • Ramificaciones en Git
  • Herramientas de Git
  • El portal Github

El curso cuenta con más de dos horas de video tutoriales y material de soporte en casi todas las lecciones. Puede completarse en un día pero es más óptimo tomar cada lección y luego practicar los conocimientos, así que una semana es el tiempo óptimo para completarlo (una sección por día). Sin embargo el material es tan completo, que estamos seguros que volverás una y otra vez a revisar los temas fundamentales.

Adicionalmente, estamos actualizando el curso constantemente, añadiendo lecciones gracias al feedback de nuestros estudiantes.

También tendremos Google Hangouts donde podrás preguntar al instructor cualquier pregunta que tengas sobre el curso o sobre Git en general.

What are the requirements?

  • Un computador con acceso al internet y acceso administrativo para instalar paquetes
  • Un conocimiento básico de cómo usar el internet y editores de texto

What am I going to get from this course?

  • Podrás iniciar un repositorio Git de un proyecto existente o clonar un proyecto que exista en Internet.
  • Tendrás un entendimiento fundamental de cómo manejar repositorios remotos.
  • Sabrás la teoría y el por qué son importantes las ramificaciones (branches).
  • Aprenderás sobre las herramientas de Git como stash y cherry-pick.
  • Verás una introducción al portal Github.

What is the target audience?

  • Programadores, desarrolladores de software, gerentes de proyecto
  • Estudiantes de computación
  • Aficionados al desarrollo de software

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Introducción
05:14

¿Qué es Git?
Git es un sistema de control de versiones

¿Qué es el control de versiones, y por qué debería usarlo?
El control de versiones es un sistema que registra los cambios realizados sobre un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante.

Ventajas de usar control de versiones

  • Es un método de respaldo
  • Revisión histórica
  • Facilita la Colaboración

Secciones del curso

  • Fundamentos de Git
  • Repositorios remotos
  • Ramificaciones (branches)
  • Herramientas
  • Portal Github

Sobre el instructor

  • 15 años liderando equipos de desarrollo web en Nueva York
  • Trabajado para empresas grandes e incipientes (startups)
  • Apasionado sobre nuevas tecnologías de aprendizaje

Tipos de sistemas de control de versiones

  • Local
  • Centralizado
  • Distribuído

¿Es Git mejor que otras herramientas similares?

  • Distribuido
  • Más control sobre la historia
  • Mejor manejo de ramas
  • Guardar provisionalmente tu trabajo
Quiz Sección 1
3 questions
Resumen de la Sección 1
Article
Section 2: Fundamentos de Git
El ciclo de los archivos
03:14
Instalando Git
00:18
07:55

Dirígete en Internet Explorer o navegador similar a la dirección: http://git-scm.com

Utiliza las opciones pre-configuradas.

El programa Git Bash en Windows es una utilidad que permite usar Git exactamente de la misma manera que usas Git en computadoras Linux/Unix.

La mejor manera de usar Git es a traves del terminal Git Bash.

Puedes correr Git Bash desde la opción de “Programas > Git > Git Bash”.

Comandos para manejo de directorios y archivos en Git Bash
ls = permite ver los contenidos del directorio en donde estás en este momento. Cuando empiezas Git Bash, por lo general estás en lo que se llama tu “Home Directory” o el directorio inicial del usuario. Generalmente es representado con una señal de tilde “~”.

mkdir <directorio> = permite crear un directorio con el nombre que pongas a continuación. Es preferible solo usar letras, sin espacios ni acentos. En nuestro ejemplo, creamos el directorio de prueba que llamamos “testgit”, escribiendo mkdir testgit.

cd <directorio> = permite cambiar al directorio que escribas. Puedes usar el nombre de cualquier directorio que veas listado en el comando “ls” (descrito arriba).

Para verificar que tienes Git instalado, escribe “git” en el terminal y para ver la versión de Git que tienes instalada, escribes git --version.

05:05

*** Nota Importante ***
Si estás en el sistema operativo “Mavericks” (Mac OSX 10.9), y has instalado herramientas de desarrollo de Xcode, es posible que ya tengas Git. Antes de instalar verifica si lo tienes instalado abriendo el terminal (“Command” + “Space” + “Terminal”) y escribe el comando “git”. Si te sale un error, prosigue con esta lección. Si te salen los comandos de Git, verifica que la versión sea por lo menos 2.0, haciendo “git --version”. Si tu versión es anterior a 2.0, prosigue con esta lección.

Dirígete en Safari o navegador similar a la dirección: http://git-scm.com

Luego de bajar el paquete, tienes que abrirlo presionando la tecla de “control” y haz click al paquete, y selecciona la opcion “Abrir” o “Open”. Esto es necesario, ya que Git es un paquete que bajas directamente de la web y las Mac no permiten abrir paquetes que no sean bajados por su aplicación de paquetes oficial.

La mejor manera de usar Git es a traves del terminal de Mac. Para abrir el terminal, puedes oprimir la tecla de “command” y la barra de espacio a la vez. Esto abrirá el “Spotlight” que es una herramienta de búsqueda. Si escribes “terminal”, veras el programa terminal con una pantalla negra como ícono. Haz click para abrir el terminal.

Una vez en el terminal, escribe el comando “git” y presiona “enter”. Si te salen los comandos de Git, estás listo para continuar.

Si te sale un error de que no se encontró Git, tendrás que modificar tu configuración de perfil, y decirle manualmente al sistema operativo dónde conseguir Git.

Para ello edita tu perfil, usando la herramienta de edición de texto “vi”.

Escribe vi ~/.profile. Esto te abrirá el editor. Presiona la tecla “i”, para insertar texto, mueve el cursor al final del archivo y presiona “enter” para darle más espacio y luego escribe: export PATH=$PATH:/usr/local/git/bin

Luego le das a la tecla de “esc” y escribe “:wq” (dos puntos, la letra “w” y la letra “q”) y le das a “enter”.

Finalmente cierra el terminal (en la opción de menú “Terminal > Quit Terminal” o haciendo “command” + “q”). y vuelve a abrirlo con “command” + “space” y poniendo “terminal” en la búsqueda y seleccionando la aplicación.

Una vez dentro del terminal, escribe git y verifica que te salen los comandos de Git.

04:28

Aquí están los links a los editores de código recomendados en la lección:

Mac
- Textmate (pagado)
- Sublime Text (pagado pero con uso ilimitado gratis)
- Atom (gratis)
- TextEdit (gratis con la Mac)

Windows
- Notepad++ (gratis)
- Sublime Text (pagado pero con uso ilimitado gratis)
- Atom (gratis)
- Notepad (gratis con Windows)

18:35

Comandos para manejo de directorios y archivos en el terminal ó Git Bash
pwd = te dice el directorio seleccionado en este momento

ls = permite ver los contenidos del directorio en donde estás en este momento. Cuando empiezas Git Bash, por lo general estás en lo que se llama tu “Home Directory” o el directorio inicial del usuario. Generalmente es representado con una señal de tilde “~”. Si quieres ver todos los directorios y archivos, incluyendo los escondidos (que empiezan con “.”) pones “ls -a”.

mkdir <directorio> = permite crear un directorio con el nombre que pongas a continuación. Es preferible solo usar letras, sin espacios ni acentos. En nuestro ejemplo, creamos el directorio de prueba que llamamos “testgit”, escribiendo mkdir testgit.

cd <directorio> = permite cambiar al directorio que escribas. Puedes usar el nombre de cualquier directorio que veas listado en el comando “ls” (descrito arriba). Si quieres salir al directorio anterior, escribes “cd ..” (cd y dos puntos seguidos). Si quieres ir rápidamente a tu directorio inicial de usuario, o “Home folder”, puedes escribir “cd ~” (“cd”, espacio y el signo de “tilde”).

clear = permite limpiar la pantalla.

Comandos de Git
Git init = inicializa un directorio y lo convierte en un repositorio Git. Al inicializar el repositorio, Git crea un directorio escondido llamado “.git” dentro del nivel principal del directorio. Aquí Git guarda información sobre el repositorio.

Antes de hacer cualquier operación, debemos configurar nuestro usuario. Para ello le decimos a Git nuestro nombre y nuestro correo electrónico, haciendo lo siguiente:

git config user.name "Jose Diaz”
git config user.email "jose@example.com"

Esto solo guarda esta información en el repositorio actual. Si quieres que Git use siempre la información en cualquier repositorio, puedes usar el parámetro “global”, escribiendo:

git config --global user.name "Jose Diaz”
git config --global user.email "jose@example.com"

Git status = nos da información sobre el estado actual de nuestro repositorio.

En la clase utilizamos el editor de código Atom, que es un proyecto de Github, y que es totalmente gratis y funciona con Windows, Mac y Linux. Para bajarte Atom, dirígete a https://atom.io/.

Git add <archivo o lista de archivos> = permite añadir un archivo nuevo o uno modificado a la lista de archivos preparados (“staging”) para la próxima instantánea. Recuerda que si un archivo que está en preparación es editado, sale de esta lista y pasa al área de “modificados”, por lo tanto no será incluído en la próxima instantánea, ya que Git piensa que todavía estás trabajando con él. Cuando termines tu trabajo en ese archivo, haz “git add” de nuevo a ese archivo.

Git commit -m “<mensaje”> = te permite crear una instantánea con todos los archivos en el área de preparación y con un mensaje. Cualquier archivo en estado “modificado” no será incluído. Es muy importante escribir un mensaje que sea completo describiendo qué cambios se están introduciendo.

Cada instantánea tiene un identificador único llamado “hash”. El hash tiene por lo general letras y números y con ese identificador puedes recuperar el estado del proyecto en ese momento.

Operaciones básicas visualizadas
Preview
03:35
12:38

Git log te permite ver las instantáneas del proyecto en orden descendiente.

Cada línea tiene un identificador de tipo SHA1.

Cuando haces git log, puede ser que entres a una ventana separada que es parte de una utilidad llamada “less” que permite leer contenido. Usando las teclas de flechas hacia arriba y hacia abajo, puedes leer el historial. Para salir de esa ventana, le das a la tecla “q”.

Si no quieres usar “less”, y en vez usar “cat”, que muestra los contenidos en el mismo terminal, puedes entrar el siguiente comando:
git config --global core.pager cat

Para mostrar diferencias entre instantáneas, puedes usar:
git log -p

Si quieres ver sólo las últimas “n” confirmaciones, puedes usar:
git log -<n>

Para ver una versión abreviada de los commits, puedes usar:
git log --oneline

Para ver una representación visual de las ramas, puedes poner:
git log --graph

Si quieres ver el historial de instantáneas controlando las fechas, puedes usar:
git log --since=2.days (ver commits desde hacen 2 días)
git log --since=2.weeks (ver commits desde hacen 2 semanas)
git log --since=”2014-09-12” (ver commits desde septiembre 12 del 2014)
git log --after=”2014-09-12” (ver commits después de septiembre 12 del 2014)
git log --until=”2014-09-12” (ver commits hasta de septiembre 12 del 2014)
git log --before=3.days (ver commits antes de 3 días)

Para ver las contribuciones de un usuario específico escribe:
git log --author=”Juan Perez”

Finalmente, puedes combinar cualquiera de estos parámetros, ejemplo:
git log -3 --oneline --before=2.days

Para ver todas las opciones disponibles para log, puedes escribir:
git help log

Para ver cómo se veía el repositorio en cualquier instantánea, se usa:
git checkout <hash>

Donde “hash” corresponde al identificador.

No es recomendable hacer cambios al proyecto en este estado de “Detached head” o cabezal desprendido. Sin embargo es totalmente válido arrancar una nueva rama de este estado.

09:54

Para mover un archivo de un directorio a otro, o para renombrarlo se usa:
git mv <origen> <destino>

Ejemplo, si queremos renombrar un archivo foo.txt a bar.txt, se usa:
git mv foo.txt bar.txt

Si queremos mover una fotografía llamada foo.jpg de un directorio a otro:
git mv fotos/foo.jpg imagenes/foo.jpg

Para eliminar un archivo, se usa:
git rm <archivo>

Para ignorar ciertos archivos, como archivos temporales o generados automáticamente, se crea un archivo llamado .gitignore en el nivel superior del directorio del repositorio.

El .gitignore usa patrones para reconocer tipos de archivos. Para una guía de estos patrones, puedes leer aquí.

Finalmente para ver las diferencias entre nuestro trabajo actual y una instantánea específica, puedes hacer:
git diff <SHA1>

También pueden chequear si tienen la herramienta gráfica, utilizando:
gitk

13:41

Para cambiar cualquier archivo o texto de confirmación después de hacer commit, podemos usar:
git commit —amend

Por lo general esto comenzará el editor de texto “vi”, que es un editor incorporado. Puedes cambiar el editor que se use, con el comando:
git config --global core.editor <editor>

Si usas “vi”, recuerda que puedes mover el cursor a donde quieras con las flechas del teclado. Luego le das a la tecla “i” para entrar al mode de insertar, haces los cambios, y luego le das a la tecla “escape” y escribes dos puntos, la tecla “w” y la tecla “q”.

Si quieres sacar a un archivo o a un grupo de archivos del área de staging, haces lo siguiente;
git reset HEAD <file>

Esto pondrá el archivo de nuevo en el área de modified.

Si quieres desechar los cambios de un archivo en el que estábamos trabajando y queremos devolverlo al estado en el que estaba en la última instantánea, entonces haces:
git checkout — <file>

Si quieres desechar todos los cambios que has hecho localmente desde la última instantánea, utiliza:
git reset HEAD --hard

Si quieres desechar el último commit y regresar al repositorio como estaba en la anterior instantánea, escribes:
git reset HEAD^ --hard

Quiz Sección 2
4 questions
Resumen de la Sección 2
Article
Section 3: Repositorios remotos
04:58

Git te permite trabajar con repositorios remotos utilizando varias utilidades que veremos en esta sección.

La primera herramienta es:
git clone <url> <directorio>

Git clone copiará todo el código que haya en ese URL a tu computador y toda la historia del proyecto, es decir, las instantáneas y las ramas que tenga disponible. El código será copiado en el directorio que elijas, y si no pones un directorio, lo pondrá en un directorio con el mismo nombre del proyecto.

Esta operación es la base de todo el movimiento “Open Source”, ya que cualquier desarrollador en el mundo puede colaborar con cualquier proyecto que le sea útil, encontrando “bugs” o haciendo mejoras.

04:47

Para gestionar repositorios remotos, se usa el comando git remote.

Para ver todos los repositorios remotos que tiene un proyecto, escribes:
git remote -v

Un proyecto puede tener múltiples repositorios remotos asociados.

Para ver los detalles de un repositorio remoto, usamos:
git remote show <nombre del repositorio>

Para añadir un repositorio remoto, pones:
git remote add <nombre> <url del repositorio remoto>

Nombre es el nombre que le pondrás al repositorio. Por lo general se usa “origin” si es el repositorio remoto principal.

Para renombrar un repositorio usamos:
git remote rename <nombre anterior> <nombre nuevo>

Finalmente, para borrar un repositorio remoto, usas:
git remote rm <nombre>

12:37

Hay tres operaciones importantes en el manejo de repositorios remotos.

La primera, git fetch, solo agarra los datos, pero no aplica los cambios localmente que se han bajado. El formato es:
git fetch <nombre repositorio remoto> <rama remota>

Puedes omitir el parámetro de la rama remota si quieres bajarte todos los cambios disponibles.

Para aplicar los cambios a tu repositorio local, usas:
git merge origin master

Para obviar este paso intermedio, se puede usar un sólo comando, que es git pull. El formato es:
git pull <nombre repositorio remoto> <rama remota>

Puedes obviar el nombre de la rama remota y te halará los cambios de la rama “master”.

Para empujar código de nuestro repositorio local al remoto, usamos:
git push <nombre repositorio remoto> <rama remota>

Quiz Sección 3
3 questions
Resumen de la Sección 3
Article
Section 4: Ramificaciones en Git
09:22

Las ramas son básicamente diferentes versiones de un proyecto que viven en tu repositorio. Por ejemplo, la rama “master” puede ser la versión que está al aire en tu website, pero tendrías otra rama llamada “en-desarrollo” que es donde tu equipo está desarrollando código que no está estable.

Para crear una rama, utilizas:
git branch <nombre de rama>

Para cambiarte a esa rama, usas:
git checkout <nombre de rama>

Para incorporar los cambios de una rama dentro de otra, hacemos primero un checkout a la rama a donde van a entrar los cambios y usamos:
git merge <rama a incorporarse>

Finalmente, para borrar una rama, hacemos:
git branch -d <nombre de rama>

Quiz Sección 4
3 questions
Resumen Sección 4
Article
Section 5: Herramientas de Git
Herramientas de Git: git stash y git cherry-pick
04:38
Quiz Sección 5
2 questions
Resumen Sección 5
Article
Section 6: El portal Github
Introducción al portal Github
03:57
Section 7: Conclusión
Conclusión
00:20
Guía de Git
13 pages

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Jorge Escobar, Tecnólogo, emprendedor y fanático del mundo del open source

Desde Cero es un proyecto educacional creado por Jorge Escobar, un tecnólogo, emprendedor y fanático del mundo del open source con más de 15 años de experiencia en el desarrollo de aplicaciones web en Nueva York.

Jorge ha trabajado en empresas de gran reconocimiento como Yahoo!, Univision y MongoDB, y ha sido tecnólogo fundador en varias empresas incipientes (startup) que han obtenido varias rondas de inversión de capital.

El problema más grande que Jorge ha experimentado durante su carrera ha sido el de conseguir desarrolladores capacitados, y entrevistó a cientos de ellos para posiciones en los equipos que lideraba. Pero un patrón constante (sin importar si venían de una buena universidad o con años de experiencia) era la falta de conocimientos prácticos.

Para ello Jorge creó Desde Cero -- para crear un proyecto de capacitación que llenara esos huecos prácticos con los conocimientos que necesitan los desarrolladores de hoy en día para poder tener éxito en las empresas de tecnología de avanzada.

Ready to start learning?
Take This Course