GitEmpezando con Git


Observaciones

Git es un sistema de control de versiones distribuido y gratuito que permite a los programadores realizar un seguimiento de los cambios de código, a través de "instantáneas" (confirmaciones), en su estado actual. La utilización de confirmaciones permite a los programadores probar, depurar y crear nuevas características de forma colaborativa. Todas las confirmaciones se guardan en lo que se conoce como un "Repositorio Git" que se puede alojar en su computadora, servidores privados o sitios web de código abierto, como en Github.

Git también permite a los usuarios crear nuevas "ramas" del código, lo que permite que diferentes versiones del código vivan una junto a la otra. Esto permite escenarios en los que una rama contiene la versión estable más reciente, una rama diferente contiene un conjunto de nuevas características que se están desarrollando y otra rama contiene un conjunto diferente de características. Git realiza el proceso de creación de estas ramas, y luego las vuelve a unir, casi sin dolor.

Git tiene 3 "áreas" diferentes para tu código:

  • Directorio de trabajo : el área en la que realizará todo su trabajo (creación, edición, eliminación y organización de archivos)
  • Área de almacenamiento : el área donde se enumerarán los cambios que haya realizado en el directorio de trabajo
  • Repositorio : donde Git almacena permanentemente los cambios que ha realizado como diferentes versiones del proyecto

Git fue creado originalmente para administrar la fuente del kernel de Linux. Al hacerlos más fáciles, alienta a los pequeños compromisos, forking de proyectos y la fusión entre las horquillas, y tener muchas sucursales de corta duración.

El mayor cambio para las personas que están acostumbradas a CVS o Subversion es que cada proceso de pago contiene no solo el árbol de origen, sino también toda la historia del proyecto. Las operaciones comunes como la revisión de revisiones, la revisión de revisiones anteriores, la confirmación (a su historial local), la creación de una rama, la verificación de una rama diferente, la combinación de ramas o archivos de parches se pueden realizar de manera local sin tener que comunicarse con un servidor central. Así se elimina la mayor fuente de latencia y falta de fiabilidad. La comunicación con el repositorio "ascendente" solo es necesaria para obtener los últimos cambios y para publicar los cambios locales a otros desarrolladores. Esto convierte lo que antes era una restricción técnica (quien tenga el repositorio propietario del proyecto) en una opción organizativa (su "upstream" es la persona que elija sincronizar).

Versiones

Versión Fecha de lanzamiento
2,13 2017-05-10
2.12 2017-02-24
2.11.1 2017-02-02
2,11 2016-11-29
2.10.2 2016-10-28
2,10 2016-09-02
2.9 2016-06-13
2.8 2016-03-28
2.7 2015-10-04
2.6 2015-09-28
2.5 2015-07-27
2.4 2015-04-30
2.3 2015-02-05
2.2 2014-11-26
2.1 2014-08-16
2.0 2014-05-28
1.9 2014-02-14
1.8.3 2013-05-24
1.8 2012-10-21
1.7.10 2012-04-06
1.7 2010-02-13
1.6.5 2009-10-10
1.6.3 2009-05-07
1.6 2008-08-17
1.5.3 2007-09-02
1.5 2007-02-14
1.4 2006-06-10
1.3 2006-04-18
1.2 2006-02-12
1.1 2006-01-08
1.0 2005-12-21
0.99 2005-07-11

Crea tu primer repositorio, luego agrega y confirma archivos

En la línea de comandos, primero verifique que tiene Git instalado:

En todos los sistemas operativos:

git --version
 

En sistemas operativos similares a UNIX:

which git
 

Si no se devuelve nada o no se reconoce el comando, es posible que deba instalar Git en su sistema descargando y ejecutando el instalador. Consulte la página de inicio de Git para obtener instrucciones de instalación excepcionalmente claras y fáciles.

Después de instalar Git, configure su nombre de usuario y dirección de correo electrónico . Haz esto antes de hacer un commit.

Una vez que Git esté instalado, navegue hasta el directorio que desea colocar bajo el control de versiones y cree un repositorio de Git vacío:

git init
 

Esto crea una carpeta oculta, .git , que contiene la tubería necesaria para que Git funcione.

A continuación, verifique qué archivos Git agregará a su nuevo repositorio; Este paso merece un cuidado especial:

git status
 

