El director de Fallout: New Vegas, Josh Sawyer, ha dejado de lado una teoría de los fanáticos que ha persistido desde el lanzamiento sobre dos de las áreas más notoriamente desafiantes del juego.

Llegar al Strip de Las Vegas será, naturalmente, una de tus principales prioridades en Fallout: New Vegas desde el principio: está en el maldito título. Y por mucho que la famosa ciudad turística ya se parezca a una zona de peligro post-apocalíptica en ciertos momentos de la noche, recuerdo que estuve interesado en dar un paseo por la versión de Obsidian del Strip desde el principio.

El comando git fetch es como un comando git pull que actualiza tu repositorio local con información y confirma desde el repositorio remoto, sin sobrescribir tus archivos de trabajo.

el git fetch El comando te permite mirar antes de saltar. Puede descubrir qué cambios se han realizado en un repositorio remoto, pero sin sobrescribir sus archivos locales con los archivos remotos.

¿Qué es git fetch y qué hace?

El fetch El comando en Git descarga confirmaciones, archivos y otra información desde un repositorio remoto a su repositorio local, de forma segura. Use fetch cuando desee ver qué cambios han realizado otros desarrolladores, sin verse obligado a aceptar los cambios. Sus archivos locales permanecen intactos. ¿Por qué es eso importante?

Tienes que mantener tu ingenio sobre ti cuando trabajas como parte de un equipo de desarrollo. El repositorio remoto o central contendrá cambios y nuevas ramas que otros desarrolladores han creado y enviado al repositorio remoto.

Es muy posible que alguien haya actualizado la copia remota de los archivos que ha modificado localmente en su computadora. Si casualmente realiza una git pull para actualizar su repositorio local, es probable que se encuentre manejando fusiones para cambios que quizás ni siquiera desee.

Una vez que haya descargado la información, puede examinarla y ver cuáles son los cambios. Esto le permite tomar una decisión informada sobre lo que desea fusionar en este momento, en todo caso, y lo que desea diferir hasta más adelante.

Git buscar vs tirar

El git fetch El comando se comporta como el git pull mando pero sin el paso que sobrescribe sus archivos locales. Su repositorio local se actualiza y sincroniza, pero los cambios no se escriben en el estado de funcionamiento de su repositorio local, por lo que sus archivos permanecen intactos.

O, dicho de otro modo, el git pull El comando es como un git fetch seguido inmediatamente por un git merge .

Sincroniza tus repositorios locales y remotos con git fetch

Para obtener todos los metadatos actualizados y confirmaciones de un repositorio remoto a su repositorio local, use el git fetch comando con el nombre o URL del repositorio remoto. De forma predeterminada, el primer repositorio remoto se llama «origen».

git fetch origin

Puede omitir la palabra «origen» si está trabajando con un solo repositorio remoto.

git fetch

Eso recupera cualquier actualización del repositorio de «origen», pero no fusiona los cambios en los archivos de trabajo. Podemos ver que hay una nueva rama, llamada «nueva rama», que se ha recuperado para nosotros.

Una vez que hayas usado el fetch comando, puede ver la lista completa de sucursales en el control remoto, usando -r (remoto) con el comando branch.

git branch -r

Esto enumera todas las sucursales que conoce el control remoto, que después de la fetch también están en su repositorio local.

Ver todas las etiquetas obtenidas

Del mismo modo, puede utilizar el tag (nota, es «etiqueta» sin «s») para ver la lista de etiquetas.

git tag

RELACIONADO: Cómo cambiar, agregar y eliminar controles remotos de Git

Hacer una carrera en seco primero

Aunque un git fetch no fusiona los cambios en sus archivos de trabajo, aún actualiza su repositorio local. Si quieres ver qué cambia el fetch ejecutará el comando, sin hacerlos realmente, use el --dry-run opción.

git fetch --dry-run

Cómo obtener una sola rama

Obtener información sobre una sola sucursal es fácil. Agregue el nombre de la rama a la línea de comando para indicar fetch solo necesita saber acerca de esa rama.

Aquí, estamos diciendo fetch para recuperar la rama «mary-feature» del repositorio remoto «origen».

git fetch origin mary-feature

Ahora que los detalles y el contenido de la rama remota están en su repositorio local, puede usar el git checkout Comando para crear una nueva sucursal y verificar la sucursal remota. Esto no sobrescribirá ningún archivo existente si es la primera vez que usa esta rama.

git checkout -b mary-feature origin/mary-feature

Obtener todas las sucursales

Si usa varios controles remotos, puede ahorrar tiempo extrayendo todos los cambios de todas las sucursales a su repositorio local usando el --all opción.

git fetch --all

Comparación de sucursales locales y remotas

Para ver cómo los archivos en una rama remota difieren de sus copias locales, use git fetch luego usa el git log dominio.

Tenga en cuenta que las sucursales locales y remotas tienen dos períodos «..” separándolos. El --oneline La opción muestra el identificador de confirmación y el mensaje de confirmación.

git fetch

git log --oneline mary-feature..origin/mary-feature

La visualización de una línea es útil si una rama contiene muchos cambios. Para ver un poco más de información, omita el --oneline opción.

git log mary-feature..origin/mary-feature

Esto nos muestra la hora y la fecha de cada confirmación, junto con el mensaje de confirmación y los datos de contacto del autor del cambio.

Sincronización de una sucursal local con una sucursal remota

Si ha decidido que desea continuar y fusionar los cambios de la rama remota con sus archivos de trabajo locales, puede usar estos comandos.

Verificaremos la sucursal para asegurarnos de que estamos trabajando, es nuestra sucursal actual y en funcionamiento.

git checkout mary-feature

La rama está verificada para nosotros y se nos dice que está detrás de la versión remota. Nosotros podemos usar git pull para actualizarlo, entonces git status para comprobar nuestro estado.

git pull

git status

Si hemos realizado algunos cambios en nuestros archivos locales, Git nos informa cuando revisamos la rama que necesitaremos realizar un git pull para iniciar una fusión.

git checkout mary-feature

Un simple git pull inicia el proceso de recuperación de archivos y fusión, o podemos sumergirnos y usar git merge sí mismo. Comenzaremos por asegurarnos de que estamos trabajando con la rama correcta

git checkout mary-feature

Bien dicho git para fusionar nuestra rama actual con la rama en el repositorio remoto, hay seis compromisos diferentes que deben resolverse.

Necesitamos decirle a Git qué rama remota queremos fusionar.

git merge origin/mary-feature

Se abre un editor que nos permite proporcionar un mensaje de confirmación. Podemos aceptar el mensaje sugerido, o agregar el nuestro. El editor es su editor predeterminado a menos que Git se haya configurado para usar un editor diferente.

Guarde sus cambios cuando esté listo para continuar. La combinación continúa automáticamente cuando se cierra el editor.

Nuestra fusión fue exitosa porque no hubo conflictos.

Los conflictos surgen cuando dos o más desarrolladores modifican las mismas líneas de código. Si ese es el caso, Git marca los conflictos en el archivo afectado. Deberá revisarlos uno por uno y elegir qué cambio desea conservar.

El cachorro a medio entrenar

Como un cachorro en entrenamiento, fetch recuperará lo que pidas, pero no lo dejará. Si realmente quieres lo que el cachorro te ha mostrado, tendrás que pull.

RELACIONADO: Git rebase: Todo lo que necesitas saber

El comando de confirmación de Git almacena copias de los cambios de su directorio de trabajo en su repositorio de Git. Pero también se puede usar para modificar compromisos existentes y también para revertir compromisos.

Un requisito básico de cualquier sistema de control de versiones es almacenar diferentes versiones de archivos para usted. En Git, el comando que hace esto es commit. Aquí está todo lo que necesitas saber.

¿Qué es un compromiso en Git?

Los compromisos son la serie de instantáneas realizadas a lo largo del ciclo de vida de un proyecto que conforman su historial de desarrollo. Los compromisos son los que nos permiten extraer una versión del proyecto tal como era en diferentes puntos en el pasado. ¿Por qué es eso importante?

Los sistemas de control de versiones (VCS) se usan más comúnmente con el código fuente del software y los proyectos de desarrollo. Pero se pueden usar con éxito con cualquier colección de archivos de texto, como los archivos Markdown que contienen capítulos de un libro.

Es posible que no desee que el VCS maneje todos los archivos en los directorios de su proyecto, por lo que debe poder designar los archivos cuya versión desea controlar. Esto los agrega a la vista de control de versiones del proyecto. Serán monitoreados por cambios.

