El comando 'ls' está obsoleto.

Escribe `ls` en un terminal hoy y efectivamente estarás viajando en el tiempo hasta los años 70. El comando sigue haciendo lo que siempre hizo: mostrar un listado de directorios, pero los flujos de trabajo de desarrollo modernos exigen mucho más que una columna monocromática de nombres de archivos. Tu editor, navegador e IDE han evolucionado; tu listado de archivos en gran medida no.

El tradicional ls no sabe nada de Git, aunque prácticamente cada proyecto serio vive en un repositorio. No puedes echar un vistazo a un directorio y ver qué archivos están modificados, ignorados o no rastreados sin ejecutar comandos separados de `git status`. Esto significa un constante cambio de contexto mental: `ls` para ver archivos, `git` para ver el estado, tu cerebro para unirlo todo.

La retroalimentación visual es igual de primitiva. GNU ls puede colorear la salida, pero se limita a tipos de archivos y permisos básicos, sin ningún concepto de íconos, rutas clicables o gradientes que resalten archivos grandes o recientes. No obtienes: - Indicadores compatibles con Git - Íconos por archivo - Hiperenlaces que puedas clicar en terminales modernas

La densidad de información es otro problema. Un volcado largo de `ls -l` amontona permisos, propietarios, tamaños y marcas de tiempo en una pared de texto que se vuelve difícil de manejar una vez que un directorio tiene cientos de entradas. O bien ves muy poco (`ls`) o demasiado (`ls -l`), sin un término medio matizado como "solo directorios", "ocultar archivos ignorados por Git" o "mostrar primero directorios".

Mientras tanto, tu terminal se ha convertido en tu interfaz principal a medida que herramientas como Git, Docker y Kubernetes trasladan más flujos de trabajo a la línea de comandos. Saltas entre Linux y macOS, manejas docenas de repositorios y aún dependes de un listado de archivos diseñado antes de que el control de versiones se volviera común. ¿Por qué tu vista de directorios no entiende tu VCS, tus fuentes ni tu esquema de colores?

Entonces, ¿cómo se vería una herramienta de listado de archivos si estuviera diseñada para 2025 en lugar de 1975? ¿Qué pasaría si `ls` pudiera mostrar el estado de Git en línea, agregar íconos automáticamente y usar opciones de ordenamiento y filtrado inteligente que se adapten a la forma en que realmente trabajas? Esa brecha, entre lo que ofrece `ls` y lo que los desarrolladores esperan ahora, es exactamente donde eza entra en juego.

Los tradicionalistas de la línea de comandos pueden no querer oírlo, pero eza es la herramienta que se comporta como la gente espera que se comporte `ls` en 2025. Viene con configuraciones predeterminadas sensatas, color por defecto y un diseño que resalta lo que realmente importa: tipos de archivo, estado de Git y metadatos legibles para humanos, en lugar de una pared monocromática de texto. Escrito en Rust, se basa en la seguridad de la memoria y un paralelismo agresivo para mantenerse rápido incluso en repositorios gigantes.

Eza no apareció de la nada. Comenzó como un fork mantenido por la comunidad de exa, el querido reemplazo de Rust para `ls` creado por Benjamin Sago (conocido como “ogham”) que estuvo sin mantenimiento durante años. Cuando exa se estancó, los colaboradores trasladaron la base de código al repositorio eza-community/eza, limpiaron problemas pendientes y comenzaron a lanzar versiones frecuentes para Linux y macOS.

Apartado el origen, la propuesta de eza es simple: mejores valores predeterminados, información más rica y una experiencia orientada a desarrolladores. Ejecuta `eza -l --git` y verás de inmediato marcadores sensibles a Git como `M` para modificado, `N` para nuevo e `I` para archivos ignorados en la misma lista que los permisos y tamaños. Agrega `--git-repos` y los directorios se transforman en un panel de control de ramas y estado “sucio/limpio” a través de múltiples repositorios.

