El último argumento para insertar comandos anteriores en Bash, Fish, ZSH

¿Está escribiendo el mismo nombre de archivo o ruta de carpeta una y otra vez en el terminal? ¡Hay una manera fácil! En esta guía, aprenderás diferentes maneras Inserte el último argumento de su comando anterior En Carnival, Fish y Zsh. ¡Sin recreación, sin errores!

Cómo aprender Repita el último parámetro en su comando anterior Ahorre su tiempo y evite los errores de escritura.

Todos estos consejos deberían ser intento. Algunos pueden ser pez,,,,, Zsh y otras conchas. ¡Comencemos!

¿Cuál es el argumento final?

El último parámetro es la última palabra o parámetro en el comando. Por ejemplo:

mkdir /home/user/my-long-project-name

aquí, /home/user/my-long-project-name Es el último argumento. Puede reutilizar este largo camino automáticamente, pero puede reutilizarlo automáticamente.

Método 1: use el último parámetro del comando anterior $_ Cambiable

este $_ Las variables son la forma más fácil de obtener el último parámetro del comando anterior.

Ejemplo 1:

mkdir project-folder
cd $_

Esto crea una carpeta llamada «Project-Folter» y se mueve hacia ella. este $_ Conviértase automáticamente en una «carpeta de proyecto».

Ejemplo 2:

cp /var/log/nginx/access.log /tmp/backup/
ls -la $_

Esto copia el archivo de registro en la carpeta de copia de seguridad y enumera el contenido de esa carpeta de copia de seguridad. ¡No es necesario escribir una ruta larga dos veces!

Ejemplo 3:

touch notes.txt && nano $_

• touch notes.txt Crear un archivo.
• nano $_ Abierto notes.txt En nanoedit.

Esto funciona muy bien cuando vincula dos comandos.

Cuándo usar $ _

• Ideal para secuencias de comandos y automatización. $_ Se puede usar de forma segura en los scripts, ya que solo se extiende después de que se ejecuta el último comando.
• Funciona en todos los proyectiles principales.
• mayoría Un método confiable Utilizado para operaciones de archivo.

Método 2: use el último parámetro del comando anterior !$

este !$ es una extensión del historial que puede obtener el último parámetro de su comando anterior. tenga en cuenta !$ Los atajos son válidos adelante Tu próximo comando se ejecuta, con $_,eficiente atrás.

Ejemplo 1:

touch important-document.txt
vim !$

Esto crea un archivo y luego lo abre para la edición. este !$ Convertirse en un «patrón importante».

Ejemplo 2:

wget  -O file.zip
unzip !$
rm !$

Esto descargará el archivo, lo extraerá y luego eliminará el archivo zip original.

¡Cuándo usarlo! $

• excelente Uso de terminal interactivo.
• Rápido y fácil de entrar.
• Funciona bien con comandos simples. !$ No siempre funciona bien en scripts o comandos complejos.

Consejos de seguridad: Use el siguiente comando para habilitar la verificación del historial para ver qué !$ Se expandirá a:

shopt -s histverify

Método 3: use el último parámetro de comando Alt+. Atajos de teclado

este Alt+. El acceso directo del teclado inserta los parámetros del último comando, dónde está el cursor correcto.

Cómo usarlo:

1. Ingrese su comando: mkdir my-project
2. Presione Entrar para ejecutar
3. Empiece a escribir: cd
4. de acuerdo a Alt + . (o Esc + .)
5. Insertará automáticamente «my-project»

La función del ciclismo

de acuerdo a Alt + . Pasando el bucle de parámetros anterior varias veces:

git add file1.txt
git commit -m "Added new feature"
git push origin main
cd Alt+.        # Shows "main"
cd Alt+. Alt+.  # Shows "Added new feature"

Cuándo usar Alt+.

• El mejor Tipificación interactiva.
• Puede ver el texto antes de ejecutar el comando.
• Perfecto cuando necesite editar un argumento.

Método 4: Crear funciones personalizadas

Para tareas comunes como la creación y la entrada de directorios, haga sus propias funciones:

mkcd() { mkdir -p "$1" && cd "$1"; }

Agréguelo a su .bashrc Archivo, luego use:

mkcd new-project

Esto creará el directorio e ingresará con un comando.

Características más útiles

# Create and edit a file
touchedit() { touch "$1" && vim "$1"; }

# Copy and then list the destination
cpls() { cp "$1" "$2" && ls -la "$2"; }

Lecturas relacionadas:

Método 5: Usar variables

Para rutas largas o parámetros complejos, guárdelos en variables:

logfile="/var/log/application/debug-$(date +%Y%m%d).log"
tail -f "$logfile"
vim "$logfile"

Esto funciona muy bien cuando necesita usar la misma ruta larga varias veces.

Lecturas relacionadas:

Consejos profesionales para usuarios eléctricos: combinando múltiples métodos

mkdir long-project-name
cd $_  # Runs cd long-project-name
touch readme.md
vim Alt+.  # Shows "vim readme.md"

Tabla de comparación: ¿Qué método elegir?

La diferencia entre $_ y !$ En el carnaval

La diferencia entre $_ y !$ Es sutil en el carnaval, pero es importante. Ambos se refieren a El último argumento El comportamiento de los comandos anteriores, pero se comportan de manera diferente dependiendo de cómo el shell maneja la historia y se ejecute.