Otra forma de lograr esto es usar una lista de ignorados. Esto le dice a Git qué archivos, directorios o tipos de archivos debe ignorar siempre.

Con el tiempo, a medida que se agreguen nuevos archivos al proyecto, será necesario agregar algunos al sistema de control de versiones. En Git, esto es manejado por el add dominio. En realidad, el add comando hace doble servicio, como veremos.

Para mantener un historial de los cambios que se han realizado en el proyecto, periódicamente le pedirá a Git que almacene una instantánea del estado del proyecto, usando el commit dominio. Aquí es donde el add el comando vuelve a aparecer en nuestro flujo de trabajo. usamos el add comando para decirle a Git cuál cambió archivos que queremos tener incluidos en la instantánea. Entonces usamos commit para decirle a Git que cree la instantánea.

Configuración del comando de confirmación

La información sobre la confirmación se almacena con él, por lo que siempre es posible saber quién realizó la confirmación, cuándo y qué contiene. Algunos de estos metadatos se capturan en el momento de la confirmación, como el mensaje de confirmación.

Los metadatos relativos a la identidad de los miembros del equipo de desarrollo pueden ser configurados por cada usuario, para evitar proporcionar repetidamente la misma información.

Para configurar su nombre globalmente para todos los repositorios en su computadora, use este comando.

git config --global user.name "Dave McKay"

Para verificar que se haya configurado su nombre, use este comando.

git config --global user.name

Si necesita usar un nombre diferente en un repositorio en particular, cambie al directorio del proyecto y use el mismo comando sin el --global opción.

git config user.name "McKay, David"

git config user.name

Ahora tenemos un nombre de usuario predeterminado diferente para este repositorio, y nuestro nombre global todavía se usa para otros repositorios.

De manera similar, podemos configurar una dirección de correo electrónico globalmente o para un solo repositorio al incluir u omitir el --global opción.

git config user.email "[email protected]"

git config --global user.email "[email protected]"

git config user.email

git config --global user.email

Estos ajustes se guardan en archivos de configuración. La configuración global de Git se mantiene en «~/.gitconfig», y la configuración específica del repositorio se mantiene en el archivo «.git/config» del repositorio.

El commit El comando hace referencia y usa estos valores mientras opera.

Usando el comando de confirmación

El uso básico de la commit El comando es tomar los archivos que se encuentran en el área de preparación, conocida como índice, y almacenarlos como una confirmación en la rama actual del repositorio.

Un compromiso básico

Tenemos un proyecto con un archivo modificado. Usaremos el add Comando para preparar el archivo, luego confirmarlo. estamos usando el -m (mensaje de confirmación) para que podamos proporcionar una breve descripción del propósito de los cambios. Si no usamos esta opción, se nos solicita un mensaje de confirmación cuando se lleva a cabo la confirmación. Es más conveniente agregar uno en la línea de comando.

git add jibber.c

git commit -m "Updated help text"

Si usamos el git log comando podemos revisar los detalles de las confirmaciones, en orden cronológico, con la confirmación más reciente en la parte superior de la lista.

git log

Las confirmaciones se muestran en less.

La confirmación se ha etiquetado con el nombre y la dirección de correo electrónico que proporcionamos anteriormente, y nuestro mensaje de confirmación también se registra.

Archivos de almacenamiento automático

La preparación de muchos archivos puede llevar un poco de tiempo. Un enfoque diferente es utilizar el -A (todas) opción con add.

Esto organiza automáticamente todos modificado archivos junto con todos actualmente sin seguimiento archivos La preparación de archivos sin seguimiento respeta la configuración de su archivo «.gitignore». Git no organizará los archivos que le hayas dicho que no quieres que se incluyan. Finalmente, los archivos en el índice que ya no están en el directorio de trabajo son remoto del índice.

Claramente, el -A opción puede hacer que sucedan muchas cosas a la vez. El --dry-run La opción le brinda una vista previa de los cambios sin realizarlos realmente.

git add -A --dry-run

En nuestro ejemplo, organizará dos archivos existentes modificados y dos archivos nuevos. Sigamos adelante y usemos el -A opción antes de usar la commit dominio.

git add -A

git commit -m "Enhanced parsing"

Podemos ver que en total se modifican cuatro archivos. Dos de ellos son los archivos recién creados, que se enumeran.

Puesta en escena y compromiso al mismo tiempo

El commit el comando tiene minúsculas -a (todas) la opción. Esto realiza la puesta en escena y la confirmación de archivos en un solo paso.

El commit -a etapas de opciones y compromisos modificados existente archivos, y elimina archivos del índice si se han eliminado de su directorio de trabajo. Él no organizar automáticamente los archivos sin seguimiento.

Como el add comando, el comando de confirmación tiene un --dry-run opción que le permite obtener una vista previa de sus acciones antes de ejecutarlo.

git commit -a --dry-run

Ahora vamos a ejecutar el comando.

git commit -a --dry-run

Los archivos están organizados y comprometidos para nosotros.

Comprometerse con una sucursal diferente

Si ha realizado algunos cambios en los archivos de su directorio de trabajo y se da cuenta de que no revisó la rama correcta, debe confirmar los cambios en la rama correcta sin afectar la rama actual.

Git no tiene un comando para comprometerse con una rama diferente. Pero puedes rectificar esta situación con un poco de destreza Git.

Usaremos el Git stash comando para hacer una copia de los cambios. Luego revisaremos la rama correcta y aplicaremos los cambios desde el alijo. Para aplicar los cambios ocultos estamos usando el pop mando en lugar de la apply dominio. El pop El comando aplica los cambios y también los elimina del alijo.

Hemos hecho algunos cambios en nuestro repositorio new-parser rama. Deberían haber sido hechos en el classic-parser rama.

git stash

git checkout classic-parser

git stash pop

Ahora podemos realizar un commity actualice esta rama.

git commit -a -m "Added pre-parser functions"

Si volvemos a la new-parser branch podemos ver que está actualizado, lo que significa que los cambios se han eliminado de su directorio de trabajo, y su repositorio y archivos están sincronizados.

git checkout new-parser

git status

RELACIONADO: Cómo actualizar y mantener ramas separadas de Git

Hacer cambios en las confirmaciones

Si necesita mejorar su mensaje de confirmación, tal vez haya detectado un error tipográfico en él, o si olvidó preparar un archivo que debería haberse incluido en la confirmación, puede usar el --amend opción de arreglar las cosas. La advertencia es que esto no debe usarse en confirmaciones que se han enviado a un repositorio remoto.

En nuestro último mensaje de confirmación, «fraze» debería haber sido «frase». si usamos git log podemos ver esto.

Para corregir esto, usaremos el --amend opción como esta.

git commit --amend -m "Optimized phrase identification"

si usamos git log una vez más, podemos ver que la confirmación anterior ha sido reemplazada por una nueva con el mensaje de confirmación corregido.

Si queremos agregar un archivo que olvidamos preparar, podemos confirmar ese archivo para que aparezca como parte de la confirmación anterior.

usaremos add para preparar el archivo, luego haga una confirmación con el --amend opción. El --no-edit opción significa que no necesitamos proporcionar un nuevo mensaje de confirmación. El mensaje de confirmación anterior se conserva.

git add jibber.c

git commit --amend --no-edit

Eliminación de cambios de una confirmación

Si sin darte cuenta preparaste y confirmaste un archivo que no era tu intención, puedes eliminar ese archivo de la confirmación usando el reset dominio. Restableceremos la confirmación de nuevo al área de ensayo o índice. Luego, eliminaremos el archivo y volveremos a confirmar el resto de los archivos.

Para restablecer la última confirmación en el área de preparación, usamos el reset --soft dominio. HEAD~ es la abreviatura de «el compromiso detrás del HEAD de la línea de tiempo del compromiso del proyecto», o en inglés, «el último compromiso».

git reset --soft HEAD~

Para eliminar el archivo que no debería haber sido incluido, usamos el reset --mixed dominio. Esto restablece esos cambios nuevamente en el directorio de trabajo, recreando el archivo modificado como un archivo no preparado y no confirmado.

git reset --mixed jibber.c

Necesitamos confirmar los otros archivos que quedan en el índice.

git commit -m "Experimental tweaks"

Los otros dos archivos que estaban en la confirmación original se vuelven a confirmar para nosotros.

RELACIONADO: Cómo corregir, editar o deshacer confirmaciones de Git (cambio del historial de Git)