La densidad de señales visuales es donde eza se separa de `ls`. Los colores siempre están activados en el uso interactivo, y opciones como `--colour=always` los preservan a través de pipes, mientras que `--colour-scale` utiliza gradientes para resaltar archivos grandes o recientes. Con una fuente Nerd instalada, `--icons` decora cada entrada con glifos de tipo de archivo, y `--hyperlink` convierte las rutas en enlaces clicables en terminales que lo soportan.

La ergonomía para desarrolladores se refleja en el modelo de ordenación y filtrado. En lugar de memorizar combinaciones de banderas `ls` arcanas, obtienes opciones explícitas como: - `--sort=size`, `--sort=time` o `--sort=extension` - `--reverse` para orden invertido - `--group-directories-first`, `--only-dirs` o `--only-files`

Existen alternativas, pero eza las apunta directamente. El proyecto afirma explícitamente ser más rápido que lsd, otro clon de `ls` en Rust, mientras ofrece una integración más profunda con Git, personalización a través de archivos de configuración, vistas de árbol con `--tree`, y adaptadores de compatibilidad para que puedas aliasar `ls` o incluso `exa` a eza y olvidar que el cambio alguna vez ocurrió.

Las máquinas modernas con macOS hacen que instalar eza sea casi trivial. Con Homebrew configurado, ejecuta: - `brew install eza` Ese único comando descarga un binario preconstruido de Rust, lo añade a tu PATH y te brinda actualizaciones a través de `brew upgrade eza` cada vez que el proyecto lanza una nueva versión.

Los usuarios de Linux reciben un tratamiento similar. En Debian/Ubuntu, ejecuta `sudo apt install eza` (en versiones antiguas puede que necesites el .deb de GitHub). En Arch y derivados, `sudo pacman -S eza` se instala desde los repositorios comunitarios. Otras distribuciones lo empaquetan bajo `eza` o documentan instrucciones en eza – Una alternativa moderna a ls (GitHub oficial).

Para hacer que eza se sienta invisible pero omnipresente, alíásalo como ls. Agrega esta línea a tu configuración de shell: - Bash: añade `alias ls='eza'` a `~/.bashrc` - Zsh: añade `alias ls='eza'` a `~/.zshrc` Después de editar, recarga con `source ~/.bashrc` o `source ~/.zshrc`, o simplemente abre una nueva pestaña de terminal.

Primero ejecuta `eza` sin banderas. Obtendrás de inmediato una salida codificada por colores y alineada en columnas que respeta mejor el ancho del terminal que `ls`. Los archivos ocultos permanecen ocultos por defecto, lo que mantiene los directorios de proyectos más legibles.

A continuación, prueba `eza -l`. La vista larga agrega permisos, propietarios, tamaños y marcas de tiempo en un formato más legible, con colores que separan los metadatos de los nombres de archivo. Luego, ejecuta `eza -a` para incluir los archivos ocultos; aún obtendrás una lista limpia, ordenada por colores, en lugar de la sopa visual que `ls -a` suele producir.

Si tu alias no hace nada, es probable que hayas editado el archivo incorrecto o que tu shell cargue una configuración diferente. Verifica `$SHELL` para confirmar Bash vs Zsh, asegúrate de que la línea del alias no tenga espacios o comillas extrañas, y ejecuta `type ls` para verificar que ahora apunte a eza. Cuando tengas dudas, reinicia el terminal para forzar un entorno limpio.

Las listas de archivos conscientes de Git te impiden alternar constantemente a `git status` cada 30 segundos. Con eza, Git no es un paso separado; está integrado directamente en la vista del directorio, por lo que la salud de tu árbol de trabajo se muestra junto a los nombres de los archivos, tamaños y marcas de tiempo.

Ejecuta `eza -l --git` en cualquier repositorio y obtendrás una columna de estado adicional directamente desde Git. Cada archivo muestra un marcador conciso extraído de `git status --short`, para que puedas buscar problemas sin tener que interpretar un muro de texto.