Revise la lista resultante de archivos; puede decirle a Git cuál de los archivos debe colocar en el control de versiones (evite agregar archivos con información confidencial, como contraseñas o archivos que solo saturan el repositorio):

git add <file/directory name #1> <file/directory name #2> < ... >
 

Si todos los archivos de la lista deben compartirse con todos los que tienen acceso al repositorio, un solo comando agregará todo en su directorio actual y sus subdirectorios:

git add .
 

Esto " preparará " todos los archivos que se agregarán al control de versiones, preparándolos para que se confirmen en su primer confirmación.

Para los archivos que nunca desee que .gitignore bajo el control de versiones, cree y .gitignore un archivo llamado .gitignore antes de ejecutar el comando add .

Confirme todos los archivos que se han agregado, junto con un mensaje de confirmación:

git commit -m "Initial commit"
 

Esto crea una nueva confirmación con el mensaje dado. Un compromiso es como guardar o instantánea de todo su proyecto. Ahora puede enviarlo o cargarlo a un repositorio remoto, y más tarde puede volver a él si es necesario.
Si omite el parámetro -m , su editor predeterminado se abrirá y podrá editar y guardar el mensaje de confirmación allí.

Añadiendo un control remoto

Para agregar un nuevo control remoto, use el comando git remote add en el terminal, en el directorio donde está almacenado su repositorio.

El comando git remote add toma dos argumentos:

  1. Un nombre remoto, por ejemplo, origin
  2. Una URL remota, por ejemplo, https://<your-git-service-address>/user/repo.git
    git remote add origin https://<your-git-service-address>/owner/repository.git
 

NOTA: antes de agregar el control remoto, tiene que crear el repositorio requerido en su servicio git, podrá enviar / tirar confirmaciones después de agregar su control remoto.

Clonar un repositorio

El comando git clone se usa para copiar un repositorio Git existente desde un servidor a la máquina local.

Por ejemplo, para clonar un proyecto de GitHub:

cd <path where you'd like the clone to create a directory>
git clone https://github.com/username/projectname.git
 

Para clonar un proyecto de BitBucket:

cd <path where you'd like the clone to create a directory>
git clone https://yourusername@bitbucket.org/username/projectname.git
 

Esto crea un directorio llamado projectname en la máquina local, que contiene todos los archivos en el repositorio remoto de Git. Esto incluye archivos de origen para el proyecto, así como un subdirectorio .git que contiene todo el historial y la configuración del proyecto.

Para especificar un nombre diferente del directorio, por ejemplo, MyFolder :

git clone https://github.com/username/projectname.git MyFolder
 

O para clonar en el directorio actual:

git clone https://github.com/username/projectname.git .
 

Nota:

  1. Cuando se clona en un directorio específico, el directorio debe estar vacío o no existente.

  2. También puede usar la versión ssh del comando:

    git clone git@github.com:username/projectname.git
     

La versión https y la versión ssh son equivalentes. Sin embargo, algunos servicios de alojamiento como GitHub recomiendan que use https lugar de ssh .

Instalación de Git

Vamos a usar algo de Git. Lo primero es lo primero: tienes que instalarlo. Puedes conseguirlo de varias maneras; Los dos principales son instalarlo desde la fuente o instalar un paquete existente para su plataforma.

Instalación desde la fuente

Si puedes, generalmente es útil instalar Git desde la fuente, porque obtendrás la versión más reciente. Cada versión de Git tiende a incluir mejoras útiles en la interfaz de usuario, por lo que obtener la última versión suele ser la mejor ruta si se siente cómodo compilando software desde su origen. También es cierto que muchas distribuciones de Linux contienen paquetes muy antiguos; así que, a menos que esté en una distribución muy actualizada o esté usando backports, la instalación desde la fuente puede ser la mejor opción.

Para instalar Git, necesitas tener las siguientes bibliotecas de las que Git depende: curl, zlib, openssl, expat y libiconv. Por ejemplo, si está en un sistema que tiene yum (como Fedora) o apt-get (como un sistema basado en Debian), puede usar uno de estos comandos para instalar todas las dependencias:

$ yum install curl-devel expat-devel gettext-devel \
  openssl-devel zlib-devel

$ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext \
  libz-dev libssl-dev
 

Cuando tenga todas las dependencias necesarias, puede seguir adelante y obtener la última instantánea del sitio web de Git:

http://git-scm.com/download Luego, compile e instale:

$ tar -zxf git-1.7.2.2.tar.gz
$ cd git-1.7.2.2
$ make prefix=/usr/local all
$ sudo make prefix=/usr/local install
 

Una vez hecho esto, también puede obtener Git a través de Git para las actualizaciones:

$ git clone git://git.kernel.org/pub/scm/git/git.git
 

Instalación en Linux

Si desea instalar Git en Linux a través de un instalador binario, generalmente puede hacerlo a través de la herramienta básica de administración de paquetes que viene con su distribución. Si estás en Fedora, puedes usar yum:

$ yum install git
 

O si estás en una distribución basada en Debian como Ubuntu, prueba con apt-get:

$ apt-get install git
 

Instalar en Mac

Hay tres formas fáciles de instalar Git en una Mac. Lo más fácil es usar el instalador gráfico de Git, que puedes descargar desde la página de SourceForge.

http://sourceforge.net/projects/git-osx-installer/

Figura 1-7. Instalador de Git OS X. La otra forma importante es instalar Git a través de MacPorts ( http://www.macports.org) . Si tiene instalado MacPorts, instale Git a través de

$ sudo port install git +svn +doc +bash_completion +gitweb
 

No tiene que agregar todos los extras, pero probablemente querrá incluir + svn en caso de que alguna vez tenga que usar Git con los repositorios de Subversion (vea el Capítulo 8).

Homebrew ( http://brew.sh/) es otra alternativa para instalar Git. Si tienes Homebrew instalado, instala Git a través de

$ brew install git
 

Instalación en Windows

Instalar Git en Windows es muy fácil. El proyecto msysGit tiene uno de los procedimientos de instalación más fáciles. Simplemente descargue el archivo exe instalador de la página de GitHub y ejecútelo:

http://msysgit.github.io
 

Después de que se instale, tiene una versión de línea de comandos (incluido un cliente SSH que será útil más adelante) y la GUI estándar.

Nota sobre el uso de Windows: debe usar Git con el shell msysGit proporcionado (estilo Unix), permite usar las complejas líneas de comando que se incluyen en este libro. Si necesita, por alguna razón, usar la consola de línea / comando nativa de Windows, debe usar comillas dobles en lugar de comillas simples (para parámetros con espacios en ellas) y debe citar los parámetros que terminan con el acento circunflejo (^ ) si son los últimos en la línea, ya que es un símbolo de continuación en Windows.

Aprendiendo sobre un comando

Para obtener más información sobre cualquier comando git, es decir, detalles sobre lo que hace el comando, las opciones disponibles y otra documentación, use la opción --help o el comando help .

Por ejemplo, para obtener toda la información disponible sobre el comando git diff , use:

git diff --help
git help diff
 

Del mismo modo, para obtener toda la información disponible sobre el comando de status , use:

git status --help
git help status
 

Si solo desea una ayuda rápida que le muestre el significado de las marcas de línea de comando más utilizadas, use -h :

git checkout -h
 

Configurar SSH para Git

Si está utilizando Windows, abra Git Bash . Si está utilizando Mac o Linux, abra su Terminal.

Antes de generar una clave SSH, puede verificar si tiene alguna clave SSH existente.

Listar los contenidos de su directorio ~/.ssh :

$ ls -al ~/.ssh 
# Lists all the files in your ~/.ssh directory
 

Verifique la lista del directorio para ver si ya tiene una clave SSH pública. Por defecto, los nombres de archivo de las claves públicas son uno de los siguientes:

id_dsa.pub
id_ecdsa.pub
id_ed25519.pub
id_rsa.pub
 

Si ve un par de claves públicas y privadas existentes que le gustaría usar en su cuenta de Bitbucket, GitHub (o similar), puede copiar el contenido del archivo id_*.pub .

De lo contrario, puede crear un nuevo par de claves pública y privada con el siguiente comando:

$ ssh-keygen
 

Presione la tecla Intro o Retorno para aceptar la ubicación predeterminada. Ingrese y vuelva a ingresar una frase de contraseña cuando se le solicite, o déjela en blanco.

Asegúrese de que su clave SSH se agrega a ssh-agent. Inicie ssh-agent en segundo plano si aún no se está ejecutando:

$ eval "$(ssh-agent -s)"
 

Agregue su clave SSH al ssh-agent. Tenga en cuenta que necesitará reemplazar id_rsa en el comando con el nombre de su archivo de clave privada :

$ ssh-add ~/.ssh/id_rsa
 

Si desea cambiar el flujo ascendente de un repositorio existente de HTTPS a SSH, puede ejecutar el siguiente comando:

$ git remote set-url origin ssh://git@bitbucket.server.com:7999/projects/your_project.git
 

Para clonar un nuevo repositorio sobre SSH puede ejecutar el siguiente comando:

$ git clone ssh://git@bitbucket.server.com:7999/projects/your_project.git
 

Configuración del control remoto

Si ha clonado una bifurcación (por ejemplo, un proyecto de código abierto en Github), es posible que no tenga acceso directo al repositorio anterior, por lo que necesita ambos bifurcaciones pero puede recuperar el repositorio ascendente.

Primero revise los nombres remotos:

$ git remote -v
origin    https://github.com/myusername/repo.git (fetch)
origin    https://github.com/myusername/repo.git (push)
upstream  # this line may or may not be here
 

Si upstream es ya (está en algunas versiones Git) que necesita para establecer la dirección URL (en la actualidad está vacío):

$ git remote set-url upstream https://github.com/projectusername/repo.git
 

Si el flujo ascendente no está allí, o si también desea agregar el fork de un amigo / colega (actualmente no existen):

$ git remote add upstream https://github.com/projectusername/repo.git
$ git remote add dave https://github.com/dave/repo.git
 

Configuración de su nombre de usuario y correo electrónico

You need to set who you are *before* creating any commit.  That will allow commits to have the right author name and email associated to them.
 

No tiene nada que ver con la autenticación cuando se empuja a un repositorio remoto (por ejemplo, cuando se empuja a un repositorio remoto usando su cuenta de GitHub, BitBucket o GitLab)

Para declarar esa identidad para todos los repositorios, use git config --global
Esto almacenará la configuración en el archivo .gitconfig su usuario: por ejemplo, $HOME/.gitconfig o para Windows, %USERPROFILE%\.gitconfig .

git config --global user.name "Your Name"
git config --global user.email mail@example.com
 

Para declarar una identidad para un repositorio único, use git config dentro de un repositorio.
Esto almacenará la configuración dentro del repositorio individual, en el archivo $GIT_DIR/config . por ejemplo, /path/to/your/repo/.git/config .

cd /path/to/my/repo
git config user.name "Your Login At Work"
git config user.email mail_at_work@example.com
 

Las configuraciones almacenadas en el archivo de configuración de un repositorio tendrán prioridad sobre la configuración global cuando use ese repositorio.


Sugerencias: si tiene diferentes identidades (una para el proyecto de código abierto, otra en el trabajo, otra para los repositorios privados, ...), y no se olvide de configurar la correcta para cada repositorio diferente en el que esté trabajando. :

  • Eliminar una identidad global

    git config --global --remove-section user.name
    git config --global --remove-section user.email
     
2.8
  • Para forzar a git a buscar su identidad solo dentro de la configuración de un repositorio, no en la configuración global:

      git config --global user.useConfigOnly true
     

De esa manera, si olvida establecer su nombre de user.name y user.email de user.email para un repositorio determinado e intenta realizar un compromiso, verá:

no name was given and auto-detection is disabled
no email was given and auto-detection is disabled
 

Compartir código

Para compartir su código, cree un repositorio en un servidor remoto en el que copiará su repositorio local.

Para minimizar el uso del espacio en el servidor remoto, cree un repositorio simple: uno que tenga solo los objetos .git y no cree una copia de trabajo en el sistema de archivos. Como beneficio adicional, configura este control remoto como un servidor ascendente para compartir fácilmente las actualizaciones con otros programadores.

En el servidor remoto:

git init --bare /path/to/repo.git
 

En la máquina local:

git remote add origin ssh://username@server:/path/to/repo.git
 

(Tenga en cuenta que ssh: es solo una forma posible de acceder al repositorio remoto).

Ahora copie su repositorio local al remoto:

git push --set-upstream origin master
 

Al agregar --set-upstream (o -u ) se creó una referencia upstream (seguimiento) que se usa con los comandos Git sin argumentos, por ejemplo, git pull .