Revertir una confirmación completa

A veces, deshacer una confirmación completa es lo más fácil de hacer. Devuelve el directorio de trabajo y el repositorio al estado en el que se encontraban antes de confirmar.

Necesitamos usar el ID de referencia hash de la confirmación. Podemos encontrar esto usando git log:

Copie esa referencia y utilícela en el revert dominio:

git revert e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8

Esto abrirá su editor predeterminado para que pueda editar un mensaje de reversión. Hay un mensaje predeterminado ingresado para usted. Puede usar esto o editarlo a su gusto.

Cuando esté satisfecho con su mensaje de reversión, guarde el archivo y salga del editor. En nano, haces esto con «Ctrl+O» y «Ctrl+X».

Usando git log una vez más, podemos ver que se ha agregado un nuevo compromiso que deshace los cambios del compromiso revertido.

La navaja suiza Git

Obviamente, commit es uno de los comandos Git más importantes. Puede hacer mucho, así que hay mucho que aprender. Familiarizarse con sus funciones menos utilizadas es tiempo bien invertido. Cuando necesite corregir un error, ahora mismo, se alegrará de haberse preparado con anticipación.

RELACIONADO: Cómo usar la fusión de Git

Para retirar una rama de un repositorio remoto, use el comando ‘git fetch’ y luego ‘git branch -r’ para listar las ramas remotas. Elija la rama que necesita y use un comando de la forma ‘git checkout -b new-branch-name origin/remote-branch-name’. Si usa varios repositorios, cambie la parte de ‘origen’ del comando de pago al nombre del control remoto desde el que desea pagar la sucursal.

Si su equipo de desarrollo usa Git, eventualmente necesitará verificar el trabajo de otra persona como una rama desde un repositorio remoto. Como la mayoría de las acciones de sucursal en Git, cambiar a una sucursal remota es bastante simple.

Git, sucursales y controles remotos

La filosofía de Git es bifurcarse a menudo. Las ramas permiten que se lleve a cabo el desarrollo sin alterar la base del código principal. Cuando esté satisfecho de que su nuevo código probado está listo, fusione su nueva rama en otra rama. Por lo general, esta es la rama principal o maestra, pero puede fusionar dos ramas cualesquiera.

Debido a esta flexibilidad, y la forma ligera y rápida en que Git maneja las ramificaciones y fusiones, se transformó la ramificación. En los sistemas de control de versiones anteriores, la ramificación era un gran problema. La ramificación y la fusión eran lentas y propensas a errores. Git les dio a los desarrolladores una bifurcación fácil y rápida que se usa para respaldar muchos flujos de trabajo diferentes.

Si trabaja o se ofrece como voluntario como parte de un equipo de desarrollo que usa Git, tendrá un repositorio de Git «central», alejado de la computadora de cada ingeniero de software. Esto se conoce como el repositorio remoto, o simplemente el «remoto». Es donde se envían las confirmaciones y los cambios a su repositorio local cuando realiza una inserción.

Por supuesto, eso es lo que están haciendo los otros desarrolladores también. Esto facilita la colaboración. Si necesita acceder al trabajo de otro desarrollador, simplemente recupere su código de una sucursal en el repositorio remoto. Si necesitan acceder a su trabajo, recuperarán su código de una sucursal en el repositorio que rastrea una de sus sucursales locales.

En Git, un proyecto de desarrollo puede tener varios controles remotos. Sin embargo, una sucursal local solo puede rastrear una única sucursal remota. Por lo tanto, mientras esté trabajando con el control remoto apropiado, verificar una sucursal remota con varios controles remotos es lo mismo que usar un solo control remoto.

Encontrar sus sucursales locales

Es necesario evitar conflictos de nombres. Si tiene una sucursal local que tiene el mismo nombre que la sucursal remota que va a verificar, tiene dos opciones. Puede cambiar el nombre de su sucursal local y consultar la sucursal remota. De esa forma, su sucursal local que rastrea la sucursal remota tiene el mismo nombre que la sucursal remota. O bien, puede verificar la rama remota y decirle a Git que cree una rama de seguimiento local con un nuevo nombre.

Para averiguar los nombres de las sucursales en su repositorio local, use el git branch dominio.

git branch

Este repositorio local tiene una rama maestra y otras tres ramas. El asterisco indica cuál es la rama actual. Pasar de una sucursal a otra requiere verificar la sucursal con la que desea trabajar.

git checkout new-feature

git status

El primer comando cambia la rama por nosotros, de modo que «nueva característica» es la rama actual. Él git status comando verifica eso para nosotros.

Podemos saltar de una sucursal a otra, realizar nuevos cambios, extraer actualizaciones del control remoto y enviar actualizaciones locales al control remoto.

RELACIONADO: Cómo actualizar y mantener ramas separadas de Git

Comprobación de una sucursal remota

Hay una rama en el repositorio remoto que no está presente en nuestra máquina. Una desarrolladora llamada Mary ha creado una nueva función. Queremos cambiar a esa sucursal remota para poder construir esa versión del software localmente.

Si realizamos un fetchGit recuperará los metadatos del repositorio remoto.

git fetch

porque esta es la primera fetch lo hemos hecho desde que Mary empujó su rama al repositorio remoto. Nos dicen que hay una nueva rama llamada «origen/característica de María». El nombre predeterminado para el primer repositorio remoto agregado a un proyecto es «origen».

Ya sea que veamos este mensaje o no, siempre podemos pedirle a Git que enumere las ramas en el repositorio remoto.

Él -r (remoto) le dice a Git que informe sobre las ramas que están en el repositorio remoto.

git branch -r

El punto a tener en cuenta aquí es que Git está comprobando su local copia de los metadatos del control remoto. Por eso usamos el git fetch para asegurarse de que la copia local de los metadatos esté actualizada.

Una vez que localizamos la sucursal que queremos, podemos seguir adelante y verificarla. usamos el git checkout comando con el -b (sucursal), seguido del nombre que usaremos para la sucursal local, seguido del nombre de la sucursal remota.

git checkout -b mary-feature origin/mary-feature

Podemos ver que revisamos la rama remota y creamos una rama local que rastreará los cambios en la rama remota.

git branch

Nuestra nueva sucursal local es ahora nuestra sucursal de trabajo actual.

Manejo de conflictos de nombres

Si tiene una sucursal local que tiene el mismo nombre que la sucursal remota, puede cambiar el nombre de su sucursal local antes de verificar la sucursal remota, o verificar la sucursal remota y especificar un nombre de sucursal local diferente.

Para retirar la sucursal remota en una sucursal local con un nombre diferente, podemos usar el mismo comando que usamos anteriormente y elegir un nuevo nombre de sucursal local.

git checkout -b mary-test origin/mary-feature

Esto crea una rama local llamada «mary-test» que rastreará las confirmaciones locales en esa rama. Las pulsaciones irán a la rama remota «origin/mary-feature».

Esta es probablemente la mejor manera de manejar los conflictos de nombres locales. Si realmente desea mantener el mismo nombre de la sucursal local y remota, deberá cambiar el nombre de su sucursal local antes de verificar la remota. Cambiar el nombre de una rama es trivial en Git.

git branch -m mary-feature old-mary-branch

Ahora puede verificar la rama remota «origin/mary-feature».

Manejo de múltiples repositorios remotos

Si tiene varios repositorios remotos configurados, debe tener cuidado de estar trabajando con el repositorio apropiado cuando desproteja la sucursal remota.

Para listar sus repositorios remotos, use el remote comando con el -v (ver) opción.

git remote -v

Para ver todas las sucursales disponibles, debemos obtener los metadatos de todos nuestros controles remotos y luego enumerar las sucursales remotas.

git fetch --all

git branch --all

Podemos ver que la sucursal que queremos está en el control remoto «origen». El comando para comprobarlo está en el mismo formato que ya hemos usado. Necesitamos especificar el nombre remoto, «origen», así como el nombre de la sucursal, «mary-feature».

git checkout -b mary-feature origin/mary-feature

RELACIONADO: Cómo cambiar, agregar y eliminar controles remotos de Git

Antes de pagar

Antes de pagar, tenga en cuenta algunas cosas y estará bien.

Asegúrese de evitar conflictos de nombres. Si tiene una sucursal local con el mismo nombre que la sucursal remota, decida si cambiará el nombre de la sucursal local o creará una sucursal con un nombre diferente para rastrear la sucursal remota.