Esas letras diminutas llevan mucho significado. En formato largo, eza utiliza:

• 1`M` a la izquierda: modificado y preparado
• 2`M` a la derecha: modificado pero no preparado
• 3`N`: archivo nuevo, no rastreado
• 4`I`: ignorado por `.gitignore` o `.git/info/exclude`

Debido a que estos marcadores se encuentran por línea, puedes ver de inmediato qué archivos son seguros, cuáles están medio comprometidos y cuáles aún están en estado salvaje. No más adivinar qué cambio en `src/` olvidaste añadir antes de tu último commit.

Los grandes monorepos multiplican ese valor. Con `eza --git --tree --level=2`, puedes recorrer una jerarquía de proyectos y mantener el estado de Git visible en cada nivel. Esa combinación convierte una simple vista en árbol en un mapa en vivo del trabajo no confirmado.

La proliferación de repositorios crea un problema diferente: saber qué proyecto está limpio antes de hacer un push. La opción `--git-repos` aborda exactamente eso. Apunta eza a un directorio lleno de proyectos y resume cada repositorio de Git en una sola línea.

Para cada subdirectorio que contenga una carpeta `.git`, `eza --git-repos` muestra la rama actual, además de un indicador de "sucio" o "limpio". Puedes ver de un vistazo 10 o 50 repositorios a la vez y detectar instantáneamente el que tiene cambios no enviados o no comprometidos.

El ruido de los activos generados y los registros puede enterrar la señal en grandes bases de código. Agrega `--git-ignore` y eza oculta todo lo que Git ya ignora, aplicando efectivamente tus reglas de `.gitignore` a la lista de archivos en sí. El directorio `dist/` de Node, el `.venv/` de Python, los informes de `coverage/` y los artefactos de construcción desaparecen de la vista.

Combina estas banderas y el terminal se convierte en un panel de Git: `eza -l --git --git-ignore --group-directories-first` para una edición enfocada, o `eza --git-repos ~/code` para un chequeo del estado de todo el portafolio. El antiguo `ls` muestra archivos; eza muestra el estado real de tu trabajo.

Color es donde eza deja de pretender ser un reemplazo directo y comienza a sentirse como una interfaz moderna comprimida en un terminal. De forma predeterminada, viene con una paleta inteligente que codifica tipos de archivos, permisos y metadatos de un vistazo: directorios en un tono, ejecutables en otro, enlaces simbólicos en un tercero, con acentos adicionales para cosas como bits pegajosos y rutas de escritura mundial. No necesitas configurar nada; solo ejecutas `eza` y tu sistema de archivos de repente tiene una leyenda.

El comando tradicional `ls --color` se siente rudimentario en comparación. Los valores predeterminados de Eza no solo distinguen qué es un archivo, sino también cuán seguro es tocarlo. Las combinaciones de permisos sospechosos, como los binarios escribibles por el grupo, destacan de inmediato, actuando como una auditoría de seguridad de bajo fricción cada vez que listamos un directorio.

El color se vuelve aún más importante en el momento en que comienzas a usar tuberías. Muchas herramientas eliminan los códigos ANSI a menos que les digas explícitamente que no lo hagan, así que eza expone `--colour=always` para forzar una salida de color persistente. Esa única opción mantiene tus tonos vivos a través de `grep`, `less -R`, `fzf`, o incluso en archivos de registro que revisas más tarde.

Usados juntos, el patrón se ve así: - `eza --colour=always | less -R` - `eza --colour=always | grep patrón` - `eza -l --git --colour=always | fzf`

Donde `eza` realmente se destaca de `ls` es en `--colour-scale`, una característica que convierte los metadatos en un degradado visual. Con `--colour-scale=size`, los artefactos grandes—piensa en imágenes de VM de varios gigabytes o en node_modules inflados—se iluminan de manera diferente a los pequeños archivos de configuración. Cambia a `--colour-scale=age` y las ediciones de ayer brillan contra un fondo de residuos heredados sin tocar.

