Editar

Varios cursores

Todos los cursores editan a la vez; escribir, borrar, mover y pegar se aplica a todos ellos.

  • Alt+clic añade un cursor; Alt+doble clic añade como región la palabra que hay bajo el puntero; Alt+arrastrar amplía la última región añadida.
  • Shift+Alt+arrastrar hace una selección en columna: una región por línea entre las dos esquinas del recuadro, recortada a las líneas más cortas (una línea que termina antes del borde izquierdo del recuadro se salta, como en VS Code). Arrastra hacia arriba o hacia la izquierda y las regiones van hacia atrás, así que lo que escribes va donde está el puntero. Un recuadro de anchura cero deja un cursor en cada línea.
  • Seleccionar la siguiente aparición (⌘D / Ctrl+D): un cursor se convierte primero en su palabra; cada pulsación añade la siguiente aparición de la última región añadida, dando la vuelta al documento y sin seleccionar nunca dos veces el mismo texto.
  • Seleccionar todas las apariciones (⌘⇧L / Ctrl+Shift+L): cada aparición del texto de la primera región (la palabra bajo un cursor).
  • Saltar esta aparición (⌘K ⌘D / Ctrl+K Ctrl+D): mueve la última región añadida a la siguiente aparición en lugar de añadirla.
  • Deshacer la última selección deshace el último cambio de selección; Añadir cursor arriba / abajo y Añadir cursor al final de cada línea están en la paleta y en el mapa de teclas.

editor.multicursor-case-sensitive hace que los comandos de apariciones distingan mayúsculas sea cual sea el ajuste de la barra de búsqueda. El comportamiento de arriba lo fija la batería de pruebas de graphoos-app/src/editor/multicursor.rs.

Fragmentos de usuario

Tus propios fragmentos (snippets) viven en ficheros TOML, uno por lenguaje: Abrir los fragmentos de usuario en la paleta abre (y crea, a partir de una plantilla) el fichero del lenguaje del documento activo dentro de la carpeta de configuración (snippets/<language>.toml); un proyecto añade los suyos en .graphoos/snippets/<language>.toml, y global.toml en cualquiera de los dos sitios se aplica a todos los lenguajes. Con el mismo prefijo, ganan los ficheros posteriores.

[[snippets]]
prefix = "tfn"
description = "test function"
body = """
#[test]
fn ${1:name}() {
    ${2:assert!(true)};$0
}
"""

Escribe el prefijo y elige el fragmento en la lista de completado (aparece con su descripción); Tab salta entre los huecos, y $0 es donde termina el cursor. El cuerpo usa la sintaxis de fragmentos de LSP que el editor ya habla: $1, ${1:default}, anidados ${1:outer ${2:inner}}, opciones ${1|a,b,c|} (se inserta la primera). body también puede ser una lista de líneas.

Las variables se expanden al insertar el fragmento: $TM_FILENAME, $TM_FILENAME_BASE, $TM_DIRECTORY, $TM_FILEPATH, $TM_LINE_INDEX, $TM_LINE_NUMBER, $TM_SELECTED_TEXT, $CLIPBOARD, $WORKSPACE_NAME, $CURRENT_YEAR, $CURRENT_YEAR_SHORT, $CURRENT_MONTH, $CURRENT_DATE, $CURRENT_HOUR, $CURRENT_MINUTE, $CURRENT_SECOND, $RANDOM, $RANDOM_HEX, $UUID; ${VAR:default} cuando la variable está vacía. Las transformaciones siguen a VS Code: ${TM_FILENAME/(.*)\..+$/$1/} quita la extensión, ${TM_FILENAME_BASE/(.*)/\U$1/} pasa a mayúsculas, \u \l \L cambian mayúsculas y minúsculas, y g e i son las opciones. Una transformación sobre un hueco (${1/…/…/}) se aplica una sola vez, a su texto por defecto, al insertar el fragmento.

Ruta de navegación y reglas

La barra que hay sobre el editor muestra la ruta del fichero y, tras ella, la cadena de símbolos dentro de los que está el cursor (src › doc.rs › impl Doc › save), según el servidor de lenguaje. editor.show-bread-crumbs = false oculta la barra.

editor.rulers = [80, 100] dibuja una guía vertical en esas columnas.

Refactorizaciones entre ficheros