Si usa varios repositorios remotos, asegúrese de usar el remoto correcto.

RELACIONADO: Git rebase: Todo lo que necesitas saber

Los investigadores de ciberseguridad de X41 y GitLab han descubierto tres vulnerabilidades de alta gravedad en el sistema de control de versiones distribuidas de Git.

Las fallas podrían haber permitido a los actores de amenazas ejecutar código arbitrario en los puntos finales de destino al explotar las vulnerabilidades de desbordamiento de búfer basadas en montón, dijeron los investigadores. De los tres defectos, dos ya tienen parches alineados, mientras que hay una solución disponible para el tercero.

XetHub, con sede en Seattle, una startup que facilita a las empresas el uso de Git para la gestión de datos, anunció hoy que ha recaudado una ronda de financiación inicial de 7,5 millones de dólares dirigida por Madrona. La idea básica aquí es permitir que los desarrolladores trabajen con datos de la misma manera que trabajan con código, incluidas todas las funciones de colaboración que permite una herramienta como Git. El equipo describe XetHub como una «plataforma de almacenamiento colaborativo para la gestión de datos».

La empresa fue cofundada por Yucheng Low (CEO), Ajit Banerjee y Rajat Arya, un equipo con años de experiencia trabajando con grandes plataformas de datos. De hecho, Low cofundó previamente la startup de ML Turi, donde Arya fue la primera empleada. Apple adquirió la empresa en 2016, lo que permitió a Low y Arya trabajar en varias partes de la pila de la plataforma ML de Apple, con Arya a la cabeza del equipo de plataforma de datos de Apple, por ejemplo. También fue en Apple donde los dos conocieron a Banerjee, quien anteriormente trabajó en Inktomi, Amazon y Facebook. Anteriormente también fundó dos startups.

Durante el tiempo que trabajaron en la plataforma de datos de Apple, el equipo se dio cuenta de que aún quedaba mucho por mejorar en el ámbito de la gestión de datos.

“Realmente no debería ser una sorpresa, pero los datos son mucho más importantes que todo lo demás. Más importante que el modelo, que cualquier otra cosa”, me dijo Low. “Administrar dónde almacena estos datos, cómo colabora con estos datos es realmente fundamental. Sin embargo, lo que vemos es que la forma en que administramos los datos hoy realmente se parece a cómo se hizo el código fuente hace 30 años, lo que significa que el control de versiones o la colaboración se realiza copiando y pegando. A veces hay una versión más elaborada, pero en última instancia, todavía es copiar y pegar si quiero asegurarme de que nadie más toque lo que estoy haciendo”.

Al igual que los desarrolladores se han pasado a herramientas como Git para colaborar en su código fuente, XetHub quiere permitirles usar estas mismas primitivas familiares para trabajar con datos.

“La forma en que lo pensamos es que, por primera vez, realmente permitimos que los desarrolladores trabajen en los datos exactamente de la misma manera que el código”, dijo Low. Señaló que el equipo tenía como objetivo crear una herramienta que no solo imitara una experiencia similar a Git, sino que preservara la experiencia central del usuario de Git, incluidas todas las integraciones con las que los desarrolladores están familiarizados.

Actualmente, el servicio puede manejar repositorios con hasta 1 TB de datos, con planes de expandir esto a 100 TB pronto. Pocos desarrolladores querrán clonar un repositorio grande como este, por lo que una característica ingeniosa aquí es que los desarrolladores también pueden montar estos repositorios y hacer que se comporten como un sistema de archivos local, sin importar si está en su computadora portátil o en un clúster de GPU grande. También vale la pena señalar que la herramienta es independiente de los formatos de archivo.

Desde una perspectiva de marketing, el equipo está enfocando sus esfuerzos en los equipos de IA/ML, pero los usuarios obviamente pueden usar XetHub para administrar cualquier tipo de datos.

Xethub ahora está disponible públicamente con una edición comunitaria gratuita que puede usar para administrar hasta 20 GB de almacenamiento deduplicado. Low me dice que la compañía ya está hablando con algunos clientes empresariales, pero el equipo aún no está listo para dar nombres.

“Yucheng y el excepcional equipo de XetHub han estado innovando con el aprendizaje automático durante más de una década y luego han aplicado sus habilidades en la empresa de tecnología de consumo más icónica: Apple. XetHub permite a los desarrolladores trabajar con grandes conjuntos de datos, en colaboración con otros, para crear aplicaciones inteligentes y generativas”, dijo Matt McIlwain, director general de Madrona. “El desarrollo y la implementación de estas aplicaciones están limitados por la infraestructura heredada y los flujos de trabajo de datos complejos, y XetHub aborda estos puntos débiles desde el punto de vista del desarrollador”.

Para fusionar una rama de desarrollo en la rama actual, use «git merge dev-branch-name». Si recibe advertencias de conflicto sobre una combinación, use «git merge –abort» para salir de ella, o edite los archivos afectados y luego confírmelos.

Git usa ramas para aislar flujos de desarrollo, para evitar que la rama de lanzamiento estable se contamine. Llevar el trabajo de una sucursal al flujo principal significa fusionar las sucursales. Así es como lo haces.

¿Qué es una fusión en Git?

Git fue diseñado para hacer que la bifurcación sea simple y rápida. A diferencia de otros sistemas de control de versiones, ramificarse en Git es un asunto trivial. Especialmente en proyectos de múltiples desarrolladores, la ramificación es una de las principales herramientas organizativas de Git.

Las ramas prueban nuevos esfuerzos de desarrollo para que el código se pueda modificar o agregar sin afectar el código en otras ramas, especialmente la rama principal o principal. Esto generalmente contiene la versión estable de su base de código.

Aislar estos cambios de su versión de código estable tiene mucho sentido. Pero tarde o temprano, el nuevo código se probará, revisará y aprobará para incorporarlo a la rama principal. En ese momento, debe fusionar su rama con la rama principal.

En realidad, las sucursales pueden tener sub-sucursales, por lo que podría estar fusionando su sucursal con alguna otra sucursal en lugar de la sucursal principal. Solo recuerda que las fusiones siempre toman una rama y la fusionan en una objetivo rama, cualquiera que sea esa rama. Si desea fusionar su rama maestra en otra rama, incluso puede hacerlo también.

Como la mayoría de las acciones en Git, realiza fusiones en su repositorio local y las envía a su repositorio remoto.

Preparándose para fusionar una rama en Git

Tenemos un pequeño proyecto de desarrollo con un repositorio Git local y un repositorio Git remoto. Creamos una rama llamada «bugfix14» de la rama «maestra» y trabajamos en una solución a un error.

Ese trabajo está completo y hemos probado nuestro código. Todo funciona como se esperaba. Queremos implementar esos cambios en la rama maestra para que nuestra solución sea parte de la próxima versión del software.

Hay que hacer un poco de preparación antes de realizar la fusión. Necesitamos asegurarnos de que la rama de destino (en este caso, la rama «maestra») y la rama que vamos a fusionar con ella estén actualizadas.

Para ello utilizaremos el git status dominio.

git status

• En la rama bugfix14: Esta es nuestra sucursal actual.
• Su rama está actualizada con ‘origen/corrección de errores’: La rama en nuestro repositorio local tiene el mismo historial de confirmaciones que la rama en el repositorio remoto. Eso significa que son idénticos.
• nada que cometer No hay cambios en el área de preparación que no se hayan confirmado.
• árbol de trabajo limpio: No hay cambios no preparados en el directorio de trabajo.

Todo eso indica que la rama está actualizada y que podemos continuar. Si alguno de estos indicara que existieron cambios, necesitaríamos organizarlos, confirmarlos y enviarlos al control remoto. Si alguien más ha trabajado en estos archivos, es posible que debamos extraer sus cambios del repositorio remoto.

Revisar la rama en la que nos vamos a fusionar simplifica el proceso de fusión. También nos permite verificar que está actualizado. Echemos un vistazo a la rama maestra.

git checkout master

git status

Obtenemos las mismas confirmaciones de que la rama «maestra» está actualizada.

RELACIONADO: Cómo elegir el modelo de ramificación y flujo de trabajo de Git adecuado para su equipo

Realizar una fusión

Antes de fusionarnos, nuestras confirmaciones se ven así.

La rama «bugfix14» se bifurcó de la rama «maestra». Hubo un compromiso con la rama «maestra» después de que se creó la rama «bugfix14». Ha habido un par de confirmaciones en la rama «bugfix14».

