Transcripciones
1. Introducción: Hola y bienvenidos al curso de Git y
GitHub para principiantes. En este curso
aprenderás los conceptos básicos de tanto get como peaje y GitHub es
un software que podemos usar. Aprenderás muchas características de ambas tecnologías por igual. Comandos que obtienen oye
o páginas de GitHub y las herramientas de escritorio de GitHub para
facilitar la gestión de nuestros proyectos. Al final de este curso, obtendrá los conocimientos
necesarios para comenzar a utilizar
ambas tecnologías. A medida que aprenderás
los conceptos centrales de repositorios, ramas y ramificación y
divergencia de código junto al
trabajo que vamos a hacer, también verás diferentes presentaciones como
deseo ilustrar para ti, cómo funcionan las desviaciones de código y cómo
se deben manejar también esas. Pero ahora, ¿quién soy yo? Mi nombre es Stefano matter, cuyo fin tengo
más de siete años de experiencia en desarrollo
web. También soy instructor en línea. Y al lado de este
curso puedes encontrar muchos otros cursos de
mi parte aquí en Skillshare. Así que asegúrate de echar un vistazo a
esos también. Si te gustaría ver más tutoriales fuera
de Skillshare, siempre
puedes visitar mi canal de YouTube ahí
encontrarás muchos tutoriales, cursos de
choque, y todo proyecto para varios diferentes
tecnologías. Y si te gustaría
ponerte en contacto conmigo, siempre
puedes visitar
mi página web allí. Puedes leer más sobre mí, pero también ver todos mis tutoriales y
cursos en un solo lugar. Ahora bienvenidos una vez más, y aprendamos más sobre
las versiones de código y código.
2. Versiones de código y código: Antes de comenzar el curso, me gustaría
hablar del código sí y de las versiones de código. Verás que como desarrolladores
desarrollaremos, construiremos e implementaremos sitios web estándar, aplicaciones, aplicaciones móviles
y software también. Todo eso requiere código y veces no solo una
persona trabajando en él, sino muchos de nosotros en equipos pequeños y
más significativos. Ahora, ¿te imaginas solo diez personas trabajando
en la misma aplicación? Cuán difícil puede ser para
ellos solo compartir el código más reciente
conservando la calidad
de esa aplicación. Junto a eso, a menudo
trabajarán en múltiples tareas, múltiples características y correcciones de errores. Es decir, cuando
necesitamos cuidar nuestro código y versiones
del mismo también. Para ello, podemos utilizar software, un producto que puede
rastrear nuestros cambios de código, mantener nuestras versiones de código, dividir las en la dosis de
fusión como deseemos. Son muchos de ellos, pero en este curso, aprenderemos a usar Git
en combinación con GitHub. Y hablaré más de
los en el siguiente video. Pero, ¿qué podemos obtener
de dicho software? Bueno, ahora ese mismo equipo de diez personas puede igualar versiones de código de
manejar más fáciles. Por ejemplo, cada
miembro del equipo puede usar similar, tal vez incluso el mismo
código y construir sobre él. Cada persona de ese
equipo puede trabajar en una tarea específica o
corregir un error en particular. Una vez terminado, el propio sistema fusionará
todos esos cambios juntos. Y si hay alguna
inconsistencia en el código,
el sistema atrapará esos y presentará esos conflictos
a los miembros del equipo. Por lo que podrían juntos
dosis fija y no mucho al
respecto también. Ahora, aprendamos más
sobre tal sistema. Veamos qué es bueno
y qué es GitHub.
3. ¿Qué es Git & Github: Ahora lo que nuestro Git
y GitHub, bueno, se
consiguen en sí es un software que nos
ayuda a rastrear los
cambios de nuestro código. Junto a llamar a los cambios, git engañará a todos los demás
cambios en nuestros archivos. Entonces si agregarías una
imagen a nuestro proyecto, consíguelo lo sabrá. Ahora consigue el
objetivo principal es asegurar la colaboración y coordinación
entre desarrolladores. Junto a esa puerta
también nos apoyará con la integridad de los datos de velocidad
en la distribución
para nuestros proyectos. Ahora, GitHub es
esencialmente un proveedor. Nos proporciona la publicación
para el desarrollo de software, lo que significa que ahora nuestros cambios de código y código
podrían hospedarse en GitHub. Junto a eso, el GitHub nos
apoyará con controles de
versión. Y lo hace
usando Git como herramienta. Entonces esencialmente podemos
usar git para administrar nuestras versiones mientras también usamos
GitHub para presentarlas, para verlas en vivo. Github
nos dará la plataforma para ver nuestro proyecto, nuestro código, y todos nuestros
cambios junto a eso, GitHub tendrá otras
características que podamos usar, pero este no es el
foco de este curso. Por ahora, nos estamos centrando solo
en las versiones de código y código. Y la mejor manera de aprender sobre el GitHub es comenzar a
trabajar con él. Entonces antes de lo
siguiente el video, por favor hazme un favor. Ir a un
sitio web oficial de GitHub. Asegúrate de registrarte si ya tienes una
cuenta en GitHub, esto no es una tarea para ti. Pero si no
tienes una cuenta, asegúrate de crear una, dar seguimiento a
este curso muy bien. Ahora, vamos a instalar eso, conseguir.
4. Instalación de Git: Obtener como herramienta debe ser instalado. Para instalar Git,
simplemente puede buscar para obtener su navegador preferido o
visitante Get-SCM.com sitio web. También tendrá el enlace a este sitio web en los
recursos de este curso, el sitio web en sí podría ser una excelente referencia para
aprender sobre buen fin. Es tuyo porque el bien
tiene su documentación. Pero estamos aquí para descargar la puerta para que
podamos instalarla. Para descargar Git. Haga clic en este botón de descargas. Esto debería llevarte a
la página de descargas. En aquí puedes simplemente seleccionar una opción para tu propio sistema. Para mí,
seleccionaré Windows aquí. Para Windows,
escucharé múltiples opciones. Pero la
opción bastante buena para mí es estos instaladores independientes
para un sistema de 64 bits, tu sistema podría ser diferente, así que asegúrate de seleccionar
el correcto aquí. Una vez finalizada la descarga, simplemente
podemos ejecutarla y la instalación para ello debe
ser bastante sencilla. En este primer paso, sólo tienes que seleccionar el siguiente. Ahora, deberíamos ver
diferentes componentes aquí. Así que sólo ve a continuación aquí también. Esta aquí es una nueva opción en entidades de
instalación para
seleccionar cómo usar OpenSSH. Así que no te molestes demasiado
con eso. Por ahora, solo puedes seleccionar
estas opciones preseleccionadas. El siguiente paso podría ser complicado, pero instalar nos dará
la versión regular de Git. Espere a que se instale ahora. Y una vez terminado, podemos desseleccionar el bot a Opciones y simplemente hacer clic en Finalizar. Ahora, sí tengo una carpeta que preparé para este
curso, la puerta. También puedes crear el
tuyo propio para que puedas mantener todo el curso en
un solo lugar, si así lo deseas. Haz clic con el botón derecho en esta carpeta, deberías estar
obteniendo opciones para buen gooey y Git Bash. Ambas herramientas se instalaron también
con la puerta. Para que puedas abrir cualquiera de esos o también puedes abrir tu terminal de
sistemas. Para ser honesto, realmente no
importa. Lo que quieres hacer
en tu terminal se utiliza el comando
de la buena versión. Si las puertas de enlace se instalan correctamente, debe ver la
versión instalada, que es buena. Si no hay versión, deberá repetir
todo el proceso de instalación. Además, el desvío puede
diferir de la mía aquí dependiendo de cuando
estés viendo este curso junto a
la buena versión, puedes usar el comando del bien, que debería mostrarte
los diferentes comandos que podemos usar
con una buena herramienta. Y muy pronto comenzaremos a
usar estos comandos. Ahora sobre las herramientas que
se instalaron con buenas, si abrieras Git GUI, verías una herramienta que
pudiera gestionar nuestros repositorios. Y hablaremos más
de esas doloridas. Si abrieras Git Bash, verías un terminal
específico para conseguir esta terminal funcionará con tu sistema y otros tours
si tienes algunos instalados. Pero junto a eso también
puedes usar tu propio terminal estándar
si estás acostumbrado a ella. Y esto se trata del proceso
de instalación. Por lo que ahora podemos empezar a
trabajar con él. Visitemos GitHub en nuestro
próximo video y
creamos nuestro primer proyecto,
nuestro primer repositorio.
5. Creación de un primer proyecto (Repo): ¿ Recuerdas que te
pedí que crearas tu propia cuenta de GitHub
si no tienes una. Bueno, espero que lo hicieras. Eso, ¿ahora vamos a trabajar
con GitHub inicia sesión en tu propia cuenta de GitHub y
entra en este tablero principal. Bueno, tu perfil donde
deberías ver tus proyectos. Obviamente, si tu
cuenta se acaba de crear, no
tendrás ningún proyecto. Bueno, cualquier repos aquí. Ahora, asegúrate
también de abrir esto, póngante aquí también. Queremos usarlo, pero deseo mostrarte
algo con él. Ves esto Gui puede
manejar nuestro repost. Podemos crear los repos locales o utilizar algunos
reportes externos también. Haremos lo mismo por nosotros,
pero nos dará más opciones y una interfaz de usuario de aspecto más amigable. Y en este video,
crearemos nuestro primer repositorio. En primer lugar, ¿cuál
es el repositorio? Un repositorio o un repositorio es lugar
centralizado para
nuestro código y activos. Entonces si deseamos construir un
sitio web o la aplicación, tener un repositorio para
tal proyecto sería
prudente porque el repositorio
es un prudente porque el repositorio lugar centralizado para nuestro código. Eso significa que
podremos gestionar nuestras versiones grabadas
en ella directamente. Entonces por deuda verás
cómo este conjunto de herramientas, Git y GitHub, podría ser
útil para nosotros. Ahora para crear el informe, tendrá este ícono plus
en la esquina superior derecha. Simplemente haga clic en él y seleccione
este nuevo repositorio. Crea un nuevo repositorio. Necesitaríamos
configurarlo para nosotros. En primer lugar,
necesitaremos un nombre para nuestro repositorio. Es vital nombrar a tu repositorio de
forma única con tu cuenta. Como no se puede tener dos
repos con los mismos nombres. Nombraré mi
repo primer proyecto que puedas llamar el tuyo como desees. Lo siguiente que podríamos
agregar es nuestra descripción, pero este campo también es opcional, por lo que simplemente lo saltaré por ahora. La siguiente opción es establecer nuestro repositorio para que sea
público o privado. Si lo pones a público, bueno, todo el mundo lo verá. Privada estará
disponible solo para ti, terminan personas que invitas. Entonces si planeas construir
algo así como un código abierto, el público es una buena opción. Si bien la
opción privada es más para personal y proyectos
en producción, pondré el
informe de la mente para ser público como
deseo que todos ustedes puedan acceder a estos tres por
cada vez que quieran. Junto a eso,
agregaré este archivo léeme, pero saltaré este archivo de
puntos gitignore. Readme es el archivo que nos
sirve para describir nuestro repositorio e
información adicional y así sucesivamente. Si bien este
archivo gitignore que
leemos, podremos ignorar
algunos de nuestros archivos, lo que significa que esos
archivos no serán rastreados, no serán empujados a
nuestro repositorio más tarde. Pero en este punto, simplemente
puedo crear mi repositorio. Una vez que hayas creado tu reporte, verás estos pasos para obtener este repositorio localmente
en tu máquina, lo que significa que ahora puedes
intentar hacerlo por tu cuenta. Pero en el siguiente video, vamos a clonar nuestro
informe juntos.
6. Clonando El Repo: Tenemos nuestro repositorio para
nuestro proyecto ahora. Podemos clonar para conseguir nuestro
repositorio localmente en nuestra máquina. Quiero que te metas en tu
perfil en GitHub e
ingreses esta sección de repositorios aquí deberías ver todos
tus repositorios. Así que asegúrate de seleccionar el
que creaste
para este curso. Para mí, es este primer
proyecto en mi repositorio. No veo mucho. Sí escucho mi
archivo readme y puedo ver el contenido de ese archivo
ReadMe a continuación. Almacenaremos todos los
archivos que creamos una actualización aquí
dentro de nuestro repositorio, ya que este será nuestro
lugar central para nuestro proyecto, somos capaces de crear
archivos directamente aquí, pero este no es tal
experiencia amistosa. Por lo que vamos a tirar de nuestro
repositorio para tenerlo localmente ya que será mucho más fácil trabajar
con él de esa manera. El comando para eso
se llama clone, ya que vamos a clonar nuestro
repositorio de GitHub a nuestra máquina local para
usar ese comando clone. Si bien eso es bastante sencillo, lo primero que tenemos que
hacer es hacer click en
esto, este botón verde, que nos
abrirá un menú. En este menú, asegúrese de
seleccionar la opción HTTP S, que nos presentará
esta URL. Url es la
URL oficial de nuestro repositorio. Para que puedas copiarlo o hacer clic en este ícono del
lado derecho para copiar esta URL. Ahora, abre tu terminal y decide la ruta a
la carpeta que desees. Bueno, donde quieras
almacenar tu repo, tengo una carpeta de bien, así que voy a usar comando de CD, llegar a entrar a esa carpeta si
necesitas ir hacia atrás la carpeta usa dot-dot slash o slash para nuestra carpeta actual. Una vez que estés dentro de tu carpeta, revisemos de nuevo si bien
se instaló correctamente. Para que puedas usar aquí el comando
GET para eso. Como puedo ver, todos
estos comandos, puedo estar seguro de que
efectivamente se instaló correctamente. También, en esta lista de comandos, puedo ver el comando clone. Y describe
que clonará el repositorio en
un nuevo directorio. Por lo que necesitamos este comando. Aquí. Voy a usar comando clear, bueno para limpiar mi terminal. Y ahora puedo usar git clone y pegar mi URL para mi repositorio
que copiamos anteriormente. Golpea Enter y
espera a que brilla. Una vez terminado, puedo usar CD first dash project para meterme dentro de mi repositorio
que acabo de clonar. Podemos ver que este comando sí funcionó porque estoy dentro
de mis primeros proyectos. Pero al lado de mi ruta de carpeta aquí, puedo ver este maestro, luego la flecha, luego origen. Esto aquí se refiere a una sucursal, y hablaremos más
de ellos un poco más adelante. Ahora, también
pondré mi carpeta donde se almacena
mi repositorio para
revisar el contenido en su interior. Bueno, parece que tengo mi archivo README que fue
creado por defecto, y sé que también tengo el archivo en mi repositorio
en GitHub. Por esto aquí podemos confirmar que nuestro repositorio fue clonado
con éxito. Antes de terminar e iniciar
el siguiente video, necesitarás algo
llamado editor de código. Se trata de un software donde
usualmente escribiremos nuestro
código y hay muchas opciones por ahí para ti que puedes usar
si deseas usar
el mismo a la vez usando código de
visita, que
Visual Studio.com. Este editor de código es
del propio Microsoft, y es de código abierto, lo
que significa que es de uso gratuito. Así que solo asegúrate de descargar e instalar la versión correcta
para tu sistema operativo. A partir del siguiente video, utilizaremos tal herramienta.
7. Realizar cambios y seguimiento: Ojalá haya instalado Visual
Studio Code ya que lo necesitamos. Ahora, asegúrate de abrir tu directiva de proyecto en
este código de Visual Studio. Antes de empezar. Solo por mencionar que
tu código de Visual Studio puede parecer diferente al mío. Ya que probablemente tenga
más extensiones instaladas y también equipo
diferente. No necesitas preocuparte
porque éste para bloquearte de
seguir las puntuaciones. Como clonamos nuestro repo en el último video dentro
de tu proyecto aquí, deberíamos ver sólo
este archivo léeme. Si abres este archivo, deberías ver algún contenido
escrito en lenguaje de markdown, que no es un
lenguaje complejo de aprender. Lo bueno de este
Visual Studio Code es que podemos usar el
terminal directamente dentro. De esa manera, podemos escribir
nuestro código mientras también manejamos nuestro repositorio para
abrir el terminal aquí, haga click en esta Ver y luego
tendrá la opción
para la terminal. Vamos a ver si todo
funciona aquí como mostró. Utilizaré el comando de
clear para despejar esta terminal. Ahora usaré Git
y luego status. Status, o status
es un comando que nos
dará el último
estatus de nuestra sucursal, que
actualmente estamos trabajando. Y como mencioné, hablaremos más de las
sucursales en el futuro. Aquí podemos ver que nuestra sucursal es maestra y todo
está actualizado, que significa que
sacamos todos nuestros últimos cambios cuando
clonamos nuestro repositorio desde GitHub. Para aclarar más, nuestra directiva local es
la misma directiva, mismo repositorio que tenemos en
nuestro GitHub, lo cual es bueno. Pero ahora cómo Git
sabe de esto, verás get es una herramienta
que rastrea nuestro código. Por lo que sabrá de nuestros
cambios que también realizamos. Por ejemplo, si deseo
crear un archivo para mi sitio web, normalmente ese archivo se
llama index.html. Para ello, simplemente haga clic en este nuevo icono de archivo y el
nombre de su archivo index.html. Visual Studio Code
es lo suficientemente inteligente como para colorear este archivo en un verde. ¿ Por qué hace eso? Bueno, el código de Visual Studio sabe
que lo bueno es rastrear
nuestros cambios aquí. Y ahora este expediente es un
cambio que hicimos. Entonces nuestra directiva local ya
no es lo mismo que nuestro repositorio, como nuestro repositorio que
tenemos en GitHub. También podemos comprobar eso
con GitHub también. En esta terminal, podemos volver a
usar un comando, git status. Y ahora deberíamos ver
unas salidas diferentes. Todavía muestra que
nuestro lado local, nuestra sucursal local que
tenemos está al día, pero muestra más. Muestra que tenemos algunos archivos no rastreados
en los cambios de pista, lo que significa que hay diferentes archivos de
nuestro repositorio de GitHub. Y es por
este index.HTML. Tenemos este index.html localmente, pero no en un GitHub. Y conseguir esto en absoluto, sabrá de estos cambios pesar de que esos cambios aún
no son rastreados. Entonces incluso si la gente
eliminara estos cambios, no pasaría nada crucial. El siguiente a eso, nos
da info, bueno, información sobre cómo
rastrear adecuadamente estos archivos con bien, que es la historia de
la siguiente conferencia.
8. Comprometer cambios: Para continuar donde nos
detuvimos en el último video, ahora
tenemos nuestro cambio
en nuestro directorio, pero ese cambio no está
siendo rastreado por Git que todos se conozcan de este cambio, pero aún no está rastreando
ese cambio, lo que significa que el cambio en
sí no terminará en nuestro repositorio para hacer un
buen seguimiento de nuestros cambios. Bueno, debemos hacerlo manualmente. Bueno, para todos los
nuevos expedientes, al menos. Para hacer tal cosa,
primero limpiaré mi terminal. Ahora puedo usar git add
y luego podemos especificar un archivo que deseamos
rastrear, como nuestro index.html. Esto agregará nuestro
archivo para rastrear archivos. Pero, ¿y si tuviéramos
diez expedientes diferentes? Todavía deseamos sumar uno por uno. Bueno, en lugar de
pasar un nombre de archivo, simplemente
podemos usar un punto
aquí que agarrará todos nuestros cambios no rastreados
y los moverá al tracto. Será una especie de
escenario esos cambios. Ahora, vamos a usar git
status una vez más. Aquí lo que podemos ver es que nuestro archivo HTML índice ya no es
rojo sino verde. Esto significa que bueno
Ahora rastrea este archivo, pero esto sigue en
nuestra máquina local, nada relacionado con
nuestro repositorio principal que tenemos en GitHub. Para que el repositorio principal
sepa sobre nuestros cambios. Debemos almacenar, bueno, debemos cometer esos cambios. Donde cometamos
esos cambios, bueno, esos estarán listos para ser publicados en nuestro repositorio
principal. Para hacer tal cosa, debemos usar este comando llamado git commit. A este comando commit, podemos pasar esta bandera, que puede especificar
con el dash m. bandera significa un mensaje, lo que significa que
después de esta bandera, también
podríamos pasar algún mensaje. Para pasar un mensaje, debes usar comillas dobles y generalmente ve este tipo de mensajes para especificar a qué se refieren
nuestros últimos cambios. Para mí, estableceré mi
mensaje para estar creando el archivo HTML de índice porque
hicimos exactamente eso. Ahora que hemos
comprometido nuestro código, un cambio que podemos ver en nuestro Visual Studio Code es que este archivo index.html ya no
es verde. Es porque get se refiere
a ella como atraer archivo, pero sin ningún cambio nuevo. Y no tenemos ningún cambio nuevo porque
todos los cambios que hicimos ya están comprometidos y listos
para ser desplegados. Si desea
confirmar tal cosa. Una vez más, podemos volver a
usar git status. Ahora podemos ver un mensaje que
dirá que nuestra sucursal, mientras que nuestra
sucursal local es jefe de nuestra sucursal maestra desde nuestro
repositorio por un commit, si visitarías
tu repositorio en GitHub. Bueno, nada
cambió ahí es porque nuestros cambios
estaban todos encendidos localmente, en nuestra máquina local. Y esa es la
razón por la que git nos dirá que nuestra sucursal local está por delante de nuestra sucursal master
en nuestro repositorio principal. Y sí, sí rastreamos nuestros cambios y también
comprometimos nuestros cambios, pero aún así no
implementamos esos a GitHub. Y para desplegarlos, lo
haremos en la
siguiente conferencia.
9. Código de empuje: Como viste, nuestros cambios ahora
son rastreados y comprometidos, pero aún no en nuestro repositorio de
GitHub. Para desplegar nuestros cambios en GitHub, debemos empujar nuestro código y sí, término se llama push
así como el comando. Entonces en mi terminal puedo simplemente
usar comando de buen push. El resultado de este
comando contendrá la información sobre nuestros cambios de
post y así sucesivamente. Pero esto no es tan importante
ya que en su mayoría es automatizado. Pero en este punto, si visitaríamos nuestro
repositorio en nuestro GitHub, deberíamos ver el
archivo index.HTML junto a nuestro archivo
léeme también. Esto significa que
nuestros últimos cambios se
desplegaron con éxito en nuestro repositorio. Y también en esta esquina
superior derecha, podemos ver que
tenemos dos commits. Si lo desea. Incluso se puede hacer click en esos commits para verlos, podemos ver, por ejemplo,
nuestro compromiso inicial. Bueno, ese fue nuestro
primer comité cuando creamos nuestro repositorio. Y para mí,
también puedo ver este cometa aquí donde agregué
el archivo HTML. Aquí, incluso podríamos
entrar en este compromiso. Puedo ver aquí este archivo
HTML vacío que se agregó, que fue el cambio en sí. Ahora, ¿cómo
sabe Git de nuestros cambios? ¿ Cómo sabe nuestros commits son los archivos rastreados
y no rastreados? Y cómo conectó también nuestro repositorio de GitHub a nuestro
repositorio que tenemos localmente. Bueno, déjame mostrarte cómo
funciona Git en un fondo
para hacer eso, entra en tu directorio que
tienes localmente en este menú Ver, debes seleccionar
estos archivos ocultos. Uno de esos archivos ocultos es esta carpeta llamada
The Dark good. Ya verás cuando clonamos
nuestro repositorio desde nuestro GitHub, la carpeta vino con
ese repositorio también. Y como tenemos esta buena herramienta
instalada en nuestra máquina, sabe trabajar
con esta carpeta. Entonces en esta combinación, bolt nos permitirá trabajar con nuestro repositorio y rastrear
todos nuestros cambios. Pero aún así, todo esto es bonito y bastante fácil de manejar
cuando estás solo. Pero cuando tienes más gente en tu equipo y estás
trabajando de cerca juntos, bueno, trabajar solo en esta rama maestra
puede ser bastante agitado. Así que déjame mostrarte cómo
puedes crear otra sucursal.
10. Crear una nueva sucursal: Ahora volveré a entrar en la terminal
principal que usan. Aquí el plan es
crear otra rama. Para crear la sucursal, podemos usar git checkout. Git checkout es el
comando que se utiliza para revisar nuestras
diferentes ramas. Si solo usamos este comando, tendríamos una opción para
pasar de rama a rama. Pero como deseo
crear una nueva rama, puedo pasar un guión B. Esta es una bandera que representa una rama al lado de esta bandera. También debemos pasar aquí
otro argumento, y ese es el
nombre de nuestra rama. Bueno, las marcas
que deseas
hacer para eso un
poco de ayuda aquí. Intenta nombrar siempre tus sucursales Por el futuro que estás trabajando
actualmente. Y esa sería una convención de
nomenclatura estándar para las sucursales. Como deseo agregar algún contenido HTML a
mi archivo HTML por delta, nombraremos el contenido HTML de mi
sucursal. Una vez que envíes tu comando, puedes ver que ahora
mi sucursal ya no está dominada,
sino contenido HTML. Incluso si visitara
mi Visual Studio Code en
la esquina inferior izquierda, puedo ver el
contenido HTML como una sucursal. Por esto aquí se puede ver que
Visual Studio Code es
lo suficientemente inteligente como para reconocer en qué sucursal estamos trabajando
actualmente. Solo por mencionar que en
tu terminal puedes incluso usar un comando
llamado git branch. Este comando te
dará la lista de sucursales para tu repositorio
actual. Para mí aquí, sí tengo
sólo dos sucursales y estas destacadas sucursal es mi sucursal actual en la que
estoy actualmente. Ahora, vamos a crear algún contenido
HTML para eso. Abre el archivo HTML del índice
y usa HTML dos puntos cinco aquí. Al usar la deuda, bueno, automáticamente
crearemos algún código HTML, y esta es solo
otra característica, solo otra gran cosa
sobre Visual Studio Code. Ahora, en este código HTML, en el cuerpo de mi HTML, agregaré una etiqueta H1, que dirá Hola mundo. Entonces podríamos tener al
menos parte
del contenido por esto aquí, ya que tenemos este contenido HTML, podemos asegurarnos desplegar estos contenidos
a nuestro repositorio. Para eso,
abriré mi terminal en Visual Studio Code y
usaré el comando git status. Aquí podemos ver que index.HTML, nuestro archivo es rojo, lo
que significa que
es archivo modificado, pero los cambios aún no se ponen en
escena, bueno, no rastreado, se vende para poner en
escena estos cambios, necesitaré usar git
add y luego eso. Ahora de nuevo, podemos
usar git status para confirmar que nuestros cambios
fueron apropiadamente etapa. Junto a la puesta en escena de nuestros cambios, también
debemos
comprometer nuestros cambios. Y para hacer eso, usaré git commit con el mensaje
específico. Mi mensaje dirá, agregando contenido a un archivo HTML. Como última cosa, necesitamos empujar este código
que creamos a nuestro repositorio. Así que aquí ahora no podemos simplemente
usar el comando git push porque GitHub actualmente no
sabe de nuestra rama que
creamos localmente, porque esta
rama de contenido HTML es mi sucursal local. Todavía no está en GitHub. Entonces necesitaré asegurarme de
que la próxima vez que cambie, también empuje mi sucursal
directamente en GitHub. Para ello,
usaré el comando git, push than dash u flag. Y después de eso usaré palabra clave
Origin y luego
el nombre de mi sucursal, que es contenido HTML. Con este comando, estableceremos la corriente ascendente para
nuestra rama remota, y crearemos la
misma rama en nuestro GitHub, que será un poco
la rama de origen de nuestra sucursal local. Ahora en nuestro GitHub, podemos ver que se creó la nueva
rama. Aun si altero este
desplegable por ramas, podemos ver que ahora
tenemos estas dos ramas. Y si seleccionarías esta rama de contenido HTML e
ingresas al archivo HTML índice, podemos ver algún contenido mientras
aún está en nuestra rama maestra. Nuestro archivo index.HTML no
tiene contenido en absoluto. Esto obviamente es
bueno porque con esto podemos dividir nuestro
código, trabajar en él, y una vez que todo esté terminado, también
podemos
volver a mover ese código al maestro. Y hablando de eso, se
puede ver este pop-up
donde somos una especie de pronta para crear una
nueva solicitud de pull. Bueno, vamos a trabajar con esto
en los siguientes videos. Por ahora, deseo
hablar más las sucursales para que se pueda entender correctamente el término.
11. ¿Qué son las ramas: El término de ramas
y todo el futuro de las ramas se crea a
partir de un árbol. Aquí el árbol,
podríamos tener nuestra principal, nuestra rama maestra, que podría
ser el cuerpo de nuestro árbol. Esta rama principal o maestra del cuerpo puede ramificarse en otras
múltiples ramas. Y junto a eso, incluso esas
ramas pueden hacer lo mismo. Ahora en GitHub, esto se
presenta un poco diferente. Todavía tenemos nuestra rama principal
o maestra, pero parece
igual que una línea desde ella. Podemos ramificarnos a
otras ramas y todas
esas pueden ser trasladadas de nuevo
a nuestra rama maestra. Si bien trabajamos en
esas otras ramas, tendríamos nuestros
commits y cada uno de esos gametos se
presentará en esas ramas. Y cada gameto tendrá su propio ID específico que
podamos aprovechar continuamente. Ahora para mostrar esto un
poco más con un equipo de personas. Digamos que tenemos
tres personas en nuestro equipo. Empezamos el
proyecto y cada una de esas personas
trabajará todas en una tarea específica. Cada una de esas tareas o características
debe ser una nueva sucursal. Por lo que ahora nuestro equipo tiene el
último código mientras trabaja en nuevas características y ninguna de sus sucursales se sabe
aún el uno del otro. Ahora, digamos que
cada uno de ellos tenía al
menos tres commits
mientras trabajaba por su cuenta. Al final, no
pudimos refundir esos cambios y características
que nuestro equipo de trabajo realizó. Y en ese punto, nuestra rama maestra llevará a cabo
todos los últimos cambios. Ahora, obviamente,
esta fusión podría causar conflictos ya que el frío
podría interferir. Especialmente si dos
personas que han trabajado en una característica similar o
la misma, pero ves get es
lo suficientemente inteligente como para fusionar
código en consecuencia. Y si hay algún
conflicto, bueno, la puerta nos señalará esos para que podamos arreglarlos. Uno. También caso de uso muy común de nuestras sucursales, especialmente
múltiples ramas. Bueno, ese caso de uso podría tratarse
de múltiples entornos. A modo de ejemplo,
digamos que tenemos nuestra rama maestra, que es nuestra producción. Eso significa que nuestro último
código en la rama master es nuestro código en vivo en nuestra página web o una app al lado de este master, que está directamente
conectado a nuestra página web. Bueno, por lo general deseamos establecer algún
entorno de desarrollo por deuda. También podemos tener una sucursal
desarrolladora sentada justo al lado de
nuestra rama maestra. Ahora en este punto cuando
trabajamos en características adicionales, nos ramificaremos de desarrollar y trabajar
en esas características y luego fusionar esas bien administradas ese código de
nuevo en desarrollo. Por lo que esto nos permitirá probar
nuestro código, no desarrollarnos. Tal vez incluso se despliega en algún entorno de
desarrollo con su propio servidor mientras que su
propia base de datos y así sucesivamente. Y una vez que el código esté a fondo probado y listo para ser desplegado, entonces podemos gestionar
nuestro desarrollo bien el código de desarrollarse
en nuestro maestro y deuda. Actualizamos nuestro
sitio web o aplicación en vivo. Esto significa que nuestro
sitio web o aplicación nunca o al menos no
debería tener errores. Ahora, este flujo que
acaban de ver también se llama git flow y es
altamente personalizable. Ahora, esa personalización, bueno, eso depende de una escala de equipo y también del software
que estás construyendo. Entonces, para una aplicación más grande, solo
quieres tener tu entorno de desarrollo y
producción, pero tal vez algún entorno de puesta en
escena, entorno de
pruebas, y así sucesivamente. Ahora, en este video también
mencioné conflictos. Entonces veamos cómo
se pueden causar esos y también resolverse.
12. Manejo de conflictos: Resolver un conflicto, primero
debemos crear uno. Los conflictos suelen ocurrir
si el mismo código se actualiza desde dos sucursales
o se elimina el código? De esa manera, bien. Uno para saber qué
color se debe fusionar y nos corresponde
resolver ese tema. Al tener nuestra sucursal de
contenido HTML aquí, podemos crear otra sucursal y hacer similar al contenido HTML. De esa manera, tendremos
contenido HTML en sucursales. Y cuando tratamos de
fusionar esos, bueno, eso fracasará
por ese conflicto. Entonces para hacer eso, volveré a
mi rama maestra y volveré a rama maestra. Necesitaré usar
comando de buen checkout y luego el nombre de mi
marca, que es master. Ahora desde rama master, crearé una nueva rama. Del mismo modo como lo hicimos
para nuestro contenido HTML, voy a crear una sucursal de
contenido del sitio es, los sitios generalmente se
escriben en código HTML. Ahora en esta rama, mi index.HTML volverá a estar vacío porque nos
ramificamos de nuestra rama maestra. Entonces en este archivo, volveré a usar ese HTML dos puntos cinco para crear el código
inicial para HTML. Y ahora
volveré a hacer elemento HTML en mi cuerpo con texto de
contenido del sitio dentro. Ahora tenemos aquí
nuestro contenido HTML. Es muy similar a nuestro contenido que tenemos
en nuestra otra sucursal. Así que vamos
a asegurarnos de empujar este código como lo hicimos para nuestra rama de contenido
HTML. Para ello,
primero usaré git add dot. De esta manera, pondré a escena
todos mis cambios. Entonces podemos usar git commit con el mensaje del
nuevo contenido del sitio. Y por último, podemos usar
comando de git, push, dash u, luego origen, y luego nuestra rama, que es el contenido del sitio. De esta manera
empujaremos nuestra sucursal y nuestro contenido en nuestro repositorio de
GitHub. En nuestro GitHub, ahora podemos ver que efectivamente tenemos
nuestras tres ramas. Encantadora. Causemos el conflicto. Ahora. Para causar el conflicto, necesitaremos volver a
nuestra sucursal de contenido HTML. Así git checkout contenido HTML. Ahora podemos usar git merge
para fusionar dos ramas. Y usaré una fusión, el origen de mi rama de contenido
del sitio. Y aquí está, el conflicto existe en este
mensaje que nos fue mostrado, incluso
podemos ver
dónde
existe el conflicto y está en
nuestro archivo index.html. Entonces vamos a abrir ese expediente. En mi Visual Studio Code, ya
podemos ver el conflicto ya que obviamente se
destaca para nosotros, llamado así
no se debe fusionar ya que puede causar muchos
bugs para nosotros aquí. Bueno, tendríamos
dos títulos diferentes, pero para ser honesto, realmente
deseo tener solo uno. Por lo que tendremos que
resolver este conflicto. Ahora, deseo ir aquí con
este título de Hola Mundo. Por lo que necesitaré ir
con el cambio actual. De lo contrario, seleccionaría
este cambio entrante. El otro título ahora desapareció porque seleccionamos
el cambio actual. Y con eso también
resolvemos el conflicto. Ahora, vamos a asegurarnos de que nuestros últimos cambios ahora estén
comprometidos y también empujados. Entonces en mi terminal, una vez más,
usaré git add dot. Después de eso,
usaré git commit con el mensaje de
arreglar conflicto. Y por último,
simplemente puedo usar git push. Obviamente, no necesitamos
crear el nuevo origen aquí ya que ya tenemos nuestra
sucursal en repositorio de GitHub. En nuestro GitHub, aún
vemos nuestras sucursales y ahora el contenido HTML
contiene el último código. Entonces, ¿cómo podemos fusionar estos
cambios en nuestra rama maestra? Bueno, hablaremos de
eso en el siguiente video.
13. Crear una solicitud de tirón: A medida que planeamos fusionar
nuestros cambios desde rama de contenido
HTML en nuestra rama maestra,
¿qué opinas? caso de que lo hagamos de la misma
manera que en el último
video, fusionar manualmente el contenido de nuestro contenido HTML en
nuestra rama maestra. Bueno, por ahora, no habrá ningún conflicto porque ya los
arreglamos. Y sí, podemos fusionar
ramas así. No será ningún problema. Pero además no es la
mejor práctica también. Cuando tengas tus propias sucursales
principales como master o una
sucursal de desarrollador para el desarrollo, o incluso probar la
sucursal para probar. Bueno, no deseas solo
administrar el código dentro. Una solución mucho mejor
para eso es crear una solicitud de pull desde tu propia rama a la rama
maestra, por ejemplo. De esa manera podemos revisar
nuestro código una vez más, comprueba si todo está bien. Además, podemos comentar nuestro
código y podemos hacer mucho, mucho más para hacer tal cosa. Da click en este pull solicita
en tu repo de GitHub. Ahora desde aquí, sólo podemos
seleccionar esta nueva solicitud de pull. Ahora se nos pide que
seleccionemos dos sucursales. El primer
ramal es la sucursal que, bueno desde donde deseamos
gestionar nuestro código. Y la otra rama es, ¿
en qué rama
queremos fusionar nuestro código? Por lo que deseo fusionar mi
código en el maestro, y saldré el código
del contenido HTML a continuación. Ahora podemos verlo comprometido que está frente a nuestra rama
maestra, lo que significa que cuando
fusionamos estos códigos juntos, todos esos commits
y contenidos que se
cambiaron estarán también
en la rama master . Por ahora. No tenemos ningún conflicto. Y aunque tuviéramos algún
conflicto que este botón, para fusionar nuestro código, mostraremos los que son para nosotros. Así que simplemente
creemos nuestra solicitud de tirón. Una vez que hacemos eso, nos redirigen a
nuestra petición polar. Aquí, podemos revisar nuestro código, poco revisar el
código una vez más. Además, podemos agregar otras
personas para revisar nuestro código. Al igual que otros revisores, también
podemos etiquetar nuestra solicitud de pull y
también mucho, mucho más. Entonces, ¿por qué estas
solicitudes de tirón son buena idea? Bueno, podríamos hacer que los miembros del equipo vengan a revisar nuestro código. A lo mejor pudieron detectar
algo que no hicimos, así que pudimos refactoriarlo. Hagamos clic ahora en esta
solicitud de fusión y confirmarla. No debe tomar mucho tiempo. Pero volviendo a
nuestra página de códigos, veremos que
nuestra rama maestra tiene nuestro archivo HTML de índice. Si entráramos a ese expediente, podemos ver que los cambios en su interior son los últimos
cambios que tuvimos. Ahora que ya sabes sobre el
flujo de trabajo con Git y GitHub, vamos a practicar un poco. Lo que quiero que hagas es
crear la nueva sucursal. Esta sucursal debe servirnos
para hacer el archivo CSS. En ese archivo, me
gustaría que
coloreara nuestra etiqueta H1 o roja. Entonces asegúrate de escenificar
y comprometer tus cambios. Y una vez que hayas terminado, entonces puedes crear tu
propia solicitud de pull y gestionar todos esos
cambios en el maestro. Y no te preocupes, si
aún no estás seguro de tus habilidades. Haremos eso juntos
en el siguiente video.
14. Flujo de trabajo habitual con Git & Github: Entonces, ¿tuviste algún éxito? No te preocupes, si no lo hiciste, estás aquí para aprender. Así que hagamos eso ahora juntos. Lo primero que
tenemos que hacer es crear nuestra sucursal donde
haremos nuestro archivo CSS. Y el código es que actualmente estamos
en una rama diferente. Echemos un vistazo a nuestra rama
maestra y asegurarnos que tengamos nuestros últimos
cambios a partir de ese momento, debería ser fácil
crear una nueva sucursal. Entonces para ir a nuestra rama master, debemos usar comando de
git checkout master. Ahora, como nuestra sucursal maestra local está detrás de nuestra rama
maestra de GitHub, debemos sacar los últimos
cambios para que nuestro código sea el mismo y no
causemos ningún conflicto. Eso es un muy simple, solo usa Git pool
abajo ahora
incluso podemos ver los cambios que se
sacaron del repositorio de GitHub. Y ahora como tenemos
nuestros últimos cambios, podemos crear nuestra sucursal
donde agregaremos nuestro CSS. Para eso, usaré
el comando de git, checkout dash B, luego el nombre de la rama
será contenido de guión CSS. Así que vamos a abrir nuestro
editor de código y agregar algo de CSS. Lo primero que hay que
hacer es crear nuestro archivo CSS. Por lo que voy a nombrar una
mina styles.css. También importaré mi CSS
a mi HTML con una etiqueta de enlace. Y por último, lo que
deseo hacer es colorear mi etiqueta H1 al color rojo. Entonces para eso,
salta a tu archivo CSS, dirige tu etiqueta H1 y usa el color rojo en él. En este punto, estamos
más o menos terminados con nuestra tarea. Podemos incluso probarlo para estar seguros de que todo está bien. Para probarlo, solo por hacer
doble clic en tu archivo
index.html para
abrirlo en tu propio navegador. Y aquí está. Parece que nuestro título es rojo, lo que significa que podemos
publicar nuestros cambios ahora, vendidos para publicar nuestros cambios, tenemos varios pasos. Tendremos que
escenificar esos cambios, comprometerlos, empujar esos, y finalmente crear
nuestra solicitud de tirón. En primer lugar, voy a escenificar
aquellos con git add dot. Ahora puedo comprometerlos con
el comando git commit, y el mensaje será
colorear título en rojo. Por último, podemos empujar estos
cambios con el comando de git push origin contenido CSS. En este punto tenemos todos
nuestros cambios en nuestro GitHub, pero actualmente no en
nuestra rama master. Entonces vamos a crear la
solicitud de tirón para eso aquí. Ahora, podemos crear nuestra solicitud de pull y también
debemos seleccionar nuestras sucursales desde
donde deseamos
monitorear nuestro código y
en qué sucursal. Entonces seleccionaré contenido
CSS desde donde
deseo fusionar mi código. Y seleccionaré
la rama maestra en qué rama
deseo fusionar mi código. Asegúrate de revisar tus cambios
y si todo está bien, solo
puedes
fusionarlos y eso debería
ser más o menos. Este es el flujo de trabajo habitual
con el Git y GitHub. Y no te preocupes si no lo
consigues la primera vez. Pruébalo un par de veces. Y cuando trabajas
en un proyecto real de lo que debería estar bien. También sólo por mencionar
que trabajar en proyecto
más significativo
o en un equipo más grande. Bueno, en ese punto, obtener flujo puede variar. Entonces este git
flow habitual que acabas ver podría ser mucho más complejo, pero eso es algo con lo que todos
tenemos que lidiar. Ahora, déjame mostrarte la
herramienta que puedes usar. Por lo que ni siquiera necesitas usar tu terminal casi en absoluto.
15. Escritorio de Github: Herramienta que deseo mostrarte
se llama GitHub Desktop. Para eso, visita,
el escritorio que GitHub.com para obtener acceso
a la herramienta aquí, asegúrate de descargar y también instalaste la herramienta para
tu sistema operativo. Y una vez que hagas eso, puedes
continuar con este video. Si tienes instalado GitHub
Desktop, asegúrate de abrirlo. En primer lugar,
hablemos de qué es. Bueno, GitHub Desktop es una excelente
aplicación de escritorio que podemos usar para ver nuestros repositorios. Junto a eso, podemos trabajar
con nuestros repos y
podremos utilizar todos los comandos sin usar el terminal. Por lo que solo podemos
hacer clic en Ver glúteos ingresando a
este escritorio de GitHub , no
verás mucho,
pero deberías tener la opción de
agregar tu propio repositorio. Desde aquí, puedes
crear un nuevo repositorio o conseguir uno del GitHub o
incluso en el repositorio local. En este ejemplo, agreguemos nuestro repositorio local porque esa manera
usaremos el local, pero también usaremos
el de un GitHub ya que nuestro repositorio local
también se almacena en GitHub. Cuando seleccione el repositorio
local, asegúrese de elegir la ruta a su repositorio en su
máquina y envíelo. Ahora ya podemos ver nuestra sucursal actual
aquí y también repo. Entonces hagamos algunos cambios. Entraré en mi Visual
Studio Code y
agregaré un color de fondo
a mi cuerpo para que sea verde. Esto definitivamente se verá feo, pero este no es
el curso de diseño. Lo importante
aquí es que
cuando visitas tu GitHub Desktop, puedes ver tu cambio
muy claramente desde aquí. Ahora, podemos comprometer nuestro código y pasar algún mensaje
para ese commit. Cuando hagamos eso,
eso debería escenificar y comprometer nuestro código en un solo objetivo. Si haces algo así, después de eso, deberías tener
esta opción para Porsche. Y obviamente es
para empujar nuestro código. Entonces con tan solo este simple
clic de un botón, podemos presionar inmediatamente
nuestros cambios a nuestro GitHub. Una vez terminado eso, inmediato obtendremos la
opción para una solicitud de pull. Entonces hagamos eso también. Al hacer clic consiguió esa opción
leerá electores a GitHub. Ya podemos crear
una solicitud de pull, por lo que sólo podemos revisar todo
y fusionarlo juntos. Por esto, puedes ver que tal vez GitHub Desktop es la opción
más fácil para ti. Pero aún así, te
aconsejaría que aprendas
a usar el terminal
con los comandos, porque el terminal
no se utilizará sólo para unas buenas
muchas tecnologías. Usaremos terminal con comandos
específicos para instalar, actualizar, eliminar
sus propias características. Entonces deberías acostumbrarte a ella. Ahora a la siguiente
conferencia, bifurcando.
16. Forzando: bifurcación es un término particular
y el futuro también. Se utiliza cuando se desea
crear algo público para que todos puedan ver y también
todos puedan acceder a eso. Entonces como ejemplo, si deseas permitir que
otras personas clonen tu código y también continúen
trabajando a través de tu código. Bueno entonces la bifurcación
vendrá en su lugar. Lo único que
debes hacer es
asegurarte de que tu repositorio
sea repositorio público. Y con Git y GitHub, podrás
bifurcar esos reportes. Esa bifurcación es todo un futuro mejora bastante nuestra
comunidad de desarrollo. Ahora, asegurémonos de
bifurcar nuestro proyecto. Bueno, como es tan bueno
bifurcar el repositorio, primero
voy a cerrar sesión de mi perfil de GitHub
porque de lo contrario no
podré bifurcar mi propio repositorio ya
que soy el dueño del mismo. Una vez que
me cierre la sesión, podré ver mi repositorio. Bueno, sigue viendo mi repositorio
aunque no estoy iniciando sesión
en mi cuenta, porque mi repositorio, cuando
creé mi repositorio, lo
configuré para que sea público. Si configuras tu propio para
que sea un repositorio privado, solo
puedes entrar en
la configuración de ese repositorio y
cambiarlo también. De lo contrario, puedes mantenerlo como privado y simplemente ver
a través de este video. En la esquina superior derecha, tendré este botón de formulario. Como no estoy conectado
a ninguna cuenta. Y para bifurcar el
repositorio de alguien, debo estar conectado. Bueno, seré
leído automáticamente dirigido a iniciar sesión. Una vez más, esta vez, iniciaré sesión con otra
cuenta para poder bifurcar el repositorio desde
mi primera cuenta una vez que seleccione esta opción fork, bueno, todo desde ahí, estaremos bastante automático. En ocasiones GitHub puede
preguntarte sobre algunos permisos
específicos, pero es directo. Una vez que el repo fue
bifurcado, es tuyo. Para que puedas hacer con
ella lo que desees. Por ejemplo, puedes
seguir construyendo sobre él. O puedes comprometer
tu código y crear la solicitud de pull directamente
al repositorio principal. Además, así es como funcionará el software de
código abierto. Nosotros como comunidad, podemos tomar bien el código de alguien, código de código abierto,
podemos arreglar algunos bugs. Podríamos agregar características
adicionales, sugerir características adicionales. Y podemos volver a comprometer
ese código y crear nuestra propia solicitud de pull desde nuestro propio repositorio bifurcado en
el repositorio principal. El propietario de ese repositorio
principal puede aceptar nuestra solicitud de pull, lo que significa que
juntos mejoramos esa herramienta, mejoramos
ese software. Y con esta bifurcación, casi
estamos terminados. Sólo deseo
mostrarles una característica más. Esta característica está relacionada
solo con GitHub, y se llama Páginas de GitHub.
17. Páginas de Github: Una de las mejores características
que tiene GitHub, y también una de las
últimas características se llama Páginas de GitHub. Páginas de Github
nos permitirá alojar fácilmente nuestro contenido en un dominio que
GitHub nos preparará. Ese dominio suele ser
nombrado por nuestro repositorio. Y requiere que tengamos
el archivo HTML de índice en el nivel raíz de nuestro
repositorio para
que pueda leer y también sacar
el contenido de ese archivo. Ahora juntos implementemos
y publiquemos bien nuestro código, nuestro proyecto que creamos
en GitHub Pages para hacer eso, visite su repositorio y
haga clic en esta pestaña Configuración. Ahora, en el lado izquierdo
de estos ajustes, hay muchas opciones
diferentes, pero por favor asegúrese de
seleccionar páginas aquí. Aquí podemos configurar y
configurar nuestras Páginas de GitHub. Y para ser honestos, no necesitaremos ejecutar ningún script para eso. Hará todo por nosotros. Lo primero que
tenemos que hacer es seleccionar la sucursal desde donde
deseamos desplegar nuestro contenido. Pues para nosotros, esta
será nuestra rama maestra. También asegúrese de seleccionar la
raíz del proyecto es nuestro archivo index.HTML
está en la raíz del mismo. Ahora, solo guarda esto y deberías ver el
enlace a tu dominio. El enlace en sí debe contener
el contenido de su sitio web. También solo dale
un poco de tiempo ya que
a veces se necesita unos
minutos para presentarlo en vivo. Pero una vez que todo está terminado y se despliega el
sitio web, deberías ver lo que veo aquí. Bueno, mi contenido,
y para ser honesto, es una gran página web. Bueno, es otro
tutorial sobre eso, pero sobre Git y GitHub. Pero con esta característica, páginas de
GitHub, estamos más
o menos terminados. Vamos a entrar en
el siguiente video para decir un adiós apropiado también.
18. Gracias y Adiós: Bueno, supongo que
esto es todo chicos. Hemos terminado este curso juntos y realmente
deseo agradecerles. Estás tomando este curso
significa mucho para mí. Ahora lo que podrías hacer es
también dejar una revisión también. La revisión en sí puede ser simple y también ser
honesta al respecto. Te fue realmente
cuidadoso este curso? ¿También? ¿ Fue a medida para principiantes? Y ¿aprendiste algo
útil y sobre eso, espero que lo hicieras o
al menos mejoraste un poco tus
conocimientos. A medida que pasamos por
un montón de características. A modo de ejemplo,
pasamos por Git y GitHub en general se
instalará Git como herramienta. Y también se le
presentó. Viste lo que es para
lo que podemos usarlo, y también el
flujo de trabajo habitual con Git. Ese flujo de trabajo habitual
incluía crear un repositorio, clonar
ese repositorio, escena nuestros cambios,
rastrear esos cambios, comprometer, y empujar
nuestro código también. Obviamente no aprendimos, solo llega hasta aquí, pero también
usamos el GitHub. Github nos ayudó a
administrar nuestras sucursales, también los cambios de checkout
y commit mientras también
pudimos fusionar
nuestro código cuando queríamos, también entendiste
el término de sucursales. ¿ Viste cómo
puedes manejarlos? También viste lo que
es solicitud de tirón. También utilizamos un par de solicitudes de
sondeo. Junto a eso, sí arreglamos conflictos y también
bifurcamos nuestro repositorio. Por último, terminamos
el discurso con dos grandes
características de GitHub, GitHub Pages y GitHub Desktop. Utilizamos escritorio para administrar nuestro
repositorio sin terminal. Y también utilizamos las páginas
para desplegar nuestro código, nuestro sitio web a un dominio
dado por GitHub. Ahora, si te gustó este
curso de mi parte y te gustaría ver más
contenido de mi parte también. Bueno, asegúrate de visitar mi canal de
YouTube para eso. En mi canal de YouTube, puedes encontrar tutoriales para diversas tecnologías como
Bootstrap, Angular, JS anidados. Junto a eso, hay cursos de
choque así
como todo el proyecto. Aquí en Skillshare. También puedes encontrar muchos proyectos
diferentes de mi parte. Entonces si te
interesan esos,
bueno, asegúrate de
revisar esos hacia fuera. Y por último, siempre puedes visitar mi
sitio web oficial ahí
encontrarás todos mis tutoriales y cursos que tengo también. Gracias una vez más por ver y terminar
este curso. Espero que también te vea
en otros cursos. Adiós.