Renombrar el símbolo (F2) pide al servidor de lenguaje todos los sitios donde se usa el símbolo. Cuando el cambio toca algo más que el fichero en el que estás, GraphoOS dice cuánto cambiaría (12 changes in 5 files) y ofrece tres respuestas: Aplicar, Ver los cambios —que abre una pestaña Refactor preview.md con cada fichero y sus líneas antes y después— o Cancelar. Un renombrado dentro del fichero que ya estás mirando se aplica directamente.

Deshacer la última refactorización deshace la última refactorización aplicada en todos los ficheros que tocó, de una vez (con el deshacer de cada fichero, así que se puede rehacer).

Ordenar los imports y Aplicar todas las correcciones piden al servidor de lenguaje su acción source.organizeImports / source.fixAll y la pasan por la misma vista previa; cuando el servidor no ofrece nada ahí, lo dice en lugar de no hacer nada en silencio.

Conflictos de fusión

Un fichero que una fusión dejó con bloques <<<<<<< / ======= / >>>>>>> se resuelve desde la paleta: Conflicto de fusión: quedarse con el cambio actual, quedarse con el cambio entrante, quedarse con los dos cambios y, cuando git también escribió el antepasado común (merge.conflictStyle = diff3), quedarse con el antepasado común. Actúan sobre el conflicto en el que está el cursor y dicen cuántos quedan en el fichero; ir al siguiente salta al siguiente bloque, dando la vuelta. Cada resolución es una edición normal, así que deshacer devuelve el bloque.

Cada lado se pinta de su color —el de esta rama en verde, el entrante en azul, el del antepasado en rojo— con su línea de marca un tono más fuerte, y la primera línea de cada conflicto lleva un icono en el margen. El icono, y el botón derecho en cualquier punto de un conflicto, ofrecen las mismas acciones, y además:

  • Comparar los dos lados: los dos lados de ese conflicto en un editor de diferencias, como ficheros con el nombre de cada rama (main (HEAD).rs, main (feature).rs).
  • Mostrar qué cambió cada lado: las tres versiones que git guarda mientras una fusión no ha terminado —el antepasado común, la de esta rama y la entrante, enteras— abiertas como dos diferencias contra el antepasado. El resultado se hace en el propio fichero, con las acciones de arriba.

Lo que te dice el árbol de ficheros

Además de colorear los ficheros cambiados, cada fila muestra a su derecha qué le pasa: la letra de estado de git (M modificado, A añadido, D borrado, R renombrado) y los problemas que encontró el servidor de lenguaje (2 ⨯ · 1 ⚠). Una carpeta lleva la suma de lo que tiene debajo, así que un árbol plegado sigue señalando dónde están los errores.

Git: preparar, ramas, fusiones

El menú Git (y la paleta) ejecuta el propio git, así que cada operación significa lo que significa en la línea de órdenes, con sus hooks y su configuración; lo que hizo, o lo que respondió git, vuelve como un mensaje.

  • Un cambio cada vez: botón derecho en una línea cambiada —Preparar este cambio, Quitar este cambio de lo preparado, Descartar este cambio— o Preparar este fichero / Quitar este fichero de lo preparado para el fichero entero. Los ficheros con algo preparado llevan una S en el panel de control de código, y el panel dice cuántos hay.
  • Hacer commit de lo preparado confirma lo preparado, tal cual está preparado, con el mensaje de la caja del panel (el botón Confirmar sigue confirmando enteros los ficheros marcados). Rehacer el último commit vuelve a hacer el último con lo preparado, y con el mensaje de la caja cuando lo hay.
  • Traer (fetch), y Sincronizar: pull —fusionando cuando los dos lados han avanzado— y después push; una rama que todavía no sigue a ninguna va al primer remoto y lo sigue desde entonces.
  • Fusionar una rama…, Rebase sobre…, Aplicar aquí un commit… eligen en la paleta lo que necesitan. Cuando una se detiene por conflictos, el panel dice que está en curso, los ficheros en conflicto están entre los cambios, y Continuar (una vez resueltos y preparados) o Abortar la terminan.
  • Renombrar esta rama…, Borrar una rama… (una con commits propios se conserva salvo que se fuerce), Crear una etiqueta… (un nombre, y después un mensaje para una etiqueta anotada), Borrar una etiqueta…, Enviar las etiquetas, Añadir un remoto… (un nombre y una URL).