Nos hemos asegurado de que nuestras dos sucursales estén actualizadas y hemos verificado la sucursal «maestra». Podemos emitir el comando para fusionar la rama «bugfix14» en la rama «maestra».

git merge bugfix14

Se produce la fusión. La rama «bugfix14» aún existe, pero ahora los cambios que se realizaron en esa rama se fusionaron en la rama «maestra».

En este caso, el comando merge realiza una fusión de tres vías. Solo hay dos ramas, pero hay tres compromisos involucrados. Son el encabezado de cualquiera de las ramas y una tercera confirmación que representa la acción de fusión en sí.

Para actualizar nuestro repositorio remoto, podemos usar el empujar git dominio.

git push

Algunas personas prefieren eliminar las ramas laterales una vez que las han fusionado. Otros se encargan de preservarlos como un registro de la verdadera historia de desarrollo del proyecto.

Si desea eliminar la sucursal, puede hacerlo mediante el git branch comando con el -d (eliminar) opción.

git branch -d bugfix14

Para eliminar la rama en el repositorio remoto, use este comando:

git push origin --delete bugfix14

Tendrás un historial de confirmación lineal, pero no será el verdadero historial.

RELACIONADO: Cómo eliminar ramas de Git en repositorios locales y remotos

Realizar una combinación de avance rápido en Git

Si no ha realizado ninguna confirmación en la rama «maestra», su historial se verá así. También tendrá este aspecto si ha modificado la base de su rama de desarrollo para que se adjunte al final de la rama «maestra».

Debido a que no hay confirmaciones en la rama «maestra», para fusionar la rama «bugfix15», todo lo que Git tiene que hacer es apuntar el puntero principal «maestro» a la última confirmación de la rama «bugfix15».

Podemos usar lo habitual git merge dominio:

git merge bugfix15

Eso nos da este resultado.

Que es lo mismo que esto:

Que es lo mismo que esto:

Git realizará una fusión de avance rápido siempre que puede. Si las confirmaciones en la rama «maestra» significan que no es posible una fusión de avance rápido, Git usará un fusión de tres vías.

no puedes fuerza una combinación de avance rápido, después de todo, puede que no sea posible, pero puede declarar que será una combinación de avance rápido o nada. Hay una opción que le indica a Git que use una combinación de avance rápido si puede, pero que no haga una combinación de tres vías si no puede. la opción es --ff-only (solo combinación de avance rápido).

Esto fusiona la rama «bugfix15» en la rama «maestra», pero solo si es posible una fusión de avance rápido.

git merge --ff-only bugfix15

Git se quejará y saldrá si no es posible.

git merge --ff-only bugfix16

En este caso, ha habido compromisos con la rama «maestra», por lo que no es posible una fusión de avance rápido.

Cómo resolver conflictos de fusión en Git

Si se han cambiado las mismas partes del mismo archivo en ambas ramas, las ramas no se pueden fusionar. Se requiere interacción humana para resolver las ediciones conflictivas.

Aquí, hemos realizado cambios en un archivo llamado «rot.c» en una rama llamada «bugfix17» que queremos fusionar con la rama «maestra». Pero «rot.c» también se ha cambiado en la rama «maestra».

git merge bugfix17

Cuando intentamos fusionarlo, recibimos una advertencia de que hay conflictos. Git enumera los archivos en conflicto y nos dice que la fusión falló. Podríamos retroceder completamente usando el --abort opción:

git merge --abort

Pero resolver fusiones no es tan aterrador como parece. Git ha hecho algo de trabajo para ayudarnos. Si editamos uno de los archivos en conflicto, en nuestro caso, solo tenemos uno, encontraremos las secciones de código en conflicto resaltadas para nosotros.

Cada conflicto está delimitado por siete caracteres menores que “<<<<<<<” y siete caracteres mayores que “>>>>>>>“, con siete signos de igual”=======» entre ellos.

• El código sobre los signos de igual es de la rama que estás fusionando en.
• El código debajo del signo igual es el código de la sucursal que está intentando unir.

Puede buscar fácilmente uno de los conjuntos de siete caracteres y pasar de un conflicto a otro a través de su archivo. Para cada conflicto, debe elegir qué conjunto de ediciones va a conservar. Debe editar el código que está rechazando y las líneas de siete caracteres que ha agregado Git.

Vamos a mantener el código de la rama «bugfix17». Después de editar, nuestro archivo se ve así.

Ahora podemos continuar con la fusión. Pero tenga en cuenta que usamos el commit comando para hacerlo, no el merge dominio.

Confirmamos el cambio preparando el archivo y confirmándolo como de costumbre. Comprobaremos el estado antes de realizar la confirmación final.

git add rot.c

git status

git commit -m "Merged bugfix17"

La fusión está completa. Ahora podemos enviar esto a nuestro repositorio remoto.

RELACIONADO: Cómo corregir, editar o deshacer confirmaciones de Git (cambio del historial de Git)

Todo se fusiona eventualmente

Todas las ramas deben fusionarse, eventualmente, para que los cambios en ellas no queden huérfanos y olvidados.

Fusionar sucursales es fácil, pero lidiar con conflictos puede complicarse en equipos ocupados y más grandes. La resolución de conflictos puede requerir el aporte de cada desarrollador solo para explicar qué hace su código y por qué hicieron los cambios. Debe comprender eso, antes de que pueda tomar una decisión informada sobre qué ediciones conservar.

Lamentablemente, Git no puede ayudar con eso.

RELACIONADO: ¿Debería usar un cliente GUI Git?

¿No quiere enviar su código a un repositorio Git alojado? Luego ejecute su propio servidor Git internamente. Gogs es la forma más fácil de hacerlo. Aquí se explica cómo configurarlo.

El problema con los repositorios alojados en la nube

Sin duda, Git es el sistema de control de versiones por excelencia. Incluso con proyectos de un solo desarrollador, Git proporciona valor y beneficios debido a su funcionalidad de control de versiones. Para proyectos de múltiples desarrolladores, Git trae otra dimensión por completo. Con un repositorio central y remoto, Git habilita una capacidad de colaboración que transformará la forma en que sus equipos de desarrollo ven el control de versiones.

Es por eso que existen servicios como GitHub, GitLab y BitBucket, y por qué han visto tal aceptación y crecimiento. Solo GitHub alberga más de 200 millones de repositorios. Pero los repositorios alojados en la nube no se adaptan a todos. La mayoría de ellos cobran por alojar repositorios privados. Algunos de ellos imponen límites de almacenamiento, límites de usuarios o límites de transferencia de datos en cuentas gratuitas.

Incluso si el uso y el tamaño de su equipo se ajustan a las restricciones de las cuentas gratuitas, o incluso si está dispuesto a pagar por una licencia comercial, es posible que no se sienta cómodo almacenando su base de código en la nube.

La alternativa es alojar su propio servidor Git, ya sea localmente en su propia red o accesible de forma privada en su propia nube privada. Configurar un servidor Git que proporcione una interfaz web con la apariencia y las opciones que GitHub y sus amigos han hecho tan populares solía requerir un cierto grado de habilidad técnica. Ahí es donde entra Gogs.

¿Qué es Gogs?

Gogs es un proyecto relativamente nuevo, escrito en Go, que ofrece una instancia de Git fácil de instalar pero con todas las funciones. No hay límites para el tamaño del equipo, el almacenamiento o cualquier otra cosa.

Incluso si es un programador aficionado, usar Gogs como un servicio Git en su red local le permite almacenar una copia de su código fuera de su máquina de desarrollo. Cuando usted, o alguien más, quiera trabajar en una computadora diferente o nueva, simplemente clone un repositorio de su servidor Gogs tal como lo haría desde GitHub.

Si va a usar Gogs con frecuencia, probablemente le resulte conveniente agregarlo a las aplicaciones de inicio de la computadora en la que se está ejecutando.

RELACIONADO: Cómo ejecutar un programa de Linux al inicio con systemd

Cómo instalar gafas

Para instalar Gogs, descargue el archivo de almacenamiento apropiado, descomprímalo y ejecute el binario principal. Completa algunos formularios y Gogs inicializa su repositorio y lo agrega como usuario administrador. Luego puede navegar a su instancia de Gogs y agregar usuarios y crear repositorios.

Gogs utiliza una base de datos para su almacenamiento de back-end. Es compatible con MySQL, MariaDB, PostgreSQL y TiDB. Si desea utilizar uno de estos potentes motores de base de datos, debe localizarlo e instalarlo usted mismo antes de instalar Gogs. Para equipos más pequeños, puede usar SQLite3. Si opta por SQLite3, está instalado para usted. Por supuesto, necesitarás tener git instalado, también.