$_: El último argumento El último comando ejecutado

• $_ configuración atrás El último comando correr.
• Sostiene El último argumento a ser utilizado Por el caparazón.
• Está disponible como una variable de shell.

!$: El último argumento Último comando de tipificación

• !$ Sí Expansión histórica.
• Significa: «De Entré en el comando anterior. «
• Se ha expandido adelante El comando se ejecuta.

ejemplo

Exploremos un ejemplo práctico.

$ echo one two three
one two three

Intentarlo ahora $_:

$ echo $_
three

$_ espectáculo threela última palabra utilizada en el último comando.

Ahora corre lo mismo echo Comando de nuevo:

$ echo one two three
one two three

Entonces intenta !$:

$ echo !$

!$ También se convirtió threeporque se refiere a la última palabra escrita en el comando anterior.

Pero aquí está su situación diferente:

$ { echo A; echo B; }
A
B

Intenta ahora:

$ echo $_
B

$_ espectáculo Bporque esa es la última oración En realidad se escapó En el bloque de comando anterior.

Intentemos nuevamente el mismo comando:

$ { echo A; echo B; }
A
B

Pero corre:

$ echo !$

Dada la salida inesperada:

echo }
}

¿mirar? !$ Obtenga la última oración (es decir, }) Desde el comando anterior, simplemente imprímalo.

porque:

• !$ Intente expandirse según lo que escriba: { echo A; echo B; }.
• El caparazón no puede tratar la última palabra (}) Correcto debido a las peculiaridades de análisis.

Resumen: $_ VS !$

¿Cuándo usar qué?

• usar $_ En scripts o líneas individuales confiables.
• usar !$ En un mensaje al recordar los nombres o argumentos de archivo rápidamente.
• evitar !$ Tener una estructura de comando compleja if,,,,, {}o tubería.

Errores comunes para evitar

1. Olvidé la cita

Siempre cita alrededor de variables con espacio:

# Wrong - will cause errors
file="my document.txt"
cat $file

# Right - handles spaces correctly
cat "$file"

2. Use !$ En el guión

este !$ Los métodos no funcionan de manera confiable en los scripts. usar $_ en cambio:

#!/bin/bash
# This might not work as expected
mkdir project && cd !$

# This works reliably
mkdir project && cd $_

3. No verifiques lo que obtienes

y Alt+.puede ver el texto antes de ejecutar. Esto evita errores:

rm important-file.txt
# Later, you want to restore it
git checkout Alt+.  # You see "git checkout important-file.txt" before running

Ejemplos del mundo real

1. Desarrollo de redes

# Download a project
git clone 
cd $_

# Start the development server
npm install
npm start

2. Gestión del sistema

# Check a log file
tail -f /var/log/apache2/error.log
# Edit the same file
sudo vim $_

3. Gestión de archivos

# Find a file
find /home -name "*.pdf" -type f
# Copy the found file
cp $(find /home -name "*.pdf" -type f | head -1) /tmp/
ls -la $_

Resolver las preguntas frecuentes

El comando no se puede encontrar

si !$ No funciona, las extensiones históricas pueden deshabilitarse:

set +H  # Disable history expansion
set -H  # Enable history expansion

alt+. No funciona

Prueba estas alternativas:

• Esc + . (especialmente en Mac)
• Verifique la vinculación clave del terminal
• Asegúrese de usar Bash o Zsh

$ _Chowe el valor del error

este $_ Cada comando actualiza la variable. Asegúrese de usarlo inmediatamente después del comando:

mkdir test
echo "hello"  # This updates $_
cd $_  # This will try to cd to "hello", not "test"

Mesa trampa

Aquí hay una hoja de trucos para todos los métodos que discutimos en la sección anterior. Imprima y manténgalo cerca de la mesa para una referencia rápida.

# Method 1: $_ variable
mkdir folder
cd $_

# Method 2: !$ history expansion  
touch file.txt
vim !$

# Method 3: Alt+. keyboard shortcut
mkdir project
cd [Alt+.]

# Method 4: Custom function
mkcd() { mkdir -p "$1" && cd "$1"; }

# Method 5: Variables
path="/long/path/to/file"
cp "$path" /backup/ && ls "$path"

Preguntas frecuentes

en conclusión

Aprender a repetir el último argumento de los comandos anteriores es muy útil para la productividad terminal. Aquí hay algo para recordar:

• usar $_ Para secuencias de comandos y automatización confiable
• usar !$ Para comandos interactivos rápidos
• usar Alt+. Cuando desee ver y editar antes de ejecutar
• Creando una función Para las tareas que realiza con frecuencia
• Usar variables Para argumentos complejos o repetitivos

Comience con el método que funcione mejor para usted. Con tu comodidad, prueba a alguien más. Pronto, te preguntarás cómo trabajas sin estos consejos para ahorrar tiempo.

La mejor parte? Estos métodos funcionan juntos. Puede combinarlos para crear poderosos flujos de trabajo que harán que su terminal funcione más rápido.

Ahora pruebe uno de estos métodos en la terminal. Crear un directorio de prueba y usar $_ o Alt+.. Una vez que comience a usar estos consejos, ¡nunca más volverá a escribir los mismos parámetros!

Lectura sugerida: