.. _8: 8 Comandos Básicos de Edición ============================= Aquí explicamos lo básico sobre cómo escribir texto, hacer correcciones y guardar el texto en un archivo. Si este material es nuevo para Usted, le sugerimos que primero ejecute el tutorial Emacs *learning-by-doing* (aprender-haciendo), tecleando :kbd:`Ctrl`-:kbd:`h` :kbd:`t` (``C-h t``, ``help-with-tutorial``, ayuda-con-tutorial). .. _8.1: 8.1 Inserción de Texto ---------------------- Puede insertar un *carácter gráfico* normal (por ejemplo, ``a``, ``B``, ``3`` y ``=``) tipeando la combinación de tecla asociada. Esto añade al búfer el carácter en el punto. La inserción desplaza el punto hacia delante, de modo que el punto queda justo después del texto insertado. Véase :ref:`1.1`. Para terminar una línea e iniciar una nueva, escriba :kbd:`RETURN` (``RET``, nueva línea). (La tecla :kbd:`RETURN` puede estar etiquetada como *Return*, o *Enter*, o con una flecha de aspecto gracioso apuntando hacia la izquierda en su teclado, pero en este manual nos referimos a ella como :kbd:`RETURN` (``RET``)). Este comando inserta un carácter de nueva línea en el búfer, y luego aplica una sangría (véase :ref:`25`) de acuerdo con el modo principal. Si el punto está al final de la línea, el efecto es crear una nueva línea en blanco después de él y sangrar la nueva línea; si el punto está en medio de una línea, la línea se divide en esa posición. Para desactivar la sangría automática, puede desactivar el modo de sangría eléctrica (véase :ref:`25.4`) o teclear :kbd:`Ctrl`-:kbd:`j` (``C-j``), que inserta sólo una nueva línea, sin ninguna sangría automática. Como explicaremos más adelante en este manual, puede cambiar la forma en que Emacs maneja la inserción de texto activando *modos menores*. Por ejemplo, el modo secundario llamado Auto Fill Mode (Modo de Relleno Automático) divide las líneas automáticamente cuando son demasiado largas (ver :ref:`26.6`). El modo secundario, o modo menor llamado Overwrite Mode (Modo Sobrescribir) hace que los caracteres insertados reemplacen (sobrescriban) el texto existente, en lugar de desplazarlo a la derecha. Véase :ref:`24.2`. Sólo se pueden insertar caracteres gráficos tecleando la tecla asociada; otras teclas actúan como comandos de edición y no se insertan. Por ejemplo, :kbd:`DEL` (``DEL``) ejecuta el comando ``delete-backward-char`` (borrar-carácter-anterior) por defecto (algunos modos lo vinculan a un comando diferente); no inserta un carácter literal ``DEL`` (código de carácter ASCII 127). Para insertar un carácter no gráfico, o un carácter que su teclado no admita, primero cítelo escribiendo :kbd:`Ctrl`-:kbd:`q` (``C-q``, ``quoted-insert``). Hay dos formas de utilizar :kbd:`Ctrl`-:kbd:`q`: * :kbd:`Ctrl`-:kbd:`q` (``C-q``) seguido de cualquier carácter no gráfico (incluso :kbd:`Ctrl`-:kbd:`g` (``C-g``)) inserta ese carácter. Por ejemplo, :kbd:`Ctrl`-:kbd:`q` :kbd:`DEL` (``C-q DEL``) inserta un carácter literal ``DEL``. * :kbd:`Ctrl`-:kbd:`q` (``C-q``) seguido de una secuencia de dígitos octales inserta el carácter con el código de carácter octal especificado. Puede utilizar cualquier número de dígitos octales; cualquier carácter que no sea un dígito termina la secuencia. Si el carácter de terminación es ``RET``, ese ``RET`` sólo sirve para terminar la secuencia. Cualquier otro carácter que no sea un dígito termina la secuencia y actúa como una entrada normal, por ejemplo, :kbd:`Ctrl`-:kbd:`q` :kbd:`1` :kbd:`0` :kbd:`1` :kbd:`B` (``C-q 1 0 1 B``) inserta ``AB``. El uso de secuencias octales está desactivado en el modo de sobrescritura ordinario no binario, para ofrecerle una forma cómoda de insertar un dígito en lugar de sobrescribirlo. Para utilizar decimal o hexadecimal en lugar de octal, establezca la variable ``read-quoted-char-radix`` en 10 o 16. Si es base 16, las letras ``a`` a ``f`` sirven como parte de un código de carácter, igual que los dígitos. Se ignoran las mayúsculas y minúsculas. Se pueden insertar algunos caracteres Unicode comunes mediante un comando que empiece por :kbd:`Ctrl`-:kbd:`x` :kbd:`8` (``C-x 8``). Por ejemplo, :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`[` (``C-x 8 [``) inserta ``‘``, que es el punto de código Unicode U+2018 COMILLA SIMPLE IZQUIERDA, a veces llamada "comilla curva" o "comilla rizada". Del mismo modo, :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`]` (``C-x 8 ]``), :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`{` (``C-x 8 {``) y :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`}` (``C-x 8 }``) insertan las comillas curvas ``’``, ``“`` y ``’``, respectivamente. La tecla :kbd:`Alt` también puede actuar como :kbd:`Ctrl`-:kbd:`x` :kbd:`8` (``C-x 8``) (a menos que vaya seguida de :kbd:`RETURN` (``RET``)); por ejemplo, :kbd:`Alt`-:kbd:`[` (``M-[``) actúa como :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`[` (``C-x 8 [``) e inserta ``‘``. Para ver qué caracteres tienen abreviaturas :kbd:`Ctrl`-:kbd:`x` :kbd:`8` (``C-x 8``), escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`Ctrl`-:kbd:`h` (``C-x 8 C-h``). También puede utilizar el comando :kbd:`Ctrl`-:kbd:`x` :kbd:`8` :kbd:`RETURN` (``C-x 8 RET``, ``insert-chart``, insertar carácter). Este comando solicita el nombre Unicode o el punto de código de un carácter, utilizando el minibuffer. Si introduce un nombre, el comando lo completa (véase :ref:`9.4`). Si introduce un punto de código, debe ser como un número hexadecimal (la convención para Unicode), o un número con un radix especificado, por ejemplo, ``#o23072`` (octal); **Ver Conceptos Básicos de Enteros** en el Manual de Referencia de Emacs Lisp. A continuación, el comando inserta el carácter correspondiente en el búfer. Por ejemplo, todos los siguientes insertan el mismo carácter: :: C-x 8 RET left single quotation mark RET C-x 8 RET left sin TAB RET C-x 8 RET 2018 RET C-x 8 [ A-[ (if the Alt key works) ` (in Electric Quote mode) Un argumento numérico para :kbd:`Ctrl`-:kbd:`q` (``C-q``) o :kbd:`Ctrl`-:kbd:`x` :kbd:`8` ``...`` (``C-x 8 ...``) especifica cuántas copias del carácter se insertarán (véase :ref:`8.10`). Como alternativa a ``C-x 8``, puede seleccionar el método de entrada transitorio correspondiente tecleando :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`x` :kbd:`\\` ``iso-transl`` :kbd:`RETURN` (``C-u C-x \ iso-transl RET``) , luego activar temporalmente este método de entrada transitorio tecleando :kbd:`Ctrl`-:kbd:`x` :kbd:`\\` :kbd:`[` (``C-x \ [``) insertará el mismo carácter ``‘`` (ver :ref:`23.4`). Además, en algunos contextos, si escribe una cita utilizando acento grave y apóstrofo ``\`como esta'``, se convierte en una forma ``\``como esta''`` usando comillas simples, incluso sin comandos :kbd:`Ctrl`-:kbd:`x` :kbd:`8` (``C-x 8``). Del mismo modo, si escribe una cita ``como ésta''`` usando doble acento grave y apóstrofo, se convierte en una forma ``“como ésta”`` usando comillas dobles. Véase :ref:`26.5`. .. _8.2: 8.2 Cambiar la Ubicación del Punto ---------------------------------- Para hacer algo más que insertar caracteres, debe saber cómo mover el punto (véase :ref:`1.1`). Los comandos de teclado :kbd:`Ctrl`-:kbd:`f` (``C-f``), :kbd:`Ctrl`-:kbd:`b` (``C-b``), :kbd:`Ctrl`-:kbd:`n` (``C-n``) y :kbd:`Ctrl`-:kbd:`p` (``C-p``) mueven el punto a la derecha, izquierda, abajo y arriba, respectivamente. También puede mover el punto usando las *teclas de flecha* presentes en la mayoría de los teclados: :kbd:`←` (``RIGHT``, DERECHA), :kbd:`→` (``LEFT``, IZQUIERDA), :Kbd:`↓` (``DOWN``, ABAJO) y :kbd:`↑` (``UP`` ,ARRIBA); sin embargo, muchos Usuarios de Emacs encuentran que es más lento usar las teclas de flecha que las teclas de control, porque necesita mover su mano al área del teclado donde se encuentran esas teclas. También puede pulsar el botón izquierdo del ratón para mover el punto a la posición pulsada. El Editor también proporciona una variedad de comandos de teclado adicionales que mueven el punto de formas más sofisticadas. :kbd:`Ctrl`-:kbd:`f` (``C-f``) Avanza el punto un caraceter (``forward-chart``). :kbd:`→` (``right``) Este comando (``right-char``) se comporta como ``C-f``, excepto cuando el punto está en un párrafo de derecha a izquierda (véase :ref:`23.20`). :kbd:`Ctrl`-:kbd:`b` (``Ctrl-b``) Mueve el punto un caracter hacia atras (``backward-chart``). :kbd:`←` (``left``) Este comando (``left-char``) se comporta como ``C-b``, excepto si el párrafo actual es de derecha a izquierda (véase :ref:`23.20`). | :kbd:`Ctrl`-:kbd:`n` (``Ctrl-n``) | :kbd:`↓` Se desplaza hacia abajo una línea de la pantalla (``next-line``). Este comando intenta mantener la posición horizontal sin cambios, por lo que si empieza en medio de una línea, se mueve a la mitad de la siguiente. | :kbd:`Ctrl`-:kbd:`p` (``Ctrl-p``) | :kbd:`↑` Mueve el punto una línea hacia arriba (``previous-line``). Este comando conserva la posición dentro de la línea, como ``C-n``. | :kbd:`Ctrl`-:kbd:`a` (``Ctrl-a``) | :kbd:`Inicio` Mueve el punto al comienzo de la línea (``move-beginning-of-line``). | :kbd:`Ctrl`-:kbd:`e` (``Ctrl-e``) | :kbd:`Fin` Mueve el punto al final de la línea (``move-end-of-line``). :kbd:`Ctrl`-:kbd:`f` (``Ctrl-f``) Avanza el punto una palabra (``forward-word``). Vea :ref:`26.1`. | :kbd:`Ctrl`-:kbd:`→` (``Ctrl-right``) | :kbd:`Alt`-:kbd:`→` (``M-right``) Este comando (``right-word``) se comporta como ``M-f``, excepto que retrocede una palabra si el párrafo actual es de derecha a izquierda. Véase :ref:`23.20`. :kbd:`Alt`-:kbd:`b` (``M-b``) Mueve el punto una palabra hacia atrás (``backward-word``). Vea :ref:`26.1`. | :kbd:`Ctrl`-:kbd:`←` (``Ctrl-left``) | :kbd:`Alt`-:kbd:`→` (``M-right``) Este comando (``left-word``) se comporta como ``M-b``, excepto que *avanza* una palabra si el párrafo actual es de derecha a izquierda. Véase :ref:`23.20`. :kbd:`Alt`-:kbd:`r` (``M-r``) Sin mover el texto en la pantalla, reposiciona el punto en el margen izquierdo de la línea de texto situada más al centro de la ventana; en invocaciones consecutivas posteriores, mueve el punto al margen izquierdo de la línea situada más arriba, a la línea situada más abajo, y así sucesivamente, en orden cíclico (``move-to-window-line-top-bottom``). Un argumento numérico dice en qué línea de la pantalla colocar el punto, contando hacia abajo desde la parte superior de la ventana (cero significa la línea superior). Un argumento negativo cuenta las líneas hacia arriba desde la parte inferior (-1 significa la línea inferior). Véase :ref:`8.10`, para más información sobre argumentos numéricos. :kbd:`Alt`-:kbd:`<` (``M-<``) Se desplaza a la parte superior del búfer (``beginning-of-buffer``, del búfer). Con argumento numérico n, se desplaza a n/10 de la parte superior. En pantallas gráficas, :kbd:`Ctrl`-:kbd:`Inicio` (``C-Inicio``) hace lo mismo. :kbd:`Alt`-:kbd:`>` (``M->``) Se desplaza al final del búfer (``end-of-buffer`` pantallas gráficas, (``C-Fin``) hace lo mismo. | :kbd:`Ctrl`-:kbd:`v` (``Ctrl-v``) | :kbd:`PageDown` | ``next`` Desplaza la visualización una pantalla hacia delante y, si es necesario, desplaza un punto en la pantalla (comando de desplazamiento hacia arriba). Véase :ref:`15.1`. | :kbd:`Alt`-:kbd:`v` (``M-v``) | :kbd:`PageUp` | ``prior`` Desplaza una pantalla hacia atrás y, si es necesario, desplaza un punto en la pantalla (comando de desplazamiento hacia abajo). Véase :ref:`15.1`. :kbd:`Alt`-:kbd:`g`-:kbd:`c` (``M-g-c``) Lee un número *n* y mueve el punto a la posición *n* del buffer. La posición 1 es el principio del buffer. Si el punto está sobre o justo después de un número en el buffer, ese es el valor por defecto para *n*. Sólo tiene que escribir :kbd:`RETURN` (``RET``) en el minibuffer para usarlo. También puede especificar *n* dándole a :kbd:`Alt`-:kbd:`g`-:kbd:`c` (``M-g c``) un argumento prefijo numérico. | :kbd:`Alt`-:kbd:`g` :kbd:`Alt`-:kbd:`g` (``M-g M-g``) | :kbd:`Alt`-:kbd:`g`:kbd:`g` (``M-g g``) Lee un número *n* y mueve el punto al principio de la línea número *n* (``goto-línea``). La línea 1 es el principio del buffer. Si el punto está sobre o justo después de un número en el buffer, ese es el valor por defecto para *n*. Simplemente teclee :kbd:`RETURN` (``RET``) en el minibuffer para usarlo. También puede especificar *n* dándole a ``M-g M-g`` un argumento de prefijo numérico. Ver :ref:`20.1`, para el comportamiento de ``M-g M-g`` cuando le da un argumento de prefijo simple. Alternativamente, puede usar el comando ``goto-line-relative`` para mover el punto a la línea relativa a la porción accesible del buffer reducido. ``goto-line`` tiene su propia lista de historial (ver :ref:`9.5`). Puede tener una única lista compartida entre todos los buffers (por defecto) o una lista separada para cada buffer, personalizando la opción de usuario ``goto-line-history-local``. :kbd:`Alt`-:kbd:`g` :kbd:`TAB` (``M-g TAB``) Lee un número *n* y se desplaza a la columna *n* de la línea actual. La columna 0 es la columna más a la izquierda. Si se llama con un argumento prefijo, se mueve al número de columna especificado por el valor numérico del argumento. :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`n` (``Ctrl-x Ctrl-n``) Usa la columna actual del punto como *columna meta semipermanente* (``set-goal-column``) en el buffer actual. Cuando una columna meta semipermanente está en efecto, :kbd:`Ctrl`-:kbd:`p` (``C-n``), :kbd:`Ctrl`-:kbd:`n` (``C-p``), ```` y ```` siempre intentan moverse a esta columna, o lo más cerca posible de ella, después de moverse verticalmente. La columna de meta permanece vigente hasta que se cancela. :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`n` (``C-u C-x C-n``) Anula la columna de meta. En adelante, ``C-n`` y ``C-p`` intentan conservar la posición horizontal, como de costumbre. Cuando una línea de texto en el buffer es más larga que el ancho de la ventana, Emacs normalmente la muestra en dos o más líneas de pantalla. Por comodidad, :kbd:`Ctrl`-:kbd:`n` (``C-n``) y :kbd:`Ctrl`-:kbd:`p` (``C-p``) mueven el punto por líneas de pantalla, al igual que las teclas equivalentes abajo y arriba. Puede forzar que estos comandos se muevan según las líneas lógicas (es decir, según las líneas de texto en el buffer) estableciendo la variable ``line-move-visual`` a ``nil``; si una línea lógica ocupa varias líneas de pantalla, el cursor se salta entonces las líneas de pantalla adicionales. Para más detalles, véase :ref:`8.8`. Véase :ref:`50.2`, para saber cómo establecer variables como ``line-move-visual``. A diferencia de ``C-n`` y ``C-p``, la mayoría de los comandos Emacs que trabajan sobre líneas trabajan sobre líneas lógicas. Por ejemplo, ``C-a`` (``move-beginning-of-line``, mover-principio-de-línea) y ``C-e`` (``move-end-of-line``, mover-fin-de-línea) se mueven respectivamente al principio y al final de la línea lógica. Siempre que encontremos comandos que trabajen sobre líneas de pantalla, como ``C-n`` y ``C-p``, los señalaremos. Cuando ``line-move-visual`` es ``nil`` (nulo), también puede establecer la variable ``track-eol`` a un valor no nulo. Entonces ``C-n`` y ``C-p``, cuando empiezan al final de la línea lógica, se mueven al final de la siguiente línea lógica. Normalmente, ``track-eol`` es ``nil``. ``C-n`` normalmente se detiene al final del buffer cuando lo usa en la última línea del buffer. Sin embargo, si establece la variable next-line-add-newlines a un valor no nulo, ``C-n`` en la última línea de un buffer crea una línea adicional al final y se mueve hacia abajo en ella. .. _8.3: 8.3 Borrar Texto ---------------- | :kbd:`DEL` (``DEL``) | :kbd:`BACKSPACE` (``BACKSPACE``) Borra el carácter anterior al punto, o la región si está activa (``delete-backward-char``). ``Delete`` Borra el carácter tras el punto, o la región si está activa (``delete-forward-char``). :kbd:`Ctrl`-:kbd:`d` Borra el caracter después del punto (``delete-char``). :kbd:`Ctrl`-:kbd:`k` Mata hasta el fina de la línea (``kill-line``). :kbd:`Alt`-:kbd:`d` (``M-d``) Avanza hasta el final de la siguiente palabra (``kill-word``). :kbd:`Alt`-:kbd:`DEL` Mata al principio de la palabra anterior (``backward-kill-word``) El comando :kbd:`DEL` (``DEL``, ``delete-backward-char``) elimina el carácter anterior al punto, moviendo el cursor y los caracteres posteriores hacia atrás. Si el punto estaba al principio de una línea, borra la nueva línea precedente, uniendo esta línea a la anterior. Si, por el contrario, la región está activa, :kbd:`DEL` (``DEL``) borra el texto de la región. Véase :ref:`12.6`, para una descripción de la región. En la mayoría de los teclados, la tecla :kbd:`DEL` (``DEL``) se denomina *BACKSPACE* (RETROCESO), pero en este manual nos referiremos a ella como :kbd:`DEL` (``DEL``). (No confunda ``DEL`` con la tecla :kbd:`Supr` (Suprimir); hablaremos de Suprimir momentáneamente.) En algunos terminales de texto, Emacs puede no reconocer la tecla :kbd:`DEL` correctamente. Vea :ref:`52.8` se encuentra con este problema. El comando ``Delete`` (``delete-forward-char``) borra en la dirección opuesta: borra el carácter después del punto, es decir, el carácter bajo el cursor. Si el punto estaba al final de una línea, une la línea siguiente a ésta. Al igual que ``Delete``, borra el texto de la región si ésta está activa (véase :ref:`12`). :kbd:`Ctrl`-:kbd:`d` (``C-d``, ``delete-char``) borra el carácter después del punto, de forma similar a ``Delete``, pero independientemente de si la región está activa. Consulte :ref:`13.1.1`, para obtener información más detallada sobre los comandos de borrado anteriores. Consulte :ref:`13`, para más información sobre ``C-k`` y comandos relacionados. 8.4 Deshacer cambios -------------------- | :kbd:`Ctrl`-:kbd:`/` | :kbd:`Ctrl`-:kbd:`x` :kbd:`u` | :kbd:`Ctrl`-:kbd:`_` Deshace una entrada de los registros de deshacer, usualmente, un comando que sea valido (``undo``, deshacer). (La primera tecla puede no estar disponible en pantallas en modo texto). Emacs registra una lista de los cambios realizados en el texto del buffer, por lo que puede deshacer los cambios recientes. Esto se hace usando el comando deshacer, que está ligado a ``C-/`` (así como ``C-x u`` y ``C-_``). Normalmente, este comando deshace el último cambio, devolviendo el punto a donde estaba antes del cambio. El comando deshacer sólo se aplica a los cambios en el búfer; no se puede utilizar para deshacer el movimiento del cursor. En un terminal que admita el modificador ``Control`` en todas las demás teclas, la forma más sencilla de invocar deshacer es con :kbd:`Ctrl`-:kbd:`/` (``C-/``), ya que no necesita el modificador ``Shif`` (Mayúsculas). En terminales que sólo permiten los caracteres de control ASCII, ``C-/`` no existe, pero para muchos de ellos :kbd:`Ctrl`-:kbd:`_` ``C-_`` todavía funciona porque realmente envía a Emacs el comando ``C-_``, mientras que muchos otros le permiten omitir el modificador ``Shift`` cuando teclea :kbd:`Ctrl`-:kbd:`_` ``C-_`` (en efecto pulsando :kbd:`Ctrl`-:kbd:`-` (``C--``)), haciendo que sea la forma más conveniente de invocar ``undo``. Aunque cada comando de edición suele tener una entrada independiente en los registros de deshacer, los comandos muy sencillos pueden agruparse. A veces, una entrada puede cubrir sólo parte de un comando complejo. Si repite :kbd:`Ctrl`-:kbd:`/` (``C-/``) (o sus alias), cada repetición deshace otro cambio anterior, hasta el límite de la información de deshacer disponible. Si ya se han deshecho todos los cambios registrados, el comando deshacer muestra un mensaje de error y no hace nada. Para obtener más información sobre el comando deshacer, consulte :ref:`17.1`. .. _8.5: 8.5 Archivos ------------ El texto que inserta en un búfer de Emacs sólo dura lo que dura la sesión de Emacs. Para mantener cualquier texto permanentemente, deberá ponerlo en un *archivo*. Suponga que hay un fichero llamado ``test.emacs`` en su directorio personal. Para empezar a editar este archivo en Emacs, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`f` ``test.emacs`` :kbd:`RETURN` (``C-x C-f test.emacs RET``) Aquí el nombre del archivo se da como *argumento* al comando ``C-x C-f`` (``find-file``, buscar archivo). Ese comando usa el *minibuffer* para leer el argumento, y teclea :kbd:`RETURN` (``RET``) para terminar el argumento (ver :ref:`9`). Emacs obedece este comando *visitando* el fichero: crea un buffer, copia el contenido del fichero en el buffer, y luego muestra el buffer para editarlo. Si altera el texto, puede *guardar* el nuevo texto en el archivo tecleando (``C-x C-s``, ``save-buffer``). Esto copia el contenido alterado del buffer en el archivo ``test.emacs``, haciéndolo permanente. Hasta que lo guarde, el texto modificado sólo existe dentro de Emacs, y dicho archivo permanece inalterado. Para crear un fichero, basta con visitarlo con :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`f` (``C-x C-f``) como si ya existiera. Esto crea un buffer vacío, en el que puede insertar el texto que quiera poner en el fichero. Emacs realmente crea el fichero la primera vez que guarda este buffer con :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`s` (``C-x C-s``). Para aprender más sobre el uso de ficheros en Emacs, vea :ref:`19`. 8.6 Ayuda --------- Si olvida lo que hace una tecla, puede averiguarlo escribiendo :kbd:`Ctrl`-:kbd:`h` :kbd:`k` (``C-h k``, ``describe-key``, describir-tecla), seguido de la tecla que le interesa; por ejemplo, :kbd:`Ctrl`-:kbd:`h` :kbd:`k` :kbd:`Ctrl`-:kbd:`n` (``C-h k C-n``) le dice lo que hace ``C-n``. El prefijo :kbd:`Ctrl`-:kbd:`h` (``C-h``) significa "help" (ayuda). La tecla :kbd:`F1` sirve de alias para :kbd:`Ctrl`-:kbd:`h` (``C-h``). Aparte de :kbd:`Ctrl`-:kbd:`h` :kbd:`k` (``C-h k``), hay muchos otros comandos de ayuda que proporcionan diferentes tipos de ayuda. Para más detalles, consulte :ref:`11`. .. _8.7: 8.7 Líneas en Blanco -------------------- Aquí encontrará comandos y técnicas especiales para insertar y eliminar líneas en blanco. :kbd:`Ctrl`-:kbd:`o` (``Ctrl-o``) Inserta una línea en blanco después del cursor (``open-line``). :kbd:`Ctrl`-:kbd:`x` :kbd:`Ctrl`-:kbd:`o` (``C-x C-o``) Borra todas las líneas en blanco consecutivas menos una (``delete-blank-lines``). Hemos visto cómo :kbd:`RETURN` (``RET``, ``new-line`` , nueva línea) inicia una nueva línea de texto. Sin embargo, puede ser más fácil ver lo que está haciendo si primero hace una línea en blanco y luego inserta en ella el texto deseado. Esto es fácil de hacer usando la tecla :kbd:`Ctrl`-:kbd:`o` (``C-o``, ``open-line``), que inserta una nueva línea después del punto pero deja el punto delante de la nueva línea. Después de :kbd:`Ctrl`-:kbd:`o` (``C-o``), escriba el texto de la nueva línea. Puede crear varias líneas en blanco tecleando :kbd:`Ctrl`-:kbd:`o` (``C-o``) varias veces, o dándole un argumento numérico que especifique cuántas líneas en blanco debe crear. Vea :ref.`8.10`, para saber cómo. Si tiene un prefijo de relleno, el comando ``C-o`` inserta el prefijo de relleno en la nueva línea, si se escribe al principio de una línea. Véase :ref:`26.6.3`. La forma más fácil de deshacerse de las líneas en blanco extra es con el comando ``C-x C-o`` (``delete-blank-lines``). Si el punto se encuentra dentro de una serie de líneas en blanco, ``C-x C-o`` borra todas menos una. Si el punto se encuentra en una sola línea en blanco, ``C-x C-o`` lo borra. Si el punto se encuentra en una línea que no está en blanco, ``C-x C-o`` borra todas las líneas en blanco siguientes, si existen. .. _8.8: 8.8 Líneas de Continuación -------------------------- A veces, una línea de texto en el buffer -una *línea lógica*- es demasiado larga para caber en la ventana, y Emacs la muestra como dos o más *líneas en pantalla*. Esto se llama *ajuste de línea o continuación*, y la línea lógica larga se llama *línea continuada*. En una pantalla gráfica, el Editor indica el ajuste de línea con pequeñas flechas dobladas en los bordes izquierdo y derecho de la ventana. En un terminal de texto, Emacs indica el ajuste de línea mostrando un carácter ``\`` en el margen derecho. La mayoría de los comandos que actúan sobre líneas lo hacen sobre líneas lógicas, no sobre líneas de pantalla. Por ejemplo, :kbd:`Ctrl`-:kbd:`k` (``C-k``) elimina una línea lógica. Como se describió anteriormente, :kbd:`Ctrl`-:kbd:`n` (``C-n``, ``next-line``, línea-siguiente) y :kbd:`Ctrl`-:kbd:`p` (``C-p``, ``previous-line``, línea-anterior) son excepciones especiales: mueven el punto hacia abajo y hacia arriba, respectivamente, una línea de pantalla (ver :ref:`8.2`). Emacs puede opcionalmente *truncar* líneas lógicas largas en lugar de continuarlas. Esto significa que cada línea lógica ocupa una sola línea de pantalla; si es más larga que el ancho de la ventana, el resto de la línea no se muestra. En una pantalla gráfica, una línea truncada se indica mediante una pequeña flecha recta en la franja derecha; en un terminal de texto, se indica mediante un carácter ``$`` en el margen derecho. Véase :ref:`15.22`. Por defecto, las líneas continuas se ajustan al borde derecho de la ventana. Dado que el ajuste puede producirse en medio de una palabra, las líneas continuas pueden ser difíciles de leer. La solución habitual es romper las líneas antes de que sean demasiado largas, insertando nuevas líneas. Si lo prefiere, puede hacer que Emacs inserte una nueva línea automáticamente cuando una línea se hace demasiado larga, usando el modo Auto Relleno (Auto Fill mode). Vea :ref:`26.6`. A veces, puede que necesite editar ficheros que contienen muchas líneas lógicas largas, y puede que no sea práctico romperlas todas añadiendo nuevas líneas. En ese caso, puedes usar el modo Línea Visual, que activa el *ajuste de palabras:* en lugar de ajustar las líneas largas exactamente en el borde derecho de la ventana, Emacs las ajusta en los límites de palabra (es decir, espacios o tabuladores) más cercanos al borde derecho de la ventana. El modo Línea Visual también redefine comandos de edición como ``C-a``, ``C-n``, y ``C-k`` para operar en líneas de pantalla en lugar de líneas lógicas. Véase :ref:`15.23`. .. _8.9: 8.9 Información sobre la posición del cursor -------------------------------------------- Aquí hay comandos para obtener información sobre el tamaño y la posición de partes del buffer, y para contar palabras y líneas. :kbd:`Alt`-:kbd:`x` ``what-line`` (``M-x what-line``) Muestra el número de línea del punto. | :kbd:`Alt`-:kbd:`x` ``line-number-mode`` (``M-x line-number-mode``) | :kbd:`Alt`-:kbd:`x` ``column-number-mode`` (``M-x column-number-mode``) Alterna la visualización automática del número de línea o columna actual. Véase :ref:`15.9`. Si desea que se muestre un número de línea antes de cada línea, consulte :ref:`15.24`. :kbd:`Alt`-`x` (``M-x``) Muestra el número de líneas, frases, palabras y caracteres presentes en la región (``count-words-region``). Consulte :ref:`12`, para obtener información sobre la región. :kbd:`Alt`-:kbd:`x` ``count-words`` (``M-x count-words``) Muestra el número de líneas, frases, palabras y caracteres presentes en la memoria intermedia. Si la región está activa (véase :ref:`12`), muestra en su lugar los números de la región. :kbd:`Ctrl`-:kbd:`x` :kbd:`=` (``C-x =``) Muestra el código de carácter del carácter después del punto, la posición del caracter y la columna del punto (``what-cursor-position``). :kbd:`Alt`-:kbd:`x` ``hl-line-mode`` (``M-x hl-line-mode``) Activa o desactiva el resaltado de la línea actual. Véase :ref:`15.21`. :kbd:`Alt` :kbd:`x` ``size-indication-mode`` (``M-x size-indication-mode``) Alterna la visualización automática del tamaño del buffer. Véase :ref:`15.19`. ``M-x what-line`` muestra el número de línea actual en el área de eco. Este comando suele ser redundante porque dicho número de línea se muestra en la línea de modo (véase :ref:`1.3`). Sin embargo, si se estrecha el búfer, la línea de modo muestra el número de línea relativo a la parte accesible (véase :ref:`15`). Por el contrario, ``what-line`` muestra tanto el número de línea relativo a la región reducida como el relativo al búfer. ``M-=`` (``count-words-region``) muestra un mensaje que informa del número de líneas, frases, palabras y caracteres de la región (véase La marca y la Región, para una explicación de la región). Con un argumento prefijo, :kbd:`Ctrl`-:kbd:`u` :kbd:`Alt`-:kbd:`=` (``C-u M-=``), el comando muestra un recuento para todo el búfer. El comando ``M-x count-words`` hace el mismo trabajo, pero con una convención de llamada diferente. Muestra un recuento para la región si la región está activa, y para el búfer en caso contrario. El comando ``C-x =`` (``what-cursor-position``) muestra información sobre la posición actual del cursor y el contenido del buffer en esa posición. Aparece una línea en el área de eco con el siguiente aspecto: .. code-block:: lisp Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53 Después de ``Char:``, muestra el carácter que está en el búfer justo en el punto. El texto dentro del paréntesis muestra los códigos de caracteres decimal, octal y hexadecimal correspondientes; para más información sobre cómo ``C-x =`` muestra la información de caracteres, véase :ref:`23.1`. Después de ``point=`` está la posición del punto como una cuenta de caracteres (el primer carácter en el buffer es la posición 1, el segundo carácter es la posición 2, y así sucesivamente). El número que sigue es el número total de caracteres del búfer, y el número entre paréntesis expresa la posición como porcentaje del total. Después de ``column=``' está la posición horizontal del punto, en columnas contando desde el borde izquierdo de la ventana. Si la opción de Usuario ``what-cursor-show-names`` no es nula, se muestra también el nombre del carácter, tal y como lo define la base de datos de caracteres Unicode. La parte entre paréntesis sería entonces: .. code-block:: lisp (99, #o143, #x63, LATIN SMALL LETTER C) Si el búfer se ha estrechado, haciendo que parte del texto del principio y del final sea temporalmente inaccesible, ``C-x =`` muestra texto adicional que describe el rango actualmente accesible. Por ejemplo, puede aparecer lo siguiente: .. code-block:: lisp Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0 donde los dos números extra dan la posición de carácter más pequeño y más grande que ese punto puede asumir. Los caracteres entre esas dos posiciones son los accesibles. Véase :ref:`15.5`. Una función relacionada, pero diferente, es el modo de visualización de números de línea (véase :ref:`15.24`). .. _8.10: 8.10 Argumentos Numéricos ------------------------- En la terminología de las matemáticas y la informática, *argumento* significa "datos proporcionados a una función u operación". Puede dar a cualquier comando de Emacs un *argumento numérico* (también llamado *argumento prefijo*). Algunos comandos interpretan el argumento como un recuento de repeticiones. Por ejemplo, dar a ``C-f`` un argumento de diez hace que avance el punto diez caracteres en lugar de uno. Con estos comandos, ningún argumento es equivalente a un argumento de uno, y los argumentos negativos hacen que se muevan o actúen en sentido contrario. La forma más sencilla de especificar un argumento numérico es escribir un dígito y/o un signo menos mientras se mantiene pulsada la tecla ``Meta`` (:kbd:`Alt`). Por ejemplo, :kbd:`Alt`-:kbd:`5` :kbd:`Ctrl`-:kbd:`n` (``M-5 C-n``) avanza cinco líneas. Las teclas :kbd:`Alt`-:kbd:`1` (``M-1``), :kbd:`Alt`-:kbd:`2` (``M-2``), etc., así como :kbd:`Alt`-:kbd:`-` (``M--``), están vinculadas a comandos (``digit-argument`` y ``negative-argument``) que establecen un argumento para el siguiente comando. ``M--`` sin dígitos normalmente significa -1. Si introduce más de un dígito, no necesita mantener pulsada la tecla :kbd:`Alt` (``Meta``) para el segundo dígito y los siguientes. Así, para avanzar cincuenta líneas, teclee :kbd:`Alt`-:kbd:`5`:kbd:`0` :kbd:`Ctrl`-:kbd:`n` (``M-5 0 C-n``) Tenga en cuenta que esto *no inserta* cinco copias de ``0`` y se desplaza una línea hacia abajo, como cabría esperar: ``0`` se trata como parte del argumento del prefijo. (¿Y si quiere insertar cinco copias de ``0``? Escriba :kbd:`Alt`-:kbd:`5` :kbd:`Ctrl`-:kbd:`u` :kbd:`0` (``M-5 C-u 0``). Aquí, ``C-u`` termina el argumento prefijo, de modo que la siguiente pulsación de tecla inicia el comando que desea ejecutar. Tenga en cuenta que este significado de ``C-u`` sólo se aplica a este caso. Para la función habitual de ``C-u``, véase más adelante). En lugar de escribir :kbd:`Alt`-:kbd:`1` (``M-1``), :kbd:`Alt`-:kbd:`2` (``M-2``), etc., otra forma de especificar un argumento numérico es escribir ``C-u`` (``universal-argument``) seguido de algunos dígitos, o (para un argumento negativo) un signo menos seguido de dígitos. Un signo menos sin dígitos normalmente significa -1. :kbd:`Ctrl`-:kbd:`u` (``C-u``) sola tiene el significado especial de "cuatro veces": multiplica por cuatro el argumento de la siguiente orden. :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`u` (``C-u C-u``) lo multiplica por dieciséis. Así, :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`f` (``C-u C-u C-f``) avanza dieciséis caracteres. Otras combinaciones útiles son :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`n` (``C-u C-n``), :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`n` (``C-u C-u C-n``) (baja una buena fracción de pantalla), :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl`-:kbd:`o` (``C-u C-u C-o``) (hace dieciséis líneas en blanco) y :kbd:`Ctrl`-:kbd:`u` :kbd:`Ctrl` :kbd:`k` (``C-u C-k``, mata cuatro líneas). Puede utilizar un argumento numérico antes de un carácter autoinsertado para insertar varias copias del mismo. Esto es sencillo cuando el carácter no es un dígito; por ejemplo, :kbd:`Ctrl`-:kbd:`u` :kbd:`6`:kbd:`4` (``C-u 6 4``) a inserta 64 copias del carácter ``a``. Pero esto no funciona para insertar dígitos; :kbd:`Ctrl`-:kbd:`u` :kbd:`6`:kbd:`4`:kbd:`1` (``C-u 6 4 1``) especifica un argumento de 641. Puede separar el argumento del dígito a insertar con otra combinación de teclas :kbd:`Ctrl`-:kbd:`u` (``C-u``); por ejemplo, :kbd:`Ctrl`-:kbd:`u` :kbd:`6`:kbd:`4` :kbd:`Ctrl`-:kbd:`u` :kbd:`1` (``C-u 6 4 C-u 1``) inserta 64 copias del carácter ``1``. Algunos comandos se preocupan de si hay un argumento, pero ignoran su valor. Por ejemplo, el comando :kbd:`Alt`-:kbd:`q` (``M-q``. ``fill-paragraph``, rellenar-párrafo) rellena texto; con un argumento, también justifica el texto. (Véase :ref:`26.6`, para más información sobre ``M-q``.) Para estos comandos, basta con especificar el argumento con una sola ``C-u``. Algunos comandos usan el valor del argumento como contador de repeticiones, pero hacen algo especial cuando no hay argumento. Por ejemplo, el comando (``C-k``, ``kill-line``) con argumento *n* mata *n* líneas, incluyendo sus nuevas líneas finales. Pero :kbd:`Ctrl`-:kbd:`k` (``C-k``) sin argumento es especial: mata el texto hasta la siguiente nueva línea o, si el punto está justo al final de la línea, mata la propia nueva línea. Así, dos comandos ``C-k`` sin argumentos pueden eliminar una línea que no esté en blanco, igual que ``C-k`` con un argumento de uno. (Ver :ref:`13`, para más información sobre ``C-k``.) Algunos comandos tratan a ``C-u`` de forma diferente a un argumento ordinario. Otros pocos pueden tratar un argumento de sólo un signo menos de forma diferente a un argumento de -1. Estos casos inusuales se describen cuando aparecen; existen para hacer que un comando individual sea más conveniente, y están documentados en la cadena de documentación de ese comando. Usamos el término *argumento prefijo* para enfatizar que estos argumentos se escriben *antes* del comando, y para distinguirlos de los argumentos del minibuffer (vea :ref:`9`), que se introducen *después* de invocar el comando. En las pantallas gráficas, :kbd:`Ctrl`-:kbd:`0` (``C-0``), :kbd:`Ctrl`-:kbd:`1` (``C-1``), etc. actúan igual que :kbd:`Alt`-:kbd:`0` (``M-0``), :kbd:`Alt`-:kbd:`1` (``M-1``), etc. .. _8.11: 8.11 Repetición de una orden ---------------------------- Muchos comandos sencillos, como los que se invocan con una sola tecla o con :kbd:`Alt`-:kbd:`x` *nombre-comando* :kbd:`RETURN` (``M-x`` *nombre-comando* ``RET``), pueden repetirse invocándolos con un argumento numérico que sirve como contador de repeticiones (véase :ref:`8.10`). Sin embargo, si el comando que desea repetir solicita entrada, o utiliza un argumento numérico de otra forma, ese método no funcionará. El comando :kbd:`Ctrl`-:kbd:`x` :kbd:`z` (``C-x z``, ``repeat``, repetir) proporciona otra forma de repetir un comando Emacs muchas veces. Este comando repite el último comando del Editor, sea cual sea. Repetir un comando usa los mismos argumentos que se usaron antes; no lee nuevos argumentos cada vez. Para repetir el comando más de una vez, escriba ``z``'s adicionales: cada ``z`` repite el comando una vez más. La repetición finaliza cuando se teclea un carácter distinto de ``z`` o se pulsa un botón del ratón. También puede activar el modo de repetición, que permite repetir comandos vinculados a secuencias de dos o más teclas tecleando un solo carácter. Por ejemplo, después de teclear :kbd:`Ctrl`-:kbd:`x` :kbd:`u` (``C-x u``, ``undo``, deshacer, véase :ref:`17.1`) para deshacer las ediciones más recientes, puede deshacer muchas más ediciones tecleando :kbd:`u`:kbd:`u`:kbd:`u` (``u u u``).... Del mismo modo, escriba :kbd:`Ctrl`-:kbd:`x` :kbd:`x`:kbd:`o`:kbd:`o` (``C-x o o o``)... en lugar de :kbd:`Ctrl`-:kbd:`x` :kbd:`o` :kbd:`Ctrl`-:kbd:`x` :kbd:`o` :kbd:`Ctrl`-:kbd:`x` :kbd:`o` (``C-x`` ``o`` ``C-x`` ``o`` ``C-x`` ``o``)... para cambiar a la ventana situada a varias ventanas de distancia. Esto funciona entrando en un modo de repetición transitorio después de teclear la secuencia de teclas completa que invoca el comando; los atajos de una sola tecla se muestran en el área de eco. Sólo algunos comandos admiten la repetición en este modo (``repeat-mode``); escriba :kbd:`Alt`-:kbd:`x` ``describe-repeat-maps`` :kbd:`RETURN` (``M-x`` ``describe-repeat-maps`` ``RET``) para ver cuáles. Los atajos de un solo carácter habilitados por el modo de repetición transitoria no tienen por qué ser idénticos: por ejemplo, después de teclear :kbd:`Ctrl`-:kbd:`x` :kbd:`{` (``C-x`` ``{``), tanto ``{`` como ``}`` o ``^`` o ``v``, o cualquier serie que mezcle estos caracteres en cualquier orden, redimensionará la ventana seleccionada de las formas respectivas. Del mismo modo, después de :kbd:`Alt`-:kbd:`g` :kbd:`n` (``M-g n``) o :kbd:`Alt`-:kbd:`g` :kbd:`p` (``M-g`` ``p``), teclear cualquier secuencia de ``n`` y/o ``p`` en cualquier mezcla repetirá ``next-error`` y ``previous-error`` para navegar en un buffer *compilación* o *grep* (ver :ref:`28.2`). Al tipear cualquier tecla distinta de las definidas para repetir el comando anterior, se sale del modo de repetición transitoria y, a continuación, la tecla que pulsó se ejecuta normalmente. También puede definir una tecla que salga del modo de repetición transitoria *sin* ejecutar la tecla que provocó la salida. Para ello, personalice la opción de usuario ``repeat-exit-key`` para nombrar una tecla; un valor natural es ``RET``. Finalmente, es posible romper la cadena de repetición automáticamente después de cierto tiempo de inactividad: personalice la opción de usuario ``repeat-exit-timeout`` para especificar el tiempo de inactividad en segundos después del cual este modo de repetición transitoria se desactivará automáticamente.