Descargue el binario apropiado.

• Para la mayoría de las distribuciones modernas de Linux, descargue el archivo «Linux amd64».
• Si está utilizando una versión de Linux de 32 bits, descargue el archivo «Linux 386».
• Si está instalando en una Raspberry Pi 2 o más tempranodescargue el archivo “Linux armv7”.
• Si está instalando en una Raspberry Pi 3, 3+ o más tardedescargue el archivo «Linux armv8».
• Si está utilizando una Intel Mac, descargue el archivo «macOS amd64».
• Para una Apple Silicon Mac, descargue el archivo «macOS arm64».

Descargamos el archivo ZIP “Linux amd64”, para su instalación en una computadora de 64 bits con Ubuntu 22.10. El archivo es pequeño, solo unos 25 MB, así que no se sorprenda si se descarga muy rápido. Eso es normal.

Localice el archivo en su sistema de archivos. Si ha mantenido la ubicación de descarga predeterminada de su navegador, el archivo probablemente estará en su directorio «~/Descargas». Haga clic con el botón derecho y seleccione «Extraer» en el menú contextual. Algunos exploradores de archivos pueden usar «Extraer aquí» en su lugar.

Se extrae un directorio del archivo ZIP. Lleva el nombre del archivo descargado. En nuestro caso, se llamó “gogs_0.11.91_linux_amd64”.

Haga doble clic en el directorio extraído y verá otro directorio llamado «gogs».

Haga doble clic en el directorio «gogs». Verá los archivos y directorios de Gogs. Haga clic con el botón derecho en la ventana del explorador de archivos y seleccione «Abrir en terminal» en el menú contextual.

Para iniciar su instancia de Gogs, escriba este comando:

./gogs web

Gogs se inicia y te dice que está escuchando en el puerto 3000.

Conéctese a su servidor de Gogs abriendo un navegador web y navegando hasta la dirección IP o el nombre de red de la computadora en la que se está ejecutando Gogs. Agregue “:3000” después de la dirección IP o el nombre de la red. No incluya ningún espacio en blanco.

Si está navegando en la computadora en la que se ejecuta Gogs, puede usar «localhost» como el nombre de la máquina, como «localhost: 3000». Nuestra computadora Gogs se llama «ubuntu-22-10.local», por lo que desde una computadora diferente en la misma red, la dirección que debemos buscar es «ubuntu-22-10.local:3000», incluido el número de puerto.

La primera vez que haga esto, verá el formulario que captura cierta información de configuración inicial.

Lo primero que debemos hacer es seleccionar «SQLite3» en el menú desplegable «Tipo de base de datos» e ingresar su nombre de usuario en el campo «Ejecutar usuario».

Si desea configurar notificaciones por correo electrónico, deberá configurar algunos pasos adicionales. Deberá retransmitir los correos electrónicos a través de un servidor de correo de Protocolo simple de transferencia de correo (SMTP) que tenga permiso para usar. Si es usuario de Google Gmail, puede utilizar el servidor SMTP de Gmail de Google.

Esto requerirá configuraciones en el servidor de correo para permitir que su cuenta acepte y retransmita el correo electrónico. Estas configuraciones varían de un servidor de correo a otro.

Gogs requiere que ingrese la siguiente información sobre su servidor de correo electrónico.

• Anfitrión SMTP: La dirección y el puerto del servidor de correo electrónico. En nuestro ejemplo, este es el servidor SMTP de Google en smtp.gmail.com:587.
• Desde: La dirección de correo electrónico desde la que se enviará el correo electrónico. Para Gmail, esta debe ser la dirección de correo electrónico de Gmail de la cuenta que está utilizando.
• Correo electrónico del remitente: Debe ser el mismo que el anterior. Esta es la identificación de la cuenta de correo electrónico que Gogs usará para comunicarse con el servidor SMTP.
• Contraseña del remitente: Esto es no la contraseña de la cuenta de Gmail. Es el contraseña específica de la aplicación obtiene de Google cuando configura su cuenta para permitir que una aplicación envíe correos electrónicos en su nombre.
• Habilitar confirmación de registro: para que Gogs verifique los correos electrónicos de los usuarios, seleccione esta casilla de verificación. Los nuevos usuarios recibirán un correo electrónico con un enlace. Deben hacer clic en para demostrar que la dirección de correo electrónico es genuina y está bajo su control.
• Habilitar notificación de correo: marque esta casilla de verificación para permitir las notificaciones por correo electrónico de Gogs.

Por supuesto, si no quiere que le molesten los correos electrónicos, puede omitir todas las configuraciones de correo electrónico.

Haga clic en el botón azul «Instalar Gogs» cuando esté listo para continuar. Gogs escribe un archivo de configuración, inicializa el almacenamiento de la base de datos e inicia su instancia de Git.

Verá la página de inicio principal de Gogs.

La primera cuenta de usuario que cree obtendrá automáticamente derechos de administrador. Haga clic en el enlace «Registrarse».

Complete el formulario «Registrarse» con su nombre de cuenta, una contraseña para esta cuenta (ingrésela dos veces) y los dígitos del Captcha. Haga clic en el botón verde «Crear nueva cuenta». Verá la página «Iniciar sesión».

Ingrese su nombre de cuenta y contraseña, y haga clic en el botón verde «Iniciar sesión».

Un recorrido rápido por Gogs

Si está familiarizado con cualquier otra instancia de Git a la que se accede a través de la web, se orientará fácilmente en Gogs.

La vista del «Panel de control» de Gogs es un poco escasa hasta que tenga un repositorio con el que trabajar. Haga clic en el botón azul «+» y complete el formulario «Nuevo repositorio».

Pide un nombre de repositorio, ya sea privado o público, y una descripción.

Los siguientes tres campos crean archivos a partir de plantillas.

• El menú «.gitignore» le permite seleccionar una plantilla para su archivo «.gitignore» configurado con configuraciones de acuerdo con los idiomas seleccionados. Puede hacer más de una elección desde este menú, para atender a los repositorios que utilizan una combinación de tecnologías de desarrollo.
• El menú «Licencia» le permite elegir una licencia de una lista completa.
• El menú «Léame» tiene una sola opción, un archivo predeterminado «LÉAME.md».

Marque la casilla de verificación «Inicializar este repositorio con los archivos y la plantilla seleccionados» y haga clic en el botón verde «Crear repositorio».

Su nuevo repositorio se muestra para usted. Gogs creó nuestros tres archivos estándar para nosotros y los agregó al repositorio con el mensaje de confirmación «Confirmación inicial».

Clonamos el repositorio en nuestra computadora, agregamos un archivo llamado «ack.c», lo confirmamos y lo empujamos a nuestro repositorio remoto de Gogs. Todo esto se hizo usando comandos estándar de Git.

Como era de esperar, nuestro nuevo archivo aparece en nuestro repositorio de Gogs.

Al hacer clic en un archivo, se nos muestra el contenido del archivo individual. Los archivos de Markdown se interpretan para usted, con encabezados, enlaces, listas y todas las demás características de Markdown. Los archivos “README.md” generalmente se escriben en Markdown.

Al hacer clic en el ícono de lápiz «Editar», podemos editar directamente nuestro archivo «README.md». Agregamos más texto, usamos etiquetas Markdown para insertar hipervínculos y cursivas, y confirmamos nuestros cambios. Todo desde dentro de Gogs.

De vuelta en nuestra vista de repositorio, se muestra nuestro archivo «README.md» actualizado, y la entrada «README.md» en la lista de archivos muestra un nuevo mensaje de confirmación y la hora de actualización.

El servidor Git más fácil: sin excepción

Gogs es un triunfo absoluto. Combina perfectamente la funcionalidad con la simplicidad.

Fuera de la caja, satisfará las necesidades de la mayoría de los aficionados o pequeños equipos de desarrollo. Algunas de sus opciones avanzadas se activan al editar el archivo de configuración que, de forma predeterminada, se encuentra en «~/Downloads/gogs_0.12.10_linux_amd64/gogs/custom/conf/app.ini». Tenga en cuenta que la ruta reflejará la versión de Gogs que está utilizando.

La administración general del sistema se puede realizar desde el panel de administración, que se encuentra en Your Profile > Admin panel.

