Cómo desplegar tu aplicación de React + Vite en GitHub Pages

🚀 Cómo desplegar tu aplicación de React + Vite en GitHub Pages

Publicar tu app en GitHub Pages es una forma rápida y gratuita de mostrar tus proyectos front-end. En esta guía te explico, paso a paso, cómo hacerlo desde un proyecto creado con React y Vite.

Requisitos previos

  • Proyecto creado con React + Vite.
  • Repositorio en GitHub con tu código.
  • Node.js y terminal operativos.

Nota: GitHub Pages sirve sitios estáticos (HTML/CSS/JS); no ejecuta código de servidor.

Configura la ruta base en vite.config.ts o vite.config.js

Vite necesita saber desde qué ruta se servirá tu sitio en producción. Para repositorios de proyecto
(https://TU_USUARIO.github.io/NOMBRE_DEL_REPO/), define base con esa URL.

Ejemplo: vite.config.ts


import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
export default defineConfig({
  plugins: [react()],
  base: 'https://TU_USUARIO.github.io/NOMBRE_DEL_REPO/',
})

Si usas un User/Org Page (repositorio llamado TU_USUARIO.github.io), la base suele ser '/':

export default defineConfig({
  plugins: [react()],
  base: '/',
})

Instala y prepara gh-pages

  1. Instala la dependencia:

    npm install --save-dev gh-pages
  2. Añade scripts en package.json:

    {
      "scripts": {
        "dev": "vite",
        "build": "vite build",
        "preview": "vite preview",
        "deploy": "npm run build && gh-pages -d dist"
      }
    }

    El script deploy compila tu app y publica la carpeta dist en la rama gh-pages.

Despliega tu app

  1. Ejecuta el despliegue:

    npm run deploy
  2. Activa GitHub Pages: en tu repositorio, ve a Settings > Pages y selecciona la rama gh-pages (carpeta raíz).

  3. Verifica la URL final:

    https://TU_USUARIO.github.io/NOMBRE_DEL_REPO/

Resumen rápido

Paso Acción
1 Definir base en Vite según tu tipo de página (User/Org o Project).
2 Instalar gh-pages.
3 Añadir scripts build y deploy en package.json.
4 Ejecutar npm run deploy.
5 Configurar GitHub Pages para usar la rama gh-pages.
6 Comprobar la URL publicada.

Rutas con React Router (SPA)

GitHub Pages no soporta el history API del navegador sin configuración extra. Tienes dos alternativas:

  1. Usar HashRouter (recomendado por simplicidad):

    import { HashRouter, Routes, Route } from 'react-router-dom'
    export function App() {
      return (
        <HashRouter>
          <Routes>
            <Route path="/" element={<Home />} />
            <Route path="/about" element={<About />} />
          </Routes>
        </HashRouter>
      )
    }
  2. Mantener BrowserRouter y añadir una 404.html que redirija a index.html (más avanzado). Para la mayoría de casos, HashRouter es suficiente.

Problemas comunes y soluciones

  • 404 Not Found / rutas rotas: usa HashRouter o configura una 404.html que redirija a index.html.

  • Recursos (CSS/JS) sin cargar: comprueba que base termina en / y apunta a la URL correcta.

  • La página no actualiza tras desplegar: puede ser la caché. Fuerza recarga (Ctrl/Cmd + Shift + R) o espera unos minutos a la propagación.

  • Error de permisos al publicar: verifica que el repositorio no es privado (o que tu configuración de Pages permite despliegue desde gh-pages).

  • Rama gh-pages no aparece: se crea en el primer npm run deploy. Si falla, revisa el log del comando.

Checklist final

  • He configurado base correctamente según el tipo de página.
  • La app compila sin errores con npm run build.
  • Las rutas funcionan (preferiblemente con HashRouter).
  • GitHub Pages está activado apuntando a gh-pages.
  • La URL final carga estilos, imágenes y navegación.

Atajos y trucos para usar Visual Studio Code desde la terminal en Mac (como una pro)

Visual Studio Code desde la terminal en Mac

Potencia tu flujo de trabajo con terminal y VS Code en Mac

Si ya sabes cómo abrir Visual Studio Code desde la terminal en Mac con code, ¡es hora de ir un paso más allá!

Aquí te comparto una selección de trucos y atajos útiles para exprimir al máximo la combinación de terminal + VS Code en macOS.

Estos tips te ayudarán a ahorrar tiempo y trabajar mejor con Visual Studio Code desde la terminal en Mac.

1. Crea alias personalizados para abrir proyectos

Si sueles trabajar en varios proyectos, puedes crear alias rápidos para abrir cada uno sin tener que navegar carpetas:

📁 Paso 1: Abre tu archivo de configuración
Dependerá de tu shell:

  • Zsh (por defecto en macOS):


	nano ~/.zshrc

Bash:


	nano ~/.bash_profile

📁 Paso 2: Añade tus alias


	alias portafolio="code ~/Proyectos/portafolio"
alias blogdev="code ~/Sites/martagonzalez.dev/blog"

Guarda el archivo y ejecuta source ~/.zshrc (o .bash_profile) para aplicar los cambios.

Ahora solo escribe portafolio y ¡listo!

2. Abre archivos individuales directamente

¿Sabías que también puedes abrir un archivo concreto?


	code index.html

Incluso varios a la vez:


	code index.html style.css app.js

3. Abre VS Code sin cargar ningún proyecto

Si solo quieres lanzar el editor sin abrir carpetas o archivos, basta con:


	code

Ideal para tomar notas rápidas o crear archivos nuevos.

4. Combina VS Code con Git desde la terminal

Visual Studio Code se lleva muy bien con Git. Si estás dentro de un repo, puedes hacer:


	code .gitignore

O incluso configurar que los diffs y merges se abran en VS Code:


	git config --global core.editor "code --wait"

5. Limpieza: cómo reiniciar VS Code desde la terminal

Si algo se queda pillado o quieres cerrar y reabrir el editor rápidamente:


	killall "Visual Studio Code"; sleep 1; code .

⚠️ Úsalo con cuidado, pero puede sacarte de un apuro.

💎 Bonus: otros comandos útiles de VS Code CLI


code --new-window            # Abrir en nueva ventana
code -r .                    # Reemplaza la ventana actual
code --diff file1 file2      # Ver diferencias entre archivos
code --disable-extensions    # Modo sin extensiones (ideal para debug)


A medida que te acostumbras a trabajar desde la terminal, verás que estos pequeños trucos se vuelven parte natural de tu día a día.
Y si además usas alias inteligentes, tu flujo de trabajo se vuelve mucho más ágil y profesional.

Si estás empezando y aún no sabes cómo abrir VS Code desde la línea de comandos, te recomiendo leer primero este artículo: cómo abrir Visual Studio Code desde la terminal en macOS.

¿Aún no tienes instalado Visual Studio Code? Puedes descargarlo gratis desde su sitio oficial y comenzar a potenciar tu flujo de trabajo desde la terminal en Mac.

Dot Coding: Qué es y cómo aplicarlo en el desarrollo web

La notación por puntos (también conocida como dot notation o codificación con puntos) es una práctica común, aunque no siempre reconocida formalmente, en el desarrollo web moderno. Su finalidad es clara: mejorar la legibilidad, la organización y el mantenimiento del código mediante el uso de puntos (.) como herramienta estructural. Esta técnica es clave en lenguajes como JavaScript, en metodologías CSS y en la definición de rutas en aplicaciones web.

Además, si te interesa optimizar tu flujo de trabajo, puedes explorar estas técnicas efectivas para depurar tu código en menos tiempo, que complementan perfectamente el uso de notación por puntos.

Gráfico sobre notación por puntos en desarrollo web, mostrando ejemplo de dot coding y código JavaScript

En este artículo aprenderás qué es la notación por puntos, cómo aplicarla, buenas prácticas, errores a evitar y cómo puede ayudarte a escribir código más limpio y profesional.

Para ampliar tu comprensión sobre estructuras de código, te recomendamos leer esta guía de objetos en JavaScript por MDN.

¿Qué es la notación por puntos?

La notación por puntos se refiere al uso de puntos para representar relaciones jerárquicas y facilitar la comprensión del código. Es un recurso sintáctico y semántico que permite acceder a propiedades, definir convenciones de nomenclatura o estructurar rutas URL. Esta sintaxis con punto también es útil para escribir código más organizado y predecible.

Principales aplicaciones

1. Notación de objetos en JavaScript (y otros lenguajes)

La dot notation es esencial en JavaScript para acceder a propiedades de objetos. También se conoce como acceso por puntos y se usa ampliamente en lenguajes como Python y Java:

const usuario = {
  nombre: "Marta",
  edad: 30
};
console.log(usuario.nombre); // "Marta"

2. Convenciones de nombres en CSS (BEM, ITCSS)

Metodologías como BEM utilizan el punto para mejorar la estructura semántica del CSS, permitiendo una escritura jerárquica de clases:


.boton {
  background-color: blue;
}
.boton__icono {
  width: 20px;
}
.boton--activo {
  background-color: red;
}

Aquí, los puntos estructuran el código CSS de manera clara, separando bloques (boton), elementos (boton__icono) y modificadores (boton–activo).

Más en BEM.

3. Rutas y URLs jerárquicas

Frameworks como Next.js y Laravel permiten el uso de puntos para representar jerarquías en rutas, una práctica útil para definir URLs estructuradas:

Ejemplo en Next.js:

/perfil/[usuario].js → /perfil/martagonzalez

O en APIs REST, donde los puntos pueden representar estructuras jerárquicas:

GET /usuarios.marta.datos

Esta forma de estructurar las rutas contribuye a una arquitectura más clara y predecible.

Ver Next.js.

Beneficios

  • Legibilidad mejorada: El uso consistente de puntos ayuda a entender la estructura del código.
  • Organización clara: Ideal para mantener el orden en proyectos medianos y grandes.
  • Facilita el mantenimiento: Simplifica la localización de errores y la actualización de funcionalidades.

Buenas prácticas

  • Utiliza dot notation solo donde sea semánticamente coherente y aporta claridad.
  • Apóyate en metodologías como BEM o en guías de estilo para mantener la coherencia del código CSS.
  • Mantén una nomenclatura clara, predecible y bien documentada para facilitar la colaboración en equipo.

Errores comunes a evitar

  • Abusar del uso de puntos en nombres que no requieren jerarquía, lo que puede llevar a confusión.
  • No documentar adecuadamente la estructura de nombres o rutas empleadas.
  • Combinar la notación por puntos con otras convenciones sin una lógica clara o coherente.

La notación por puntos es una estrategia simple pero poderosa para mejorar la calidad del código en proyectos web. Adoptarla puede marcar una gran diferencia en la claridad, organización y escalabilidad de tus desarrollos.