---
title: "Guía de Autocompletado y Sugerencias en Fish Shell"
description: "Cómo funcionan las autosugerencias y el autocompletado con Tab en Fish Shell, cómo configurarlos y cómo escribir tus propias completaciones personalizadas."
date: 2026-02-22
categories: ["vps"]
tags: ["fish-shell"]
---

import Notice from "@components/widgets/Notice.astro";

Lo primero que la gente nota al abrir Fish son las autosugerencias. Empiezas a escribir y aparece texto gris después del cursor, prediciendo lo que quieres. Se siente como si el shell pudiera leer tu mente. Comparado con [Bash o Zsh](/es/fish-shell-vs-bash-vs-zsh-comparacion/), donde necesitas plugins para lograr algo parecido, Fish lo hace desde una instalación limpia.

Esta guía cubre cómo funcionan ambos sistemas — las autosugerencias (las predicciones grises en línea) y las completaciones con Tab (el menú que aparece al presionar Tab) — y cómo configurarlos y extenderlos.

## Autosugerencias

Las autosugerencias son el texto gris que aparece mientras escribes. Fish las obtiene de dos fuentes: tu historial de comandos y las completaciones disponibles (rutas de archivos, nombres de comandos, etc.). Las coincidencias del historial tienen prioridad, así que cuanto más uses un comando, más rápido aparece como sugerencia.

### Cómo aceptar sugerencias

- **Flecha derecha** — aceptar la sugerencia completa
- **Alt+Flecha derecha** (o `Alt+F`) — aceptar una palabra a la vez
- **Ctrl+F** — igual que flecha derecha, aceptar la sugerencia completa
- Seguir escribiendo — ignorar la sugerencia por completo

Aceptar palabra por palabra es útil cuando la sugerencia está cerca pero no es exactamente lo que quieres. Si Fish sugiere `git commit -m "fix auth bug"` y quieres `git commit -m "fix login flow"`, presiona `Alt+Right` tres veces para aceptar `git commit -m` y luego escribe tu propio mensaje.

### Cómo Fish clasifica las sugerencias

Fish elige sugerencias basándose en:

1. Comandos de tu historial que coinciden con lo que has escrito hasta ahora, los más recientes primero
2. Rutas de archivos y completaciones que coinciden con el contexto actual

Si ejecutaste `docker compose up -d` veinte veces esta semana, escribir `do` casi seguro te sugerirá ese comando completo.

### Desactivar autosugerencias

A algunas personas les resultan molestas. Desactívalas así:

```fish
set -g fish_autosuggestion_enabled 0
```

Agrega eso a `~/.config/fish/config.fish` para hacerlo permanente.

## Completaciones con Tab

Presiona Tab y Fish muestra las completaciones posibles en un menú tipo paginador debajo de tu línea de comandos. Cada completación viene con una descripción, así que no tienes que adivinar qué hace `-v` para un comando en particular.

### Cómo navegar el menú de completaciones

- **Tab** — abrir completaciones, o avanzar entre ellas
- **Shift+Tab** — retroceder
- **Teclas de flecha** — navegar la lista de completaciones
- **Enter** — seleccionar la completación resaltada
- **Ctrl+S** — abrir una búsqueda dentro del menú de completaciones (útil cuando hay muchos resultados)

### De dónde vienen las completaciones

Fish obtiene completaciones de varias fuentes:

**Páginas man.** Fish analiza las páginas man en segundo plano y genera completaciones para flags y opciones de comandos. Por eso `rsync --` seguido de Tab te muestra cada flag de `rsync` con descripciones, directamente sin configurar nada.

**Completaciones integradas.** Fish incluye scripts de completación escritos a mano para cientos de comandos: `git`, `docker`, `ssh`, `systemctl`, `apt`, `brew`, `npm`, y muchos más. Se almacenan en el directorio de datos de Fish (normalmente `/usr/share/fish/completions/`).

**Completaciones personalizadas.** Puedes escribir las tuyas propias. Más sobre esto más adelante.

**Rutas de archivos.** Fish completa nombres de archivos y directorios por defecto cuando no hay otras completaciones que coincidan.

### Forzar completación de archivos

A veces las completaciones inteligentes de Fish ocultan rutas de archivos. Presiona `Alt+E` (o `Alt+O` en algunos sistemas) para completar explícitamente una ruta de archivo, saltando las completaciones programadas.

## Escribir completaciones personalizadas

Aquí es donde el sistema de completaciones de Fish se pone interesante. Puedes agregar completaciones para tus propios scripts, herramientas internas, o comandos que no tienen buenas completaciones todavía.

Los archivos de completación van en `~/.config/fish/completions/` y se nombran según el comando: `mycommand.fish` para el comando `mycommand`.