Aunque la documentación de Gogs es breve hasta el punto de ser concisa, eso significa que es fácil encontrar lo que está buscando, y las descripciones son lo suficientemente detalladas para que las siga.

Si desconfía de los repositorios alojados en la nube que, en última instancia, están bajo el control de otros, considere usar Gogs localmente. No perderás funcionalidad, pero ganarás control y privacidad garantizada.

RELACIONADO: Cómo verificar y actualizar su versión de Git

Para cambiar el nombre de la sucursal local actual, use «git branch -m new-name». Para cambiar el nombre de una rama local desde dentro de otra, usa «git branch -m old-name new-name». Para cambiar el nombre de una rama remota, elimínela con «git push origin –delete old-name», luego presione la rama local renombrada con «git push origin -u new-name».

La ramificación es un ejercicio trivial en Git. Desafortunadamente, las tareas triviales rara vez reciben la debida atención y ocurren errores. Si le has puesto un nombre incorrecto a una rama, tendrás que cambiarle el nombre. Así es como se hace.

Por qué los nombres de las sucursales son importantes en Git

Cualquier cosa que tuviera que ver con las ramas en los sistemas clásicos de control de versiones (VCS) era un gran problema. Requería un entendimiento coordinado de que se estaba agregando o fusionando una sucursal, y todas las personas que usaban ese repositorio tenían que asegurarse de no hacer nada, u olvidarse de hacer algo, para que la operación continuara y tuviera éxito.

Las operaciones que involucraban sucursales a menudo también eran muy lentas. Hubo una penalización de tiempo en el tope usando ramas. Git fue diseñado desde el principio para ser diferente. Debido a que es un sistema de control de versiones distribuido, cada usuario tiene una copia del repositorio completo en su máquina local.

La bifurcación en su máquina local no afecta a nadie más a menos que envíe la bifurcación a un repositorio remoto. Y en Git, las operaciones de sucursal están diseñadas para ser tan fáciles de usar como rápidas de completar. La ramificación en Git es muy barata en términos computacionales. Es una acción trivial dentro del repositorio local.

De hecho, se alienta a los desarrolladores a ramificarse, y ramificarse a menudo. Las sucursales son solo otra herramienta dentro de su VCS de la que se beneficia. Las ramas no son grandes cosas aterradoras en Git, son una de sus características más utilizadas.

Pero la familiaridad puede conducir al desprecio. O, al menos, a una consideración casual por las ramas. La ramificación puede ser rápida y simple en Git, pero aún debe concentrarse cuando crea una rama. Es fácil escribir mal el nombre de una rama o escribir el nombre incorrecto, lo que da como resultado una rama con un nombre incorrecto.

Si la rama se enviará al repositorio remoto en algún momento, debe escribirse correctamente. Si no es así, causará confusión cuando otros intenten usarlo.

RELACIONADO: ¿Cómo funcionan las ramas de Git?

Enumerar ramas en Git antes de cambiarles el nombre

Verificar cuáles son los nombres de las sucursales actuales es un buen primer paso. Él git branch el comando enumera las ramas para nosotros. Puedes ver las ramas en el repositorio local con este comando:

git branch

Las sucursales están listadas para nosotros. La rama actual está resaltada en verde y con un asterisco.

Para ver las ramas y sus compromisos, puede usar el show-branch dominio.

git show-branch

Puede ver las ramas en el repositorio remoto al incluir la opción -r (remoto).

git branch -r

Para ver sucursales locales y remotas con un solo comando, use el -a (todas) la opción.

git branch -a

Tenemos más sucursales locales que sucursales remotas. La rama «feature16» aún no se ha enviado al repositorio remoto. Eso es solo un aspecto de la operación normal, no un problema.

Nuestro problema es que la rama «feature19» debería haberse llamado «feature18». Así que ese es el error que vamos a corregir.

RELACIONADO: Cómo actualizar y mantener ramas separadas de Git

Cómo cambiar el nombre de una sucursal local en Git

Hay dos formas de cambiar el nombre de una sucursal localmente. Puede pagar la sucursal y cambiarle el nombre, o puede cambiar el nombre de la sucursal mientras trabaja en otra sucursal.

Para renombrar el Actual rama, asegúrese de que haya verificado y esté usando la rama que desea cambiar de nombre. Luego usa el git branch comando con el -m (mover) opción.

git checkout feature19

git branch -m feature18

Verificamos la rama «feature19» y la renombramos a «feature18». Veamos cómo se ven nuestras sucursales ahora.

git branch

Nuestra sucursal ahora tiene el nombre correcto en el repositorio local.

Si lo desea, puede cambiar el nombre de una sucursal cuando esté trabajando en otra sucursal. Aquí hay un ejemplo en el que estamos trabajando en la rama «maestra».

git branch

El comando que usamos es el mismo comando que antes, pero debemos proporcionar el nombre actual de la rama que estamos renombrando, así como el nuevo nombre que queremos que tenga.

git branch -m feature19 feature18

git branch

Nuevamente, la sucursal en nuestro repositorio local ha sido renombrada con el nombre correcto.

RELACIONADO: Cómo crear una nueva sucursal en GitHub

Cómo cambiar el nombre de una sucursal remota en Git

El repositorio remoto aún contiene la rama con el nombre anterior. Para cambiar el nombre de una rama remota, eliminamos la rama anterior y empujamos la nueva rama.

Si otros usuarios usan esta rama y le envían confirmaciones, debe hacer una extracción antes de cambiarle el nombre localmente. Esto garantiza que su repositorio local esté actualizado y que los cambios realizados por otros usuarios no se perderán. Regresar sus cambios a su repositorio antes de cambiar el nombre de la rama localmente significa que esos cambios estarán en la nueva rama cuando la vuelva a enviar al repositorio remoto.

Echemos un vistazo al estado de nuestras sucursales. Usaremos el -a (todas) opción para ver tanto las sucursales locales como las remotas.

git branch -a

Necesitamos eliminar «feature19» del repositorio remoto y enviar «feature18» al control remoto.

git push origin --delete feature19

Se le pedirá la contraseña para el repositorio remoto. Una vez que se haya realizado la eliminación, verá un mensaje de confirmación.

Ahora enviaremos nuestra nueva rama al control remoto y usaremos la opción -u (establecer upstream)

git push origin -u feature18

Nuevamente, se le pedirá su contraseña para el control remoto. La nueva rama se envía al control remoto y se nos dice que la rama «feature18» está configurada para realizar un seguimiento de los cambios en nuestra copia local de la rama.

Comprobemos una vez más en qué estado se encuentran nuestras sucursales locales y remotas.

git branch -a

Nuestra sucursal ha sido renombrada con éxito tanto local como remotamente, y la sucursal remota está rastreando los cambios en nuestra sucursal local.

RELACIONADO: Cómo eliminar ramas de Git en repositorios locales y remotos

Cambiar el nombre de las sucursales es simple

Con Git, cambiar el nombre de las ramas es simple. Si es la única persona que usa un repositorio o una rama que necesita renombrarse, es muy simple.

Si otros comparten la rama, asegúrese de comunicarles que va a cambiar el nombre de la rama y que deben impulsar cualquier trabajo no comprometido. Cuando hayan presionado, puede extraer la rama y luego cambiar el nombre de su rama de forma local y remota.

RELACIONADO: Cómo usar git con múltiples repositorios remotos

El comando Git rebase mueve una rama a una nueva ubicación en la cabecera de otra rama. A diferencia del comando de fusión de Git, rebase implica volver a escribir el historial de su proyecto. Es una gran herramienta, pero no rebase las confirmaciones en las que otros desarrolladores han basado el trabajo.

el git rebase El comando combina dos ramas del código fuente en una sola. el git merge comando hace eso también. Te explicamos qué rebase hace, cómo se usa y cuándo usar merge en cambio.

La explosión de Git

Frustrado con otros sistemas de control de versiones y sus lentas actualizaciones y confirmaciones, Linus Torvalds, famoso por el kernel de Linux, dedicó un mes en 2005 a escribir el suyo propio. Lo llamó Git.

Sitios como GitHub, GitLab y BitBucket han promovido simbióticamente y se han beneficiado de Git. Hoy en día, Git se usa a nivel mundial, con un masivo 98 por ciento de 71 mil encuestados en una encuesta de 2022 que usa Git como sistema de control de versiones.