Apartar los cambios

Git: apartar los cambios (stash) se lleva todo lo que tiene el árbol de trabajo —incluidos los ficheros que git no ha visto nunca, que es como un stash pierde un fichero nuevo— y deja el árbol como estaba en el commit. Git: cambios apartados (stash) lista lo que hay, del más nuevo al más antiguo, con cuándo se hizo; elegir uno lo recupera y lo quita de la pila. Git: recuperar lo último apartado hace lo mismo sin preguntar cuál.

Cada uno dice lo que ha hecho. Un comando que vacía tus cambios sin decir nada no se distingue de uno que los ha perdido.

Historial de git de un fichero

Git: historial de este fichero en la paleta lista los commits que tocaron el fichero activo, del más nuevo al más antiguo, cada uno con su id corto, autor y fecha; elegir uno abre esa versión como diff frente al fichero tal como está ahora. Lee el repositorio directamente (sin proceso git), y un fichero que no existía en ese commit lo dice.

Historial local

Cada vez que se guarda un fichero —y la primera vez que se abre— GraphoOS guarda una copia fuera del proyecto (history/ en la carpeta de datos). Funciona con ficheros que no están en git y con cambios hechos entre commits.

Historial local: abrir una versión guardada en la paleta lista las versiones del fichero activo, de la más nueva a la más antigua, cada una con su hora, hace cuánto fue, en cuántas líneas difiere de lo que hay ahora en disco y su tamaño; elegir una la abre como diff frente al fichero actual. Historial local: restaurar una versión guardada escribe la versión elegida sobre el fichero (antes se guarda el contenido actual como una versión, así que la propia restauración se puede deshacer), e Historial local: olvidar las versiones de este fichero las borra.

Se conservan las 50 versiones más nuevas de cada fichero, y nada de más de 30 días; editor.local-history = false lo desactiva todo.

Los cambios como patch

Git: ver los cambios de este fichero como patch abre lo que ha cambiado frente a la versión de git como una pestaña .diff: el formato de git diff, con sus bloques @@ y tres líneas de contexto, que se puede leer entero, copiar en un mensaje o aplicar en otro sitio. Lado a lado es mejor para leer un cambio en su sitio; un patch es mejor para verlo entero de un vistazo.

Diff: ver esta comparación como un patch hace lo mismo con la comparación que esté abierta —frente a una rama, frente a un commit, o los dos ficheros de una comparación de carpetas— porque solo necesita los dos lados, que la comparación ya tiene.

Git: comparar este fichero con… abre el fichero junto a la versión de cualquier rama, etiqueta o commit del repositorio, que es como se lee un cambio frente a algo que no sea el último commit.

El explorador

Cada fila lleva lo que es el fichero: la letra de estado de git (M, A, D, R) y el número de errores y avisos que tiene, y una carpeta lleva la suma de lo que tiene debajo, así que el árbol dice dónde mirar sin abrir nada.

Arrastrar un fichero o una carpeta sobre otra carpeta lo mueve allí; soltarlo sobre un fichero lo pone junto a ese fichero; y soltar un fichero sobre un grupo de editores lo abre ahí. La carpeta en la que caería se marca mientras arrastras, y un movimiento que haría perder el fichero —dentro de sí mismo, encima de algo con el mismo nombre— se rechaza con el motivo. Todo lo abierto sigue al fichero a su nueva ruta.

Comparar dos carpetas: Marcar para comparar en una carpeta y Comparar la carpeta con lo marcado en otra lista los ficheros que difieren —los que solo están en un lado y aquellos cuyo contenido ha cambiado— y elegir uno abre los dos como diff. Lo que es igual no se lista, y en .git, node_modules y target no se entra.

El menú del botón derecho tiene Nuevo fichero, Nueva carpeta, Abrir, Abrir al lado, Mostrar en el Finder (o en el gestor de ficheros del sistema), Abrir en el terminal integrado, Buscar en la carpeta…, Abrir los cambios, Abrir en el remoto (web), Historial de este fichero, Renombrar, Duplicar, Mover el fichero / la carpeta a la papelera, Copiar la ruta, Copiar la ruta relativa, Marcar para comparar / Comparar con lo marcado y Actualizar.