Esos gradientes se adaptan especialmente bien en árboles grandes. Ejecuta `eza --tree --colour-scale=size` en un proyecto y podrás identificar los 3-4 archivos que consumen espacio en disco sin leer un solo número. Se siente más como un mapa de calor que como una lista aburrida.

Si no te gustan las configuraciones predeterminadas, eza no te encierra. Soporta temas de color personalizados, cargados desde archivos de configuración que asignan roles semánticos (directorio, enlace simbólico, socket, modificado por git) a estilos específicos. Puedes obtener un tema de la comunidad en eza-community/eza, agregarlo a tu configuración, o crear el tuyo propio para que cada terminal que toques se sienta inconfundiblemente tuya.

La vista de cuadrícula es donde comienza eza. Por defecto, agrupa los nombres de archivo en una cuadrícula de múltiples columnas, utilizando el ancho de tu terminal para evitar el desorden de una sola columna que a menudo obtienes con ls. Aún obtienes colores, íconos y marcas de Git en esta vista, por lo que un simple `eza` ya es más informativo que `ls -F`.

Cuando necesitas detalles, `long view` es la herramienta de trabajo. `eza -l` cambia a un listado largo con permisos, propietarios, grupos, tamaños, marcas de tiempo y estado de Git opcional en una tabla limpia y alineada. Combina `-l` con `-a` para mostrar archivos ocultos o con `--group-directories-first` para mantener las carpetas en la parte superior de la pila.

A veces quieres densidad, no decoración. `eza --oneline` imprime una entrada por línea, ideal para secuencias de comandos, redirigir a `fzf`, o revisar directorios masivos sin desplazamiento horizontal. Agrega `--sort=size` o `--sort=modified` para convertir eso en un informe visual rápido de tus archivos más grandes o más nuevos.

Los desarrolladores se sienten atraídos por `eza --tree`. La vista en árbol recorre directorios de manera recursiva y representa toda la jerarquía con caracteres de dibujo de cuadros, íconos y colores, de modo que los directorios anidados `src`, `tests` y `migrations` se vuelven instantáneamente legibles. Ejecuta `eza --tree src` en un repositorio de JavaScript o Rust y obtendrás un mapa del proyecto que supera cualquier muro de texto de `ls -R`.

La salida en árbol puede descontrolarse en monorepos reales, así que eza incorpora un freno eficaz: `--level`. Usa `eza --tree --level=2` para ver solo las dos capas superiores de un espacio de trabajo de Node, o `--level=4` para asomarte más a fondo en `packages/` sin ahogarte en `node_modules`. Ese límite de profundidad convierte `--tree` de una novedad en una herramienta diaria para navegar estructuras complejas.

Para un mayor control, eza expone un puñado de interruptores de visualización específicos. `--header` añade una fila de encabezado a listados largos, etiquetando columnas como permisos, tamaño y hora de modificación, lo cual es perfecto cuando capturas la salida para documentos o informes de errores. `--inode` muestra números de inode, invaluables cuando depuras enlaces duros o comportamientos extraños del sistema de archivos.

Los usuarios avanzados pueden apilar estas flags. Un comando como `eza -la --header --inode --tree --level=2` te proporciona una visión general del proyecto, ricamente anotada, a dos niveles de una sola vez. Para una lectura más profunda sobre estos modos y más ejemplos, eza: Simplificando la Listado de Archivos con Funcionalidad Mejorada de 'ls' – Linuxiac desglosa combinaciones adicionales y casos extremos.

Los usuarios avanzados de la línea de comandos viven y mueren por el orden de clasificación. Eza trata la clasificación como una característica de primera clase con una única bandera `--sort` coherente en lugar de la variedad de opciones de `ls`. Puedes clasificar por tamaño (`--sort=size`), tiempo modificado (`--sort=modified` o `--sort=mtime`), tiempo de creación (`--sort=created` o `--sort=ctime`), nombre (`--sort=name`), o extensión (`--sort=extension`).