### Ejemplo básico

Digamos que tienes un script llamado `deploy` que acepta los subcomandos `staging`, `production` y `rollback`:

```fish
# ~/.config/fish/completions/deploy.fish

# Desactivar completación de archivos (deploy no usa nombres de archivo)
complete -c deploy -f

# Agregar subcomandos
complete -c deploy -a "staging production rollback" -d "Deployment target"

# Agregar flags
complete -c deploy -s v -l verbose -d "Verbose output"
complete -c deploy -s d -l dry-run -d "Show what would happen without doing it"
```

Ahora `deploy` seguido de Tab muestra tus tres subcomandos, y `deploy --` muestra los dos flags.

### Completaciones según el contexto

Las completaciones pueden ser condicionales. Usa `-n` (condición) para mostrar ciertas completaciones solo en ciertos contextos:

```fish
# Solo mostrar estas cuando no se ha dado un subcomando todavía
complete -c deploy -n "not __fish_seen_subcommand_from staging production rollback" \
    -a "staging production rollback"

# Solo mostrar nombres de rama después de "deploy staging"
complete -c deploy -n "__fish_seen_subcommand_from staging" \
    -a "(git branch --format='%(refname:short)')" -d "Git branch"
```

La función auxiliar `__fish_seen_subcommand_from` verifica si alguna de las palabras dadas ha aparecido en la línea de comandos. Fish incluye varias funciones auxiliares como esta — revisa `/usr/share/fish/completions/git.fish` para un ejemplo real.

### Completaciones con datos dinámicos

El flag `-a` acepta sustituciones de comandos:

```fish
# Completar nombres de contenedores Docker en ejecución
complete -c myapp -l container \
    -a "(docker ps --format '{{.Names}}')" \
    -d "Container name"

# Completar desde un archivo de configuración
complete -c myapp -l profile \
    -a "(cat ~/.myapp/profiles | string split \\n)" \
    -d "Config profile"
```

El comando dentro de `()` se ejecuta cada vez que presionas Tab, así que las completaciones se mantienen actualizadas.

## Ajustar el comportamiento de completación

### Colores de completación

Fish colorea el paginador de completaciones según estas variables:

```fish
set fish_color_search_match --background=yellow  # coincidencia resaltada
set fish_pager_color_completion normal             # texto de completación normal
set fish_pager_color_description grey              # texto de descripción
set fish_pager_color_prefix cyan --underline       # prefijo coincidente
```

También puedes configurarlos a través de `fish_config` en la interfaz del navegador.

### Rendimiento de completaciones

El análisis de páginas man ocurre en segundo plano cuando Fish arranca. Si instalas nuevos programas y sus completaciones no aparecen, ejecuta:

```fish
fish_update_completions
```

Esto regenera las completaciones desde las páginas man. Tarda unos pocos segundos.

### Sensibilidad a mayúsculas

La completación con Tab en Fish no distingue mayúsculas por defecto. Escribe `doc` y coincide tanto con `Documents/` como con `docker`. Si escribes una letra mayúscula, Fish cambia a coincidencia sensible a mayúsculas para esa completación.

## Autosugerencias vs completaciones con Tab

Estas son dos funcionalidades separadas que a veces se confunden:

| | Autosugerencias | Completaciones con Tab |
|---|---|---|
| Disparador | Automático mientras escribes | Presionar Tab |
| Visualización | Texto gris después del cursor | Menú debajo de la línea de comandos |
| Fuente | Historial + completaciones | Solo completaciones |
| Aceptar | Flecha derecha / Ctrl+F | Enter / Tab |
| Muestra opciones | Una sugerencia a la vez | Todas las opciones que coinciden |

Trabajan juntas. Las autosugerencias te dan recuperación rápida del historial sin detenerte. Las completaciones con Tab te dan una lista navegable cuando necesitas explorar opciones.

## Comparación con Zsh y Bash

En [Zsh](/es/fish-shell-vs-zsh-comparacion/), obtienes autosugerencias similares con el plugin `zsh-autosuggestions`. El sistema de completaciones `compinit` de Zsh es potente pero necesita configuración. La ventaja de Fish es que todo esto funciona sin configurar nada.

Bash tiene completación básica con Tab a través de `readline` y `bash-completion`. Funciona para casos simples pero no genera completaciones desde páginas man y no muestra descripciones.

Si quieres configurar Fish desde cero, consulta mi [guía de instalación en Ubuntu](/es/instalar-fish-shell-ubuntu/) o la [guía de configuración en macOS](/es/fish-shell-macos-configuracion/). Para plugins que mejoran aún más las completaciones de Fish, como fzf.fish para búsqueda difusa, revisa [los mejores plugins de Fish Shell](/es/mejores-plugins-fish-shell/).