Ejecutar las pruebas de lo que has pulsado: Ejecutar las pruebas, Depurar las pruebas y Ejecutar las pruebas con cobertura aparecen sobre un fichero o una carpeta cuando el proyecto dice cómo —cargo test <name> (--lib para src, --tests para tests), pytest <path>, go test ./dir/... o npm test -- <path>—, y la ejecución va al panel Ejecutar y depurar como cualquier otra tarea. La cobertura se pide a cada herramienta a su manera (pytest --cov, go test -cover, npm test -- --coverage, cargo llvm-cov), así que necesita que esa herramienta esté instalada.

Cortar, copiar y pegar un fichero o una carpeta con ⌘X / ⌘C / ⌘V o desde el menú: pegar lo pone dentro de la carpeta seleccionada, o junto al fichero seleccionado. Una carpeta viaja entera. Nunca se sobrescribe nada —un nombre ya ocupado pasa a ser name copy, luego name copy 2— y una carpeta pegada dentro de sí misma se rechaza en lugar de copiarse para siempre.

Solo con el teclado se recorre el árbol: las flechas se mueven y abren o cierran una carpeta, Home y End van a la primera y a la última fila, las teclas de página avanzan de diez en diez, escribir una letra salta a la siguiente fila cuyo nombre empieza por ella, Enter renombra lo seleccionado, ⌘⌫ (Delete en los demás sistemas) lo manda a la papelera, ⇧F10 (o la tecla de menú) abre el menú de lo seleccionado, y ⌘A selecciona el texto del panel para poder copiarlo.

Los demás menús secundarios

Sobre el texto: Ir a la definición, Ir a la definición del tipo, Ver la jerarquía de llamadas, Buscar las referencias, Ir a la implementación, Renombrar el símbolo, Acción de código, Seleccionar todas las apariciones (cada aparición de lo que hay bajo el cursor), Formatear el documento, Formatear la selección, Ordenar los imports, Aplicar todas las correcciones, Preguntar al asistente sobre la selección, Ejecutar en el terminal, Mostrar en el panel, Mostrar en el explorador, Abrir en el remoto, Cortar / Copiar / Pegar, la paleta, y Copiar la ruta / Copiar la ruta relativa de lo que se está editando. En un run.toml el menú es el corto más Añadir configuración de ejecución y depuración.

Formatear la selección (⌘K ⌘F, Ctrl+K Ctrl+F) pide al servidor de lenguaje que formatee solo lo seleccionado; sin nada seleccionado formatea todo el documento, y un servidor que no ofrece formateo por rangos lo dice en lugar de dejar el editor esperando.

Sobre una pestaña del editor: Cerrar, Cerrar las demás, Cerrar todas, Cerrar las pestañas de la derecha / de la izquierda, Cerrar las guardadas, Fijar la pestaña (Soltar la pestaña cuando está fijada), Dividir a la derecha, Dividir abajo, Mostrar en el Finder —el gestor de ficheros del sistema—, Copiar la ruta y Copiar la ruta relativa.

Una pestaña fijada muestra una chincheta donde está su botón de cerrar, se coloca a la izquierda de las que no están fijadas, sobrevive a todos los «cerrar las demás» que haya, y sigue fijada la próxima vez que se abre el editor.

Sobre una pestaña del terminal: Copiar (desactivado si no hay nada seleccionado), Pegar, Seleccionar todo, Buscar…, Limpiar todo, Detener / Reiniciar cuando está ejecutando una tarea, y Cerrar.

Seleccionar y copiar en los paneles

El texto de los paneles es texto: arrastra sobre el mensaje de un problema, un resultado de búsqueda, el nombre de un fichero o la descripción de un plugin y ⌘C (Ctrl+C) lo copia, sin tener que volver a escribirlo.

⌘A en el panel Problemas o Buscar selecciona todas las filas que muestra, y ⌘C copia entonces el conjunto: una línea por fila, cada una con su fichero y su línea, como lo escribe un compilador. Un panel pasa a tener el foco cuando haces clic en él o seleccionas texto en él; hacer clic en un problema o en una coincidencia abre el fichero, así que el foco se va con él al editor.

Los paneles, con el ratón

Problemas: el clic secundario copia el mensaje, o el mensaje con su fichero y su línea como lo escribe un compilador, va al problema, y deja en el panel solo los problemas de ese fichero hasta que vuelvas a pedirlos todos.

Buscar: copiar la línea, copiarla con su sitio, ir a la coincidencia, Reemplazar aquí —que reemplaza esa sola coincidencia, se puede deshacer, y está desactivado mientras el cuadro de reemplazo está vacío— y Descartar este resultado, que quita un resultado de la lista sin tocar el fichero.

Control de versiones: abrir los cambios como diff, incluir el fichero en el commit o dejarlo fuera, descartar sus cambios, mostrarlo en el gestor de ficheros del sistema, y copiar su ruta o su ruta relativa.

Depuración: sobre una variable, copiar su nombre, su valor o ambos, cambiar lo que contiene, y añadirla a Vigiladas.

Extensiones: el clic secundario de la fila abre el mismo menú que el engranaje —recargar, activar o desactivar (aquí o en este proyecto), desinstalar— y Abrir la carpeta de la extensión.

Objetos de texto (modo modal)

Con core.modal = true, i y a después de un operador —o en modo visual— significan «la cosa en la que está el cursor»: ciw cambia la palabra, di( quita lo que hay dentro de los paréntesis, ya" copia la cadena con sus comillas, vip selecciona el párrafo. Los objetos son w y W (palabra y PALABRA), ", ', `, los paréntesis y corchetes ((, [, {, <, y b y B), p (párrafo), s (la línea) y t (la etiqueta XML/HTML más interior).

Marcas (modo modal)

m y después una letra recuerda dónde está el cursor; ' y la misma letra vuelve allí. Una letra minúscula pertenece al fichero en el que se puso, así que ma en un fichero y ma en otro son dos sitios distintos. Una letra mayúscula pertenece a la ventana: 'A abre el fichero en el que se puso, estés donde estés.

Una marca es una línea y una columna, no una posición en los bytes, así que sigue apuntando a la misma línea mientras se escribe texto por encima. Una marca a un fichero que ya no existe se olvida la primera vez que se sigue.

Repetir y reemplazar (modo modal)

. vuelve a escribir el último cambio, fuera lo que fuera: un operador con su movimiento, un objeto de texto, una línea escrita en modo inserción. Se guarda como las teclas que lo hicieron, desde la última vez que el editor estaba en modo normal hasta que volvió a él con el texto cambiado.

r y un carácter reemplaza el carácter que hay bajo el cursor sin salir del modo normal.

Macros (modo modal)

q y una letra empieza a grabar lo que escribes; q otra vez la detiene, y @ con la misma letra la reproduce. @@ vuelve a reproducir la última. Una macro puede reproducir otra macro, hasta cuatro niveles, que basta para construir una a partir de otras y no basta para colgar el editor con una que se reproduce a sí misma.

Registros (modo modal)

" y una letra dice qué registro usa la siguiente copia, borrado o pegado: "ayy guarda la línea en a, "ap la vuelve a pegar, y lo que hay en a se queda ahí mientras yy y p siguen usando el registro sin nombre. Una letra mayúscula añade al registro en lugar de sustituirlo, así que "Ayy en varias líneas las va juntando.

Emmet

En HTML, XML, JSX/TSX, Vue, Svelte y PHP, una abreviatura antes del cursor se expande en el marcado que representa: Emmet: expandir la abreviatura (Ctrl+Alt+E) y, cuando tiene estructura, como propuesta en la lista de completado, así que Enter o Tab la aceptan.

ul>li.item*3              una lista de tres elementos, cada uno con su clase
div#main>p+span           un id, un hijo y su hermano
a[href=# target=_blank]   atributos, entre comillas o no
li.row$*3{fila $}         numerados: row1 … row3, «fila 1» … «fila 3»
(div>p)*2                 los grupos repiten todo lo que tienen dentro
table>tr>td               lo que significa una clase suelta depende del contexto

Los atributos vacíos y los elementos vacíos se convierten en los huecos de un fragmento, así que Tab los recorre, y el cursor termina después del último. Una etiqueta vacía (img, br, input…) se cierra sola.

En CSS, SCSS y Less las abreviaturas son las de Emmet para declaraciones, ofrecidas las primeras en la lista de completado y expandidas con la misma orden:

m10-20        margin: 10px 20px;
w100p         width: 100%;         (p %, e em, x ex, r rem, o la unidad escrita)
fz1.5e        font-size: 1.5em;
df+aic+g8     display: flex; align-items: center; gap: 8px;
c#f           color: #fff;
posa          position: absolute;
m10!          margin: 10px !important;
bdrs          border-radius: |     (el cursor donde va el valor)

Emmet: envolver con una abreviatura… mete la selección —o la línea, sin nada seleccionado— dentro de lo que representa una abreviatura: div.card la envuelve en el div, section>div en el de dentro, y un * sin número hace una copia por línea, así que ul>li* convierte las líneas en una lista.

Etiquetas que se cierran solas

En esos mismos lenguajes, escribir > tras una etiqueta de apertura escribe la de cierre y deja el cursor entre las dos, y escribir </ la completa con la etiqueta que siga abierta. Las etiquetas vacías (br, img, input…) y las que se cierran solas se dejan en paz. editor.auto-closing-tags = false lo desactiva.

Ficheros grandes

Un fichero de más de 4 MB, o con una línea de más de 100 000 caracteres (un JSON escrito en una sola línea, un bundle minificado), se abre sin resaltado de sintaxis, y a partir de 16 MB tampoco se le comunica a ningún servidor de lenguaje. Analizarlo costaría segundos de ventana congelada, y mantenerlo en un servidor costaría memoria que nadie ha pedido; lo que normalmente quieres de un fichero de ese tamaño es mirarlo, y eso sigue funcionando. El editor dice qué ha desactivado al abrir uno.

Imágenes

Abrir un .png, .jpg, .gif, .webp, .svg, .ico o .avif —desde el explorador, desde la paleta o desde un enlace— muestra la imagen en una pestaña, con su tamaño en píxeles y lo que pesa debajo, en lugar de los bytes que la forman. Es una pestaña como cualquier otra, así que se puede dividir junto al código que la usa.

Colores que se ven

Cada color escrito en un fichero —#1e1e2e, #0f08, rgb(220, 30, 90), rgba(0, 128, 255, .5)— recibe una barra de su propio color bajo el texto que lo nombra, sobre un contorno fino para que un color oscuro sobre un tema oscuro se siga viendo. Lo que solo parece un color se deja en paz: el #[derive] de un fichero de Rust no es un color. editor.color-swatches = false lo desactiva.

Color: elegir un color… ofrece el color bajo el cursor escrito de las otras formas —#ff0000, rgb(255 0 0), hsl(0 100% 50%)— y los colores con nombre; Color: escribir un color… acepta uno en cualquiera de esas formas. Lo elegido sustituye al color bajo el cursor (un #hex, un rgb(), un hsl() o un nombre), o va donde está el cursor.

El minimapa

El fichero entero se dibuja en pequeño a lo largo del lado derecho: una barra por línea según su sangría, las líneas que difieren de git en el color del margen, las coincidencias de la barra de búsqueda destacadas, y un recuadro sobre la parte que estás mirando. Hacer clic en él o arrastrarlo te mueve por el fichero. Un fichero demasiado largo para caber se desliza bajo el recuadro, así que el mapa siempre muestra dónde estás. editor.minimap = false lo desactiva y editor.minimap-width cambia su anchura.

Recorrer los cambios

Ir al cambio siguiente (Alt+F5) e Ir al cambio anterior (Shift+Alt+F5) mueven el cursor por los sitios donde el fichero difiere de la versión de git: los mismos cambios que marca el margen. Un bloque de líneas añadidas es una parada, un bloque que se borró para donde sigue el texto, y el último cambio lleva de vuelta al primero.

Enlaces del terminal

Ctrl/Cmd+clic en una línea del terminal abre lo que hay bajo el puntero: un fichero en la línea y la columna que imprimió su herramienta —src/main.rs:12:5, src/a.ts(3,5), File "app.py", line 12, ./cmd/x.go:7:2, una ruta simple o una URL file://— o una dirección web, en tu navegador. Las rutas se resuelven respecto a la carpeta de trabajo del terminal y después respecto al proyecto, y solo se ofrecen si el fichero existe, así que una palabra que solo parece una ruta se deja en paz. Con la integración con la shell configurada, la carpeta del terminal es aquella en la que está realmente la shell, así que los enlaces de un programa que cambió de carpeta siguen funcionando.

Consulta Terminal para buscar en el historial y para volver a ejecutar un comando reciente.

Fuente: docs/es/editing.md