Donde `ls` dispersa el comportamiento a través de opciones como `-t`, `-S` y `-X`, `eza` lo agrupa en argumentos legibles y amigables para scripts. ¿Necesitas los artefactos más grandes en la parte superior de tu directorio de compilación? `eza --sort=size --reverse target` muestra los mayores infractores al instante.

Invertir un orden revela una de las diferencias más importantes con `ls`. En lugar de variantes reversas separadas como `-tr` o `-Sr`, eza siempre utiliza la misma bandera `--reverse`. Especificas el criterio de ordenación y luego lo inviertes: `eza --sort=modified --reverse` significa “el más antiguo primero”, sin necesidad de acrobacias mentales.

Esa elección de diseño vale la pena cuando encadenas opciones. Una vista larga de Git de tu repositorio, con los cambios más recientes en la parte superior, se convierte en `eza -l --git --sort=modified`. ¿Quieres la misma lista pero con el contenido antiguo que probablemente deberías eliminar? Agrega `--reverse` y nada más cambia.

La clasificación solo te lleva a la mitad; los proyectos serios necesitan filtrado. Eza envía `--group-directories-first`, que empuja las carpetas a la parte superior de la lista sin trucos extraños de locale o shell. Combínalo con `--sort=name` para un diseño limpio y predecible en cualquier idioma.

Cuando necesites reducir el ruido, `--only-dirs` y `--only-files` actúan como filtros quirúrgicos. Escanea solo tu estructura de directorios con `eza --only-dirs --group-directories-first --tree`, o inspecciona únicamente los binarios y activos compilados usando `eza --only-files --sort=size`. No se requieren encantamientos de `find`.

Estas banderas comienzan a sentirse como operadores de consulta una vez que las apilas. Algunas combinaciones comunes en el mundo real incluyen: - `eza --group-directories-first --sort=extension --only-files src` - `eza -l --sort=created --reverse --only-files dist` - `eza --sort=modified --only-dirs --git`

Ese último comando muestra solo directorios, ordenados por actividad reciente, con el estado de Git integrado: un mapa de calor en vivo de dónde ocurre realmente tu trabajo.

Los íconos transforman eza de un `ls` más inteligente en algo que realmente se siente moderno. Añade `--icons` a cualquier comando y las listas de archivos de repente obtienen pequeños glifos de alto impacto: un logo de Python para `.py`, un icono de documento para `.md`, un engranaje para ejecutables, símbolos distintos para enlaces simbólicos y archivos ocultos. Los directorios obtienen íconos de carpeta, y los repositorios de Git destacan instantáneamente cuando se combinan con `--git` y `--git-repos`.

Esos íconos dependen de Nerd Fonts, un proyecto popular que parches fuentes amigables para desarrolladores con miles de glifos adicionales. Nerd Fonts agrupa símbolos de proyectos como Font Awesome, Devicons y Octicons en más de 50 fuentes base. No estás instalando un plugin para eza; estás instalando una fuente que tu terminal puede renderizar.

En macOS, una configuración típica consta de tres pasos. Descarga una Nerd Font como FiraCode Nerd Font o JetBrainsMono Nerd Font desde nerdfonts.com, instálala haciendo doble clic y seleccionando “Instalar fuente”, luego apunta tu terminal hacia ella. Los usuarios de Linux a menudo pueden instalarla a través de gestores de paquetes (por ejemplo, `sudo pacman -S nerd-fonts-jetbrains-mono`) y luego seleccionarla en las preferencias de su emulador.

Configurar iTerm2 es sencillo. Abre Preferencias → Perfiles → Texto, haz clic en el selector de fuente y elige tu fuente Nerd Font instalada (las variantes regulares y sin ligaduras funcionan ambas). Después de eso, `eza --icons` muestra inmediatamente logos de lenguajes, íconos de archivos comprimidos para `.zip` y `.tar.gz`, íconos de bases de datos para `.sql`, y más.

