<![CDATA[ Nora Gonzalo Ciordia - freeCodeCamp.org ]]> https://www.freecodecamp.org/espanol/news/ https://cdn.freecodecamp.org/universal/favicons/favicon.png <![CDATA[ Nora Gonzalo Ciordia - freeCodeCamp.org ]]> https://www.freecodecamp.org/espanol/news/ Eleventy Sat, 06 Jun 2026 19:41:50 +0000 60 <![CDATA[ Validación Básica de Formularios en JavaScript ]]> https://www.freecodecamp.org/espanol/news/validacion-basica-de-formularios-en-javascript/ 5fea3cfc8c7cd154bb980e9e Wed, 27 Jan 2021 13:00:00 +0000 En el pasado, la validación de formularios solía ocurrir en el servidor, después de que una persona hubiera introducido toda su información y hubiera presionado el botón de envío.

Si la información era incorrecta o faltaba algo, el servidor tenía que enviar todo de vuelta junto con un mensaje indicando a esa persona que corrigiera el formulario antes de enviarlo de nuevo.

Era un proceso largo y suponía una gran carga para el servidor.

Hoy en día, JavaScript proporciona numerosas formas de validación de los datos de un formulario en el navegador antes de ser enviado al servidor.

Aquí está el código HTML que utilizaremos en los siguientes ejemplos:

<html>
<head>
  <title>Validación de Formularios</title>
  <script type="text/javascript">
    // la Validación del Formulario irá aquí
  </script>
</head>
<body>
  <form id="formulario">
    <table cellspacing="2" cellpadding="2" border="1">
      <tr>
        <td align="right">Nombre de Usuario</td>
        <td><input type="text" id="usuario" /></td>
      </tr>
      <tr>
        <td align="right">Email</td>
        <td><input type="text" id="email" /></td>
      </tr>
      <tr>
        <td></td>
        <td><input type="submit" value="Submit" id="btn-enviar" /></td>
      </tr>
    </table>
  </form>
</body>
</html>

Validación Básica

Este tipo de validación implica chequear todos los campos obligatorios y asegurar que estén correctamente cumplimentados.

Aquí te dejo un ejemplo básico de una función de validación que  muestra una alerta si los campos de nombre de usuario y email están en blanco, de otro modo devuelve true (verdadero): 

const btnEnviar = document.getElementById('btn-enviar');

const validación = (e) => {
  e.preventDefault();
  const nombreDeUsuario = document.getElementById('usuario');
  const direcciónEmail = document.getElementById('email');
  if (usuario.value === "") {
    alert("Por favor, escribe tu nombre de usuario.");
    usuario.focus();
    return false;
  }
  if (email.value === "") {
    alert("Por favor, escribe tu correo electrónico");
    email.focus();
    return false;
  }
  
  return true;
}

submitBtn.addEventListener('click', validate);

Pero, ¿qué pasaría si alguien introduce un texto al azar como si fuera su dirección de correo electrónico? Actualmente, la función validación seguiría devolviendo true porque el campo no está vacío aunque no sea una dirección de correo válida. (texto aclaración añadida para que quede claro el concepto) Como puedes imaginar, enviar datos incorrectos al servidor puede generar problemas.

Es aquí donde entra en el juego la validación del formato de datos.

Validación del Formato de Datos

Este tipo de validación mira realmente los valores del formulario y verifica que sean correctos.

La validación de las direcciones de correo electrónico es sumamente difícil - hay un gran número de direcciones de correo electrónico y alojamientos legítimos, y es imposible averiguar todas las combinaciones de caracteres válidas.

Dicho esto, hay algunos factores clave que son comunes en todas las direcciones de correo electrónico válidos:

  • Un correo debe contener una @ y al menos un punto (.)
  • La @ no puede ser el primer carácter del correo
  • Él (.) debe ir posicionando al menos un carácter después de la @

Teniendo esto en mente, posiblemente algunos desarrolladores utilicen el regex para determinar si un correo electrónico es válido o no. 

const emailVálido = email => {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

emailVálido('free@code@camp.org') // false
emailVálido('quincy@freecodecamp.org') // true

Añadido al código del último ejemplo, quedaría así: 

const btnEnviar = document.getElementById('btn-enviar');

const validación = (e) => {
  e.preventDefault();
  const nombreDeUsuario = document.getElementById('usuario');
  const direcciónEmail = document.getElementById('email');
  if (usuario.value === "") {
    alert("Por favor, escribe tu nombre de usuario.");
    usuario.focus();
    return false;
  }
    
  if (email.value === "") {
    alert("Por favor, escribe tu correo electrónico");
    email.focus();
    return false;
  }

  if (!emailVálido(email.value)) {
    alert("Por favor, escribe un correo electrónico válido");
    emailAddress.focus();
    return false;
  }
  
  return true; //Se pueden enviar los datos del formulario al servidor
}

const emailVálido = email => {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

submitBtn.addEventListener('click', validate);

Restricciones de Formulario de HTML5

Algunas de las restricciones comúnmente usadas por HTML5  para <input> son los atributos type  (p.ej. type="password"), maxlength, required y disabled.

Una restricción de uso menos común es el atributo pattern quien toma una expresión regular de JavaScript.

Más Información

Traducido del artículo - Basic Form Validation in JavaScript

]]> <![CDATA[ JavaScript Date Now – Cómo obtener la fecha actual con JavaScript ]]> https://www.freecodecamp.org/espanol/news/javascript-date-now-como-obtener-la-fecha-actual-con-javascript/ 5fe713aa8c7cd154bb97e9b7 Fri, 22 Jan 2021 14:00:00 +0000 Muchas de las aplicaciones que construirás tendrán algún componente del tipo fecha, ya sea por la creación de la fecha de un recurso, o por una marca temporal (timestamp) de alguna actividad.

Tratar con formatos de fechas y marcas de tiempo puede resultar agotador. En esta guía encontrarás cómo obtener la fecha de hoy en varios formatos con JavaScript.

Objeto Date (fecha) de JavaScript

JavaScript tiene un objeto  Date  integrado que almacena la fecha y la hora y provee de métodos para manejarlos.

Para crear una nueva instancia del objeto Date, utiliza la palabra clave new :

const fecha = new Date();

El objeto Date contiene un Number(número) que representa los milisegundos pasados desde el Epoch (fecha de referencia), que es el 1 de enero de 1970.  

Puedes convertir una string al constructor Date para crear un objeto con una fecha específica:

const fecha = new Date('Jul 12 2011');

Para obtener el año actual, utiliza el método de instancia getFullYear() del objeto Date . El método getFullYear() devuelve el año de la fecha especificada en el constructor  Date

const añoActual = fecha.getFullYear();
console.log(añoActual); //2020

Así mismo, existen métodos para obtener el día y el mes en los que estamos actualmente: 

const hoy = fecha.getDate();
const mesActual = fecha.getMonth() + 1;

El método getDate() devuelve el día del mes en el que estamos (1-31).

El método getMonth() devuelve el mes de la fecha especificada. Un punto a tener en cuenta acerca del método getMonth() es que devuelve valores indexados (0-11) donde el 0 es enero y el 11 es diciembre. Por tanto, añadiéndole 1 normalizamos el valor del mes.

Date now

now() es un método estático del objeto Date . Devuelve el valor en milisegundos que representa el tiempo transcurrido desde el Epoch. Puedes pasar los milisegundos devueltos del método now() dentro del constructor Date para crear una instancia de un nuevo objeto Date: 

const tiempoTranscurrido = Date.now();
const hoy = new Date(tempoTranscurrido);

Formateando Date

Puedes formatear la fecha en múltiples formatos (GMT, ISO, y demás) utilizando los métodos del objeto Date.

El método toDateString() devuelve la fecha en un formato legible por un humano: 

hoy.toDateString(); // "Sun Jun 14 2020"

El método toISOString() devuelve la fecha siguiendo con el Formato Extendido de ISO 8601:

hoy.toISOString(); // "2020-06-13T18:30:00.000Z"

El método toUTCString() devuelve la fecha en el formato según la zona horaria UTC:

hoy.toUTCString(); // "Sat, 13 Jun 2020 18:30:00 GMT"

El método toLocaleDateString() devuelve la fecha en un formato sensible a la localización, adaptándose así al idioma y formato del lugar donde te encuentres: 

hoy.toLocaleDateString(); // "14/6/2020"

Puedes encontrar una referencia completa de los métodos de Date en la documentación oficial de MDN.

Función para formatear a medida la fecha

Aparte de los formatos ya mencionados en la sección de más arriba, tu aplicación puede tener un formato diferente de datos. Puede ser en el formato yy-dd-mm, yyyy-dd-mm, dd-mm-yy o de cualquier otro.  

Para abordar este problema, conviene crear una función reutilizable que podremos usar en función de que la necesitemos en todos nuestros proyectos.

Por tanto, en esta sección, vamos a crear una función de utilidad que nos devuelva la fecha en el formato que le indiquemos en el argumento:

const hoy = new Date();

function formatoFecha(fecha, formato) {
	//
}

formatoFecha(hoy, 'dd/mm/yy');

Necesitas reemplazar las strings "dd", "mm" y "yy" con los respectivos valores del día, mes y año del formato pasado en la string que pasamos en el argumento.

Para hacer eso puedes usar el método replace() como te muestro aquí abajo: 

formato.replace('mm', fecha.getMonth() + 1);

 Pero esto dará lugar a un encadenamiento de métodos y dificultará el mantenimiento a medida que intentas hacer que la función sea más flexible:

formato.replace('mm', fecha.getMonth() + 1)
    .replace('yy', fecha.getFullYear())
	.replace('dd', fecha.getDate());

En lugar de usar métodos de encadenamiento, puedes hacer uso de expresiones regulares con el método replace().

Primero, crea un objeto que represente un par clave-valor del substring con su respectivo valor: 

const formatoMap = {
    dd: fecha.getDate(),
    mm: fecha.getMonth() + 1,
    yy: fecha.getFullYear().toString().slice(-2),
    yyyy: fecha.getFullYear()
};

Después, usa una expresión regular para hacer coincidir y reemplazar las strings: 

fechaFormateada = formato.replace(/mm|dd|yy|yyy/gi, matched => map[matched]);

La función completa se ve así: 

function formatoFecha(fecha, formato) {
    const map = {
        dd: fecha.getDate(),
        mm: fecha.getMonth() + 1,
        yy: fecha.getFullYear().toString().slice(-2),
        yyyy: fecha.getFullYear()
    }

    return formato.replace(/dd|mm|yy|yyy/gi, matched => map[matched])
}

Puedes también añadir la habilidad de formatear las marcas de tiempo a la función.

Conclusión

Espero que ahora entiendas mejor el objeto Date de JavaScript. Puedes usar también librerías externas como datejs y  moment para manejar fechas en tu aplicación.

Hasta la siguiente, cuídate y a por ello.

Traducido del artículo de Vijit Ail- https://www.freecodecamp.org/news/javascript-date-now-how-to-get-the-current-date-in-javascript/

]]> <![CDATA[ 10 Comandos de Git Que Todo Desarrollador Debería Saber ]]> https://www.freecodecamp.org/espanol/news/10-comandos-de-git-que-todo-desarrollador-deberia-saber/ 5fe4b8688c7cd154bb97d989 Mon, 11 Jan 2021 15:00:00 +0000 Git es una parte importante de quien programa a diario (especialmente si estás trabajando con un equipo) y se usa extensamente en la industria de software.

Desde que existe una gran variedad de comandos que puedes utilizar, dominar Git requiere tiempo. Pero algunos comandos se utilizan más frecuentemente (algunos hasta a diario varias veces). Por tanto, en este artículo, les compartiré y explicaré los 10 comandos de Git más usados que todo desarrollador debería de conocer.  

Nota: Para entender este artículo, tienes que conocer lo básico acerca de Git.

1. Git clone

Git clone es un comando para descargarte el código fuente existente desde un repositorio remoto (como Github, por ejemplo). En otras palabras, Git clone básicamente realiza una copia idéntica de la última versión de un proyecto en un repositorio y la guarda en tu ordenador.

Hay un par de formas de descargar el código fuente, pero principalmente yo prefiero clonar de la forma con https: 

git clone <https://link-con-nombre-del-repositorio>

Por ejemplo, si queremos descargar un proyecto desde Github, todo lo que necesitamos es hacer clic sobre el botón verde (clonar o descargar), copiar la URL de la caja y pegarla después del comando git clone que he mostrado más arriba.

bootstrap-github-1
Código fuente de Bootstrap en Github

Esto hará una copia del proyecto en tu espacio de trabajo local y así podrás empezar a trabajar con él.

2. Git branch

Las ramas (branch) son altamente importantes en el mundo de Git. Usando ramas, varios desarrolladores pueden trabajar en paralelo en el mismo proyecto simultáneamente. Podemos usar el comando git branch para crearlas, listarlas y eliminarlas.

Creando una nueva rama: 

git branch <nombre-de-la-rama>

Este comando creará una rama en local. Para enviar (push) la nueva rama al repositorio remoto, necesitarás usar el siguiente comando:

git push <nombre-remoto> <nombre-rama>

Visualización de ramas:

git branch
git branch --list

Borrar una rama:

git branch -d <nombre-de-la-rama>

3. Git checkout

Este es también uno de los comandos más utilizados en Git. Para trabajar en una rama, primero tienes que cambiarte a ella. Usaremos git checkout principalmente para cambiarte de una rama a otra. También lo podemos usar para chequear archivos y commits.

git checkout <nombre-de-la-rama>

Hay algunos pasos que debes seguir para cambiarte exitosamente entre ramas:

  • Los cambios en tu rama actual tienen que ser confirmados o almacenados en el guardado rápido (stash) antes de que cambies de rama.
  • La rama a la que te quieras cambiar debe existir en local.

Hay también un comando de acceso directo que te permite crear y cambiarte a esa rama al mismo tiempo: 

git checkout -b <nombre-de-tu-rama>

Este comando crea una nueva rama en local (-b viene de rama (branch)) y te cambia a la rama que acabas de crear.

4. Git status

El comando de git status nos da toda la información necesaria sobre la rama actual. 

git status

Podemos encontrar información como:

  • Si la rama actual está actualizada
  • Si hay algo para confirmar, enviar o recibir (pull).
  • Si hay archivos en preparación (staged), sin preparación(unstaged) o que no están recibiendo seguimiento (untracked)
  • Si hay archivos creados, modificados o eliminados
git-status-1
git status nos da información acerca del archivo y las ramas

5. Git add

Cuando creamos, modificamos o eliminamos un archivo, estos cambios suceden en local y no se incluirán en el siguiente commit (a menos que cambiemos la configuración).

Necesitamos usar el comando git add para incluir los cambios del o de los archivos en tu siguiente commit.

Añadir un único archivo: 

git add <archivo>

Añadir todo de una vez: 

git add -A

Si revisas la captura de pantalla que he dejado en la sección 4, verás que hay nombres de archivos en rojo - esto significa que los archivos sin preparación. Estos archivos no serán incluidos en tus commits hasta que no los añadas.

Para añadirlos, necesitas usar el git add:

git-add
Los archivos en verde han sido añadidos a la preparación gracias al git add

Importante: El comando git add no cambia el repositorio y los cambios que no han sido guardados hasta que no utilicemos el comando de confirmación git commit.

6. Git commit

Este sea quizás el comando más utilizado de Git. Una vez que se llega a cierto punto en el desarrollo, queremos guardar nuestros cambios (quizás después de una tarea o asunto específico).  

Git commit es como establecer un punto de control en el proceso de desarrollo al cual puedes volver más tarde si es necesario.

También necesitamos escribir un mensaje corto para explicar qué hemos desarrollado o modificado en el código fuente.

git commit -m "mensaje de confirmación"

Importante: Git commit guarda tus cambios únicamente en local.

7. Git push

Después de haber confirmado tus cambios, el siguiente paso que quieres dar es enviar tus cambios al servidor remoto. Git push envía tus commits al repositorio remoto.

git push <nombre-remoto> <nombre-de-tu-rama>

De todas formas, si tu rama ha sido creada recientemente, puede que tengas que cargar y subir tu rama con el siguiente comando: 

git push --set-upstream <nombre-remoto> <nombre-de-tu-rama>

or

git push -u origin <nombre-de-tu-rama>

Importante: Git push solamente carga los cambios que han sido confirmados.

8. Git pull

El comando git pull se utiliza para recibir actualizaciones del repositorio remoto. Este comando es una combinación del git fetch y del git merge lo cual significa que cundo usemos el git pull recogeremos actualizaciones del repositorio remoto (git fetch) e inmediatamente aplicamos estos últimos cambios en local (git merge).

git pull <nombre-remoto>

Esta operación puede generar conflictos que tengamos que resolver manualmente.

9. Git revert

A veces, necesitaremos deshacer los cambios que hemos hecho. Hay varias maneras para deshacer nuestros cambios en local y/o en remoto (dependiendo de lo que necesitemos), pero necesitaremos utilizar cuidadosamente estos comandos para evitar borrados no deseados.

Una manera segura para deshacer nuestras commits es utilizar git revert. Para ver nuestro historial de commits, primero necesitamos utilizar el  git log -- oneline:

histo-rico-git
histórico de git en mi rama master

Entonces, solo necesitamos especificar el código de comprobación que encontrarás junto al commit que queremos deshacer:

git revert 3321844

Después de esto, verás una pantalla como la de abajo -tan solo presiona shift + q para salir:

resim-2

El comando git revert deshará el commit que le hemos indicado, pero creará un nuevo commit deshaciendo la anterior:

git-revert
commit generado con el git revert

La ventaja de utilizar git revert es que no afecta al commit histórico. Esto significa que puedes seguir viendo todos los commits en tu histórico, incluso los revertidos.

Otra medida de seguridad es que todo sucede en local a no ser que los enviemos al repositorio remoto. Por esto es que git revert es más seguro de usar y es la manera preferida para deshacer los commits.

10. Git merge

Cuando ya hayas completado el desarrollo de tu proyecto en tu rama y todo funcione correctamente, el último paso es fusionar la rama con su rama padre (dev o master). Esto se hace con el comando git merge.

Git merge básicamente integra las características de tu rama con todos los commits realizados a las ramas dev (o master).  Es importante que recuerdes que tienes que estar en esa rama específica que quieres fusionar  con tu rama de características.

Por ejemplo, cuando quieres fusionar tu rama de características en la rama dev:

Primero, debes cambiarte a la rama dev: 

git checkout dev

Antes de fusionar, debes actualizar tu rama dev local: 

git fetch

Por último, puedes fusionar tu rama de características en la rama dev: 

git merge <nombre-de-la-rama>

Pista: Asegúrate de que tu rama dev tiene la última versión antes de fusionar otras ramas, si no, te enfrentarás a conflictos u otros problemas no deseados.

Aquí están mis 10 comandos de git más usados cuando me enfrento a la programación en mi día a día. Hay muchas más cosas que aprender sobre Git y las explicaré más adelante en oros artículos.

Si quieres aprender más sobre el desarrollo web, ¡puedes seguirme en Youtube!

¡Gracias por leerme!

Traducido del artículo de Cem Eygi - 10 Git Commands Every Developer Should Know

]]> <![CDATA[ Cómo entender Git: una introducción a los comandos básicos, consejos y trucos ]]> https://www.freecodecamp.org/espanol/news/git-comandos-basicos-como-entender-git/ 5fde12688c7cd154bb97aa6e Mon, 04 Jan 2021 13:00:00 +0000 Recientemente me he convertido en mentor de un compañero de trabajo.  Y mi mentorando me ha preguntado sobre Git en varias ocasiones. ¡Esto es por ti compañero! P.D. Debería de haber escrito este artículo cuando comenzamos pero, ¡espero que también ayude ahora!

Y recuerda: La mejor manera de aprender algo es haciéndolo por ti mismo. Y como mi mentor siempre me decía: Udaraj!

Básicos

0-2GkM1pvDmnI2ksUM

Entonces, ¿por qué Git es tan importante?

Vamos a empezar primero citando la primera línea de la página sobre Git en Wikipedia:

“Git (/ɡɪt/) es un software de control de versiones para llevar el registro de los cambios en los archivos de tu ordenador y coordinar el trabajo que varias personas realizan sobre archivos compartidos.".

Esto significa que la función más básica e importante de Git es permitir a grupos de personas añadir (y fusionar) código al mismo tiempo en el mismo proyecto. Añadiendo esta opción a los proyectos, hace a los grupos más eficientes y les otorga la habilidad de trabajar en proyectos más grandes y en problemas más complejos.

Existen muchas otras cosas que Git hace realmente bien: nos permite revertir cambios, crear nuevas ramas para añadir nuevas características, resolver conflictos de fusión, y muchas más.

Cómo funciona

Git almacena los proyectos en repositorios. Se hacen las confirmaciones (commits) al proyecto y le informas a Git de que estás satisfecho con los archivos nuevos o modificados que has has creado.

El código creado como nuevo/con cambios se confirman en las ramas. La mayoría del trabajo es confirmado en otras ramas y fusionado con la rama master. Todo esto es almacenado en el mismo directorio que el proyecto pero en una sub carpeta llamada .git.

Para compartir el código con tus compañeros tienes que enviar (push) los cambios al repositorio. Para añadir el código nuevo de tus compañeros, tienes que traer (pull) los cambios del repositorio.

git-hosting-services-1

Entonces, qué son GitHub, GitLab y Bitbucket?

Bien, ¡me alegro de que lo preguntes! Este tipo de aplicaciones se llaman servicios de gestión de repositorios. Juegan un papel crucial en el desarrollo de software moderno.

Pese a que Git y Github son la mejor opción en cuanto a sistemas de control de versiones, GitHub tiene fuertes competidores como GitLab y Bitbucket. No obstante, si sabes utilizar GitHub, no tendrás ningún problema en trabajar con GitLab o Bitbucket.

Por tanto, para dejarlo claro: Git es la herramienta, y GitHub es el servicio para los proyectos que usa Git.

¿Dónde puedo descubrir proyectos interesantes y conectar con otros desarrolladores?

GitHub, GitLab y Bitbucket tienen opciones de búsqueda de repositorios públicos y la posibilidad de seguir a otros usuarios.

¿Puedes ver por qué es importante saber manejar Git y Github (GitLab/Bitbucket)? Lo único que nos queda por hablar sobre los comandos, es darte unas simples reglas que tendrás que seguir cuando uses Git:

  • Regla 1: Crea un repositorio Git para cada proyecto nuevo
  • Regla 2: Crea una nueva rama para cada característica

Comandos

Para empezar con Git lo tienes que tener instalado en tu ordenador. Si todavía no lo tienes, puedes visitar su página y seguir las instrucciones para obtenerlo.

Inicializar un nuevo repositorio: Git init

Todo tu código será rastreado y rastreable en el repositorio. Para inicializar un repositorio en git, ejecuta este comando mientras estés en la carpeta del proyecto. Éste creará un archivo .git. 

git init

Git add

Este comando añade uno o todos los archivos cambiados en el área de preparación.

Para añadir un solo archivo a la preparación:

git add nombredelarchivo.py

Para preparar archivos nuevos, modificados o eliminados: 

git add -A

Para preparar archivos nuevos y modificados: 

git add .

Para preparar archivos modificados y borrados: 

git add -u

Git commit

Este comando guarda el archivo en versión histórico. El -m significa que le acompaña un mensaje de confirmación. Este mensaje es personalizable y lo debes de usar para indicar a tus compañeros o a tu yo del futuro que ha sido realizado, añadido o modificado en ese commit. 

git commit -m "tu mensaje"

Git status

Este comando te informa del estado de los archivos de tu proyecto y listará los archivos en verde o en rojo. Los archivos en verde se han añadido a la preparación pero no se han confirmado todavía. Los archivos marcados en rojo son aquellos que no han sido añadidos a la preparación. 

git status

Trabajando con ramas

Git branch nombre_de_rama

Este comando creará una nueva rama

git branch nombre_de_rama

Git checkout nombre_de_rama

Para cambiar de una rama a otra:

git checkout nombre_de_rama

Git checkout -b nombre_de_rama

Para crear una nueva rama y cambiar a ésta automáticamente: (comprobar que se puede hacer sin commit de la rama en la que estás, porque creo que no se puede cambiar de rama sin hacer commit en la que estás)

git checkout -b nombre_de_rama

Es la forma abreviada de hacer:

git branch nombre_de_rama
git checkout nombre_de_rama

Git branch

Para listar todas las ramas y ver en qué rama estás trabajando en ese momento: 

git branch

Git log

Este comando listará el histórico de las versiones de la rama en la que estás trabajando: 

git log

Push & Pull

Git push

Este comando envía los cambios confirmados a un repositorio remoto:

git push

Git pull

Para descargar los cambios realizados en el servidor remoto en tu ordenador: 

git pull

Consejos y Trucos

Desecha tus cambios sin confirmar

Tal y como se indica, este comando descartará todos los cambios sin confirmar:

git reset --hard

Elimina un archivo de git sin eliminarlo de tu ordenador

A veces, cuando utilizas el comando "git add", puedes añadir archivos que no querías añadir.

Si no eres cuidadoso durante un "git add", puedes acabar añadiendo archivos que no querías añadir. Debes eliminar el archivo de la versión de preparación, para añadirlo al archivo .gitignore para evitar cometer el mismo error una segunda vez: 

git reset nombre_del_archivo
echo filename >> .gitignore

Editar un mensaje de confirmación

Es muy fácil arreglar un mensaje de confirmación: 

git commit --amend -m "nuevo mensaje"

¡Gracias por tu lectura!

Traducido del artículo de Goran Aviani - How to understand Git: an intro to basic commands, tips, and tricks

]]>