Entiende lo Básico para Programar Mejor.
Soy
Los VCS (Version Control System) son sistemas que reconocen los cambios de un archivo o conjunto de archivos, se puede realizar con cualquier tipo de archivo en un ordenador.
Proyecto, ProyectoFinal ,ProyectoFinalFinal1.0, ProyectoChidoBueno, si esto te suena familiar entonces tu res puesta es SI
1) Registran y guardan cada modificación del proyecto en un registro. Todo lo que modificas, lo vigilan.
2) Te dan acceso a este registro. Con esto, puedes gestionarlo, compartirlo, colaborarlo, administrarlo, editarlo, etc.
3) Podrás moverte hacia atrás o hacia adelante en diferentes momentos del proyecto.
Siempre busca lo mas entendible
Es el sistema de control de versiones.
a) Entren a http://git-scm.com
b) Escoja dependiendo de Windows, Mac, Linux
$ pwd // Nos muestra la ruta de carpetas en la que te encuentras ahora mismo.
$ mkdir // Nos permite crear carpetas (por ejemplo, mkdir Carpeta-Importante).
$ touch // Nos permite crear archivos (por ejemplo, touch archivo.txt).
$ rm // Nos permite borrar un archivo o carpeta (por ejemplo, rm archivo.txt).
Mucho cuidado con este comando, puedes borrar todo tu disco duro.
$ cat //Ver el contenido de un archivo (por ejemplo, cat nombre-archivo.txt).
$ ls // ver los archivos de la una carpeta.
$ cd // Nos permite navegar entre carpetas.
Recuerda que podemos descubrir todos los argumentos de un comando con el argumento --help (por ejemplo, cat --help)
Abrir terminal, consola, bash
$ git --version
$ git config --global user.name "TU NOMBRE"
$ git config --global user.email "TU CORREO DE GITHUB"
$ git config --global color.ui true
$ git config --global --list
Es es la parte de trabajo, en donde te pones a plasmar todas ideas en codigo
Despues de trabajar tan duro, es momendo de decir que archivos estan listos para generar un commit y cuales no
Es el area de registros del proyecto.
Es un comando que se utiliza para saber como funciona cada instrucción de git, al igual que da una breve explicacíon de dicha instrucción.
git --help comando.
Con esté comando le decimos a git que empiece a monitorear todos los cambios que haga en mi carpeta de trabajo, es el Nivel 1 de nuestro proyecto, es el inicio de una fantástica aventura.
Si no inicias con git init nos dirá que no hay un repositorio de git.
Nos muestra el estado en el que se encuentra nuestro proyecto:
Con este comando decidimos que archivos van a convertirse en commit y que archivos aún no están listos.
Agregamos todos los archivos.
git add -A
Agregamos solo el archivo index.html o el nombre del archivo que usemos.
git add index.html
Aquí ya estamos en la ultima parte del esquema de árbol y es hacer un commit como tal.
Ya que hicimos código y decidimos que archivos están listos, solo queda guardar lo que hicimos en un commit es decir el trabajo de hoy está hecho.
git commit -m "hoy pase de estar en ssj3 a ssj4"
Nos dice como está el repositorio a nivel de commits (Cuantos commits tenemos en el repositorio), quien las hizo, cuando las hizo y básicamente todo.
Es exactamente lo mismo que git log solo que este nos genera un .txt con los commits en la raíz del proyecto.
Con este comando visualizamos los ultimos cambios registrados.
quien hiso el cambio que quito y que agrego
Con este comando viajamos a travez del tiempo, y podemos ir a cualquier commit que tengamos atrás, esto sin afectar a los que hay enfrente.
Si hacemos un cambio a algún proyecto que tienes atrás, crearás dos mundos paralelos
git checkout commit
git checkout master
Master -> rama principal
Este comando es súper poderoso y ten cuidado con usarlo, hace lo mismo que git checkout a diferencia que arrasa con todos los commits que tiene enfrente.
Tiene tres tipos de ejeción:
Es un reset tranquilo, tu Working Area lo deja, no se mete con tú código.
Este reset es raro y muy poco usado, borra tu Staging Area sin tocar tu Working Area
Este comando lo que dice es ¡Hey quiero borrar todo! y en efecto eso es lo que hace, inluyendo tu código.
Cuando quieres recordar el estado actual el working area, pero necesitas regresar a un entorno limpio
este comando guarda localmente las modificacions para despues aplicarlas
# este comando guarda automaticamente
$ git stash
# con este comando listamos la pila de los cambios almacenados
$ git stash list
# con este comando puedes guardar siendo mas descriptivo
$ git stash save
# se aplica el ultimo cambio almacenado en la pila tambien puedes indicar cual
$ git stash apply
Una rama es una línea alterna del tiempo, en la historia de nuestro repositorio.
Funciona para crear features, arreglar bugs, experimentar, sin afectar la versión estable, la línea principal, del proyecto
Una rama Git es simplemente un apuntador móvil apuntando a una de esas confirmaciones. La rama por defecto de Git es la rama master. Con la primera confirmación de cambios que realicemos, se creará esta rama principal master apuntando a dicha confirmación. En cada confirmación de cambios que realicemos, la rama irá avanzando automáticamente. Y la rama master apuntará siempre a la última confirmación realizada.
Esto creará un nuevo apuntador apuntando a la misma confirmación donde estés actualmente
$ git branch testing
Esto creará un nuevo apuntador apuntando a la misma confirmación donde estés actualmente
Pediante un apuntador especial denominado HEAD. es simplemente el apuntador a la rama local en la que tú estés en ese momento. En este caso, en la rama master. Puesto que el comando git branch solamente crea una nueva rama, y no salta a dicha rama.
Para saltar de una rama a otra, tienes que utilizar el comando git checkout. Hagamos una prueba, saltando a la rama testing recién creada:
$ git checkout testing
y poder seguir avansando en nuestro proyecto
Simplemente, activando (checkout) la rama donde deseas fusionar y lanzando el comando git merge
$ git checkout master
$ git merge nombre_de_rama
git log --oneline --graph --all
git config --global alias.nicelog 'log --oneline --graph --all'
$ git tag
# este comando lista las tags que tengas en el entordo
$ git tag
# -a anota la referencia tag -m anota el mensaje para describir el tag
$ git tag -a v1.4.0 -m "mi androide 14"
# para publicar en mi repositorio remoto las tags correspondientes
$ git push --tags
Cuando hacer un tag ?
Los repositorios remotos son versiones de tu proyecto que se encuentran alojados en Internet o en algún punto de la red.
Es una plataforma social para construir proyectos.
Exploración: Git Clone
$ git clone [https or SSH]
$ git log (comprobar commits)
Configurar SSh
Son ramas locales que no puedes mover; se mueven automáticamente cuando estableces comunicaciones en la red.
Suelen referenciarse como (remoto)/(rama).
Para añadir un nuevo repositorio Git remoto, asignándole un nombre con el que referenciarlo fácilmente, ejecuta $ git remote add [nombre] [url]
Subir cambios a GitHub
$ git init
$ git remote add origin [HTTPS or SSH]
$ git remote -v
Generamos cambios
$ git commit -am "[Mensaje]"
$ git push origin master
- Es lo mismo que el proceso anterior.
- Todos los cambios que hagan nuestros colaboradores lo subirán al repositorio
- Es nuestra obligación, descargar los nuevos cambios antes y después de codificar.
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Git Fetch & Git Merge
Creamos ó entramos a la carpeta de nuestro proyecto
$ git init (si apenas vamos a iniciar)
$ git remote add origin [HTTS or SSH]
$ git fetch origin
$ git merge origin/master
Hacen cambios
$ git fetch origin
$ git merge origin/master
$ git push origin master
3) Repositorios "forked" (De 3º's, hay gestores)
- Ustedes no son los dueños pero quieren participar en el desarrollo.
- Los dueños del proyecto le dan la visión (que commits sí y que commits no)
- Todo esto a través del concepto de Pull Request (PR)
Subir cambios a GitHub
$ git init
$ git remote add origin [HTTPS or SSH]
$ git remote -v
Generamos cambios
$ git commit -am "[Mensaje]"
$ git push origin master
Repositorios "forked"
Necesitamos conectar 2 repositorios.
1) Su repositorio forked (el que se colocó en su cuenta de GitHub y son dueños)
2) El repositorio principal (no son dueños)
Repositorios "forked"
Repositorios "forked"
Repositorios "forked"
Repositorios "forked"
Repositorios "forked"
Repositorios "forked"
Ciclo final - Repositorios "forked"
Repositorios "forked"
La idea es:
- Siempre que vayamos a iniciar cambios, actualizarnos con el proyecto principal.
- Hacer nuestros cambios, experimentos, etc.
- Revisar nuevamente si no hubo cambios con el proyecto principal.
- Subir a nuestro forked repository todo lo que hemos hecho.
- Si queremos, crear un pull request para colaboración.
Repositorios "forked"
Crear ó entrar a la carpeta del proyecto
$ git remote add origin [HTTPS ó SSH del proyecto forked]
$ git remote add upstream [HTTPS ó SSH del proyecto "main"]
$ git fetch upstream
$ git merge origin/upstream
$ git fetch origin
$ git merge origin/master
Hacer cambios en local
$ git fetch upstream
$ git merge origin/upstream
$ git push origin master
Repositorios "forked"
Si queremos, realizamos un Pull Request al proyecto principal ("main")