Los usuarios de Kitty editan `kitty.conf` directamente. Establezca una línea como `font_family JetBrainsMono Nerd Font` y reinicie Kitty o recargue la configuración. Dado que Kitty maneja Unicode moderno de manera eficiente, los iconos se renderizan con claridad, sin columnas desalineadas ni caracteres de caja rotos.

La densidad visual aumenta, pero la carga cognitiva disminuye. Cuando ejecutas algo como `eza -l --git --icons`, tus ojos pueden escanear para: - Iconos de carpeta para seguir la estructura de directorios - Iconos de repositorio para localizar las raíces de Git - Iconos de lenguaje para encontrar `.ts`, `.rs`, `.go` de un vistazo

Los hipervínculos llevan a eza aún más al territorio de la GUI. Con `--hyperlink`, eza emite secuencias de escape OSC 8 que muchos terminales modernos entienden como enlaces clicables. Los nombres de archivos se convierten en URL que apuntan a rutas `file://`, por lo que hacer clic en ellos puede abrir el Finder en macOS, tu gestor de archivos en Linux, o un editor que se registre como manejador.

El soporte varía según el emulador, pero iTerm2, Kitty y las versiones recientes de GNOME Terminal manejan estos enlaces de manera confiable. Combina `--hyperlink` con `--icons --long --git` y obtendrás un panel denso, clicable y con codificación visual de tu directorio de trabajo, todo desde un solo comando.

ls a la antigua aún se envía en todos los sistemas similares a Unix, pero su conjunto de características se estancó hace décadas. Sin colores por defecto, sin reconocimiento de Git, sin íconos y sin hipervínculos. Puedes añadir alias y LS_COLORS, pero aun así tienes que manejar banderas que varían entre GNU coreutils, BSD y macOS.

Los reemplazos modernos se dividen en tres categorías: exa, lsd y eza. Los tres buscan mejores configuraciones predeterminadas, color y mejor metadata. Sin embargo, solo uno de ellos está siendo mantenido de manera activa en 2024.

Resumen rápido de características:

• 1ls: C, ubicuo, características mínimas, sin Git, sin íconos
• 2exa: Rust, archivado en GitHub, color, Git básico, soporte de árboles limitado.
• 3lsd: Rust, iconos y colores con opinión, sin Git profundo, velocidad de implementación de características más lenta.
• 4eza: Rust, comunidad activa, enfoque en Git, iconos, hipervínculos, árboles, personalización

Diferenciador clave: exa está efectivamente congelado. Su repositorio en GitHub está archivado, con problemas abiertos y PR no fusionados acumulándose. Eza comenzó como un fork, pero los mantenedores de la comunidad de eza lo reconfiguraron en un proyecto en movimiento rápido con lanzamientos frecuentes, banderas modernas y paquetes de distribución que llegan rápidamente.

El rendimiento se mantiene afilado en el trío de Rust. Los benchmarks de los usuarios muestran que eza y lsd ejecutan listados de directorios en decenas de milisegundos en árboles medianos, superando típicamente a GNU ls una vez que habilitas las banderas de color y clasificación comparables. Eza se apoya en el ecosistema amigable con async de Rust y llamadas al sistema eficientes para mantener la latencia baja, incluso cuando `--git` o `--tree` recorren repositorios enteros.

La profundidad de las características es donde eza se destaca. Obtienes `--git`, `--git-repos`, `--git-ignore`, `--colour-scale`, `--icons`, `--hyperlink`, `--only-dirs`, y `--sort` con campos como `size`, `modified`, `created`, y `extension`. Lsd se centra en configuraciones predeterminadas atractivas e íconos, pero omite los metadatos avanzados de Git; exa expone cierta información de Git pero se pierde de nuevas opciones y correcciones de errores que eza agregó.

El ecosistema y la documentación sellan el trato. Eza se integra en Homebrew, en los principales repositorios de Linux y cuenta con páginas de manual detalladas, además de temas de la comunidad y fragmentos de configuración. Para un análisis más profundo, Transforma tu terminal con eza: La actualización que merecía ls – DEV Community explica configuraciones prácticas y alias.

Tomados en conjunto, el desarrollo activo, el rendimiento de Rust y un conjunto de características centrado en Git hacen de eza el reemplazo de `ls` más capaz que puedes instalar en 2024.

Comienza con alias. La mayoría de las personas integran `eza` en su memoria muscular con algunos atajos de alto impacto en `~/.zshrc` o `~/.bashrc`:

• 1`alias ll="eza -l --primero-grupos-directorios --git --iconos"`
• 2`alias la="eza -la --group-directories-first --git --icons"`
• 3`alias lt="eza --tree --level=2 --long --git --icons"`
• 4`alias l1="eza --en una línea --ordenar=nombre"`
• 5`alias lg='eza -l --git --git-ignore --group-directories-first'`

Esos cinco cubren el 90% de las listas del día a día: vistas detalladas, de todos los archivos, en árbol, de una sola columna y conscientes de Git.

A continuación, crea un valor predeterminado personal y asígnalo a `ls` mismo. Muchos desarrolladores lo hacen:

- `alias ls="eza --directorios-grupo-primero --iconos --git --encabezado"`

A partir de ahí, agrega banderas que coincidan con tu flujo de trabajo: `--all` si trabajas con dotfiles, `--binary` si te importan los tamaños legibles por humanos, o `--colour-scale=size` si constantemente buscas grandes artefactos en `dist/` o `node_modules/`.

Los usuarios avanzados apilan múltiples comportamientos en vistas especializadas. Ejemplos:

• 1`alias lcode='eza -l --git --git-ignore --sort=modified --group-directories-first src tests'`
• 2`alias lbig="eza -l --sort=size --reverse --colour-scale=size"`
• 3`alias lrecent='eza -l --sort=modificado --reverse --color-escala=edad'`
• 4`alias ldirs="eza --solo-directorios --agrupar-directorios-primer --árbol --nivel=3"`

Esos comprimen intenciones complejas—“muéstrame los cambios de código recientes” o “destaca los archivos más grandes”—en 5-6 caracteres.

La personalización no se detiene en las banderas. Eza admite temas, por lo que puedes colocar un tema de la comunidad en el directorio de configuración (consulta GitHub) y cambiar al instante, o ajustar los colores manualmente para permisos, enlaces simbólicos y estados de Git utilizando la guía de temas. Combina eso con Nerd Fonts, `--hyperlink` y `--icons` para convertir tu terminal en un panel de control denso y navegable.

Ahora es tu turno: publica tus alias de `eza` más ingeniosos, configuraciones de tema y frases raras en los comentarios. El truco de tres banderas de alguien más podría convertirse en tu nueva opción predeterminada.

¿Qué es eza?

Eza es una utilidad de línea de comandos moderna y rica en características que reemplaza el comando 'ls' tradicional. Escrito en Rust, ofrece un mejor rendimiento, salida codificada por colores, integración con Git, íconos de archivos, vista en árbol y más.

¿Es eza un reemplazo directo y alternativo para 'ls'?

Principalmente, pero no completamente. Aunque puedes asignar 'ls' a 'eza' para el uso diario, algunas opciones y comportamientos de ordenación son diferentes. Por ejemplo, invertir una lista por tiempo requiere una combinación de opciones diferente en eza en comparación con ls.

¿Cómo instalo eza?

Puedes instalar eza utilizando gestores de paquetes como Homebrew para macOS (`brew install eza`) o el gestor de paquetes de tu distribución para Linux (por ejemplo, `sudo apt install eza`).

¿Por qué necesito una fuente de Nerd para usar íconos con eza?

Nerd Fonts son fuentes especiales modificadas con una gran cantidad de glifos e íconos. Eza utiliza estos íconos para representar diferentes tipos de archivos y carpetas, por lo que se debe instalar y configurar una Nerd Font en tu terminal para renderizarlos correctamente.