Una de las principales decisiones de diseño de Git fue la velocidad. En particular, el trabajo con ramas tenía que ser lo más rápido posible. Las sucursales son una parte fundamental de los sistemas de control de versiones. Un repositorio de proyectos tendrá una rama principal o maestra. Aquí es donde se encuentra el código base del proyecto. El desarrollo, como las nuevas características, se lleva a cabo en ramas laterales segregadas. Esto evita que el trabajo realizado en las ramas estropee la rama principal y permite que se produzca un desarrollo simultáneo en diferentes partes de la base de código.

A medida que se completan los desarrollos en las ramas laterales, los cambios se transfieren a la rama maestra al fusionar la rama de desarrollo con la rama maestra. En otros sistemas de control de versiones, trabajar con sucursales era difícil y computacionalmente costoso. Trabajar con ramas en Git es muy rápido y muy ligero. Lo que antes era un ejercicio tedioso y evitado en otros sistemas, se volvió trivial en Git.

el git rebase El comando es otra forma de transferir los cambios de una rama a otra rama. los merge y rebase Los comandos tienen objetivos similares, pero logran sus fines de diferentes maneras y producen resultados ligeramente diferentes.

¿Qué es la fusión de Git?

Entonces, ¿qué es el Git? merge comando para? Digamos que ha creado una rama llamada dev-branch para trabajar en una nueva función.

Realiza algunas confirmaciones y prueba su nueva función. Todo funciona bien. Ahora desea enviar su nueva función al master rama. debes estar en el master rama para unir otra a ella.

Podemos asegurarnos de que estamos en el master ramificación revisándola explícitamente antes de fusionarnos.

git checkout master

Ahora podemos decirle a Git que fusione el dev-branch en la rama actual, que es la master rama.

git merge dev-branch

Nuestro merge se completa para nosotros. Si revisas el master ramificar y compilarlo, tendrá la característica recientemente desarrollada. Lo que Git realmente ha realizado es una combinación de tres vías. compara los commits más recientes en el master y dev-branch sucursales, y la confirmación en el master sucursal inmediatamente antes de la dev-branch fue creado. A continuación, realiza una confirmación en el master rama.

Las fusiones se consideran no destructivas porque no eliminan nada y no cambian nada del historial de Git. los dev-branch todavía existe, y ninguna de las confirmaciones anteriores se modifica. Se crea una nueva confirmación que captura los resultados de la combinación de tres vías.

Después de la fusión, nuestro repositorio de Git parece una línea de tiempo con una línea alternativa que se bifurca y luego regresa a la línea de tiempo principal.

los dev-branch sucursal se ha incorporado a la master rama.

Si tiene muchas sucursales en un proyecto, la historia del proyecto puede volverse confusa. Este suele ser el caso si un proyecto tiene muchos colaboradores. Debido a que el esfuerzo de desarrollo se divide en muchas rutas diferentes, el historial de desarrollo no es lineal. Desenredar el historial de confirmaciones se vuelve aún más difícil si las sucursales tienen sus propias sucursales.

Tenga en cuenta que si tiene cambios no confirmados en el master branch, deberá hacer algo con estos cambios antes de poder fusionar algo en él. Puede crear una nueva rama y confirmar los cambios allí, y luego realizar la fusión. Luego, deberá fusionar su rama temporal nuevamente en la rama principal.

Eso funciona, pero Git tiene un comando que logra lo mismo, sin tener que crear nuevas ramas. los stash El comando almacena los cambios no confirmados por usted y le permite recuperarlos con stash pop .

Los usarías así:

stash

git merge dev-branch

stash pop

El resultado final es una rama fusionada, con los cambios no guardados restaurados.

¿Qué es Git rebase?

el git rebase comando logra sus objetivos de una manera completamente diferente. Toma todas las confirmaciones de la rama en la que se va a reorganizar y las reproduce en el final de la rama en la que se está reorganizando.

Tomando nuestro ejemplo anterior, antes de realizar cualquier acción, nuestro repositorio de Git se ve así. Tenemos una sucursal llamada dev-branch y queremos mover esos cambios a la master rama.

Después de la rebase parece una única línea de tiempo de cambios completamente lineal.

los dev-branch ha sido eliminado, y las confirmaciones en el dev-branch se han agregado a la rama principal. El resultado final es el mismo que si las confirmaciones en el dev-branch en realidad se había comprometido directamente con el master rama en primer lugar. Las confirmaciones no solo se añaden al master rama, se «reproducen» y se agregan nuevos.

Esta es la razón por la cual el rebase comando se considera destructivo. La rama reorganizada ya no existe como una rama separada y el historial de Git de su proyecto se ha reescrito. No puede determinar en algún momento posterior qué confirmaciones se realizaron originalmente en el dev-branch.

Sin embargo, te deja con una historia simplificada y lineal. En comparación con un repositorio con docenas o incluso cientos de ramas y fusiones, leer el registro de Git o usar una GUI gráfica de Git para ver un gráfico del repositorio, un repositorio reorganizado es muy fácil de entender.

Cómo cambiar de base a otra rama

Probemos un git rebase ejemplo. Tenemos un proyecto con una rama llamada new-feature. Casarse rebase esa rama hacia el master rama como esta.

Primero, comprobamos que el master sucursal no tiene cambios destacados.

git status

Verificamos el new-feature rama.

git checkout new-feature

Le decimos a Git que rebase la rama actual en la rama maestra.

git rebase master

Podemos ver que todavía tenemos dos sucursales.

git branch

Cambiamos de nuevo a la master rama

git checkout master

Fusionamos la rama de nuevas funciones con la rama actual, que en nuestro caso es la master rama.

git merge new-feature

Curiosamente, todavía tenemos dos sucursales después de la fusión final.

La diferencia es que ahora el jefe de la new-feature rama y el jefe de la master rama están configurados para apuntar a la misma confirmación, y el historial de Git no muestra que solía haber una new-feature rama, aparte de la etiqueta de la rama.

Git Rebase vs. Merge: ¿Cuál debería usar?

no es un caso de rebase contra merge. Ambos son comandos poderosos y probablemente los usará a ambos. Dicho esto, hay casos de uso en los que rebase realmente no funciona tan bien. Desechar errores causados ​​por errores usando merge son desagradables, pero los errores de eliminación causados ​​por rebase es infernal

Si es el único desarrollador que usa un repositorio, hay menos posibilidades de que haga algo con rebase eso es desastroso. todavía podrías rebase en la dirección equivocada, por ejemplo, y rebase su rama principal en su new-feature rama. para conseguir tu master bifurcarse hacia atrás, necesitaría rebase otra vez, esta vez de su new-feature ramifica a tu master rama. Eso restauraría su master rama, aunque con una historia de aspecto extraño.

no usar rebase en sucursales compartidas donde es probable que otros trabajen. Tus cambios en tu repositorio van a causar problemas a muchas personas cuando envíes tu código rebasado a tu repositorio remoto.

Si su proyecto tiene varios colaboradores, lo más seguro es usar solo rebase en tu local repositorio, y no en sucursales públicas. Del mismo modo, si las solicitudes de extracción forman parte de sus revisiones de código, no use rebase. O al menos, no usar rebase después de crear la solicitud de extracción. Es probable que otros desarrolladores estén mirando sus confirmaciones, lo que significa que esos cambios están en una rama pública, incluso si no están en el master rama.

El peligro es que vas a rebase confirmaciones que ya se han enviado a un repositorio remoto, y es posible que otros desarrolladores ya hayan basado su trabajo en esas confirmaciones. tu local rebase hará que esos compromisos existentes desaparezcan. Si envía esos cambios al repositorio, no será popular.

Otros colaboradores tendrán que pasar por un complicado merge para que su trabajo sea devuelto al repositorio. Si luego vuelve a colocar sus cambios en su repositorio local, se enfrentará a deshacer un lío de cambios duplicados.

¿Rebase o no Rebase?

Rebase podría estar fuera de la ley en su proyecto. Puede haber objeciones culturales locales. Algunos proyectos u organizaciones consideran rebase como una forma de herejía y un acto de profanación. Algunas personas creen que el historial de Git debería ser un registro permanente e inviolable de lo que sucedió. Asi que, rebase podría estar fuera de la mesa.

Pero, usado localmente, en sucursales privadas, rebase es una herramienta útil.

Empujar después ha reorganizado y restringirlo a sucursales donde usted es el único desarrollador. O al menos, donde todo el desarrollo se ha detenido y nadie más ha basado ningún otro trabajo en las confirmaciones de su rama.

Haz eso y te evitarás cualquier problema.

RELACIONADO: Cómo verificar y actualizar su versión de Git