viernes, 29 de enero de 2016

Moviendo el cursor

Los códigos de escape pueden ser usados para posicionar el cursor. Se usa comúnmente para proporcionar un reloj o algún otro tipo de información en una localización diferente de la pantalla, como en la esquina superior cada vez que se dibuja el prompt. Aquí tenemos una lista de los códigos de escape que posicionan el cursor:

Tabla 13-4: Secuencias de escape de movimiento del cursor
Código de escape Acción
\033[l,cH Mueve el cursor a la línea l y columna c
\033[nA Mueve el cursor arriba n lineas
\033[nB Mueve el cursor abajo n lineas
\033[nC Mueve el cursor hacia delante n caracteres
\033[nD Mueve el cursor hacia atrás n caracteres
\033[2J Limpia la pantalla y mueve el cursor a la esquina superior izquierda (línea 0, columna 0)
\033[K Limpia desde la posición del cursor hasta el final de la línea actual
\033[s Almacena la posición actual del cursor
\033[u Recupera la posición del cursor almacenada

Usando los códigos anteriores, construiremos un prompt que dibuje una línea roja arriba de la pantalla conteniendo un reloj (dibujado en texto amarillo) cada vez que se muestre el prompt. El código para el prompt es esta cadena de aspecto formidable:

PS1="\[\033[s\033[0;0H\033[0;41m\033[K\033[1;33m\t\033[0m\033[u\]<\u@\h \W>\$ "

Echemos un vistazo a cada parte de la cadena para ver que hace:

Tabla 13-5: Desglose de cadenas de prompt complejas
Secuencia Acción
\[ Comienza una secuencia de caracteres no imprimibles. El propósito de esto es permitir que bash calcule apropiadamente el tamaño del prompt visible. Sin un calculo preciso, las funciones de edición de la línea de comandos no pueden posicionar el cursor apropiadamente.
\033[s Almacena la posición del cursor. Se necesita para volver a la ubicación del prompt después de que la barra y reloj hayan sido dibujados en la parte superior de la pantalla. Ten en cuenta que ciertos emuladores de terminal no soportan este código.
\033[0;0H Mueve el cursor a la esquina superior izquierda, que es la línea 0, columna 0.
\033[0;41m Establece el color de fondo a rojo.
\033[K Borra desde la posición actual del cursor (la esquina superior izquierda) al final de la línea. Como el color de fondo es ahora rojo, la línea se borra con ese color creando nuestra barra. Ten en cuenta que borrar hasta el final de la línea no cambia la posición del cursor, que permanece en la esquina superior izquierda.
\033[1;33m Establece el color de texto en amarillo
\t Muestra la hora actual. Como es un elemento “imprimible”, lo incluimos todavía dentro de la porción no imprimible del prompt, ya que no queremos que bash incluya el reloj cuando calcule el tamaño real del prompt mostrado.
\033[0m Apaga el color. Afecta tanto al texto como al fondo.
\033[u Recupera la posición del cursor salvado anteriormente.
\] Fin de la secuencia de caracteres no imprimibles.
<\u@\h \W>\$ Cadena de prompt.

jueves, 28 de enero de 2016

Confusión con el Terminal

Volviendo a los viejos tiempos, cuando los terminales estaban conectados a ordenadores remotos, habías muchas marcas de terminales compitiendo y todas funcionaban de forma diferente. Tenían teclados diferentes y todas tenían diferentes formas de interpretar la información de control. Los sistemas Unix y tipo Unix tienen dos subsistemas complejos para tratar la torre de babel del control del terminal (llamados termcap y terminfo). Si miras en lo más profundo de la configuración de tu emulador de terminal encontrarás un parámetro para el tipo de emulador de terminal.

En un esfuerzo para hacer que los terminales hablen un tipo de lenguaje común, El American National Standards Institute (ANSI) desarrolló un catálogo de secuencias de caracteres para controlar los terminales de video. Los usuarios antiguos de DOS recordarán el archivo ANSI.SYS que se utilizaba para permitir la interpretación de dichos códigos.

miércoles, 27 de enero de 2016

Añadiendo color

La mayoría de los programas emuladores de terminal responden a ciertas secuencias de caracteres no imprimibles para controlar cosas como atributos de caracteres (color, negritas y pavorosos textos parpadeantes) y posiciones del cursor. Veremos la posición del cursor en un rato, pero primero veamos el color.

El color de los caracteres se controla enviando al emulador de terminal un código de escape ANSI incluido en la cadena de caracteres a mostrar. El código de control no se “imprime” en la pantalla, en su lugar es interpretado por la terminal como una instrucción. Como vimos en la tabla anterior, las secuencias \[ y \] se usan para encapsular caracteres no imprimibles. Un código de escape ANSI comienza con un octal 033 (el código generado por la tecla escape), seguido, opcionalmente, de un atributo de carácter, seguido por una instrucción. Por ejemplo, el código para establecer el color del texto a texto negro normal (atributo = 0), es:

\033[0;30m

Aquí tenemos una tabla con los colores disponibles. Fíjate que los colores se dividen en dos grupos, diferenciados por la aplicación del atributo de carácter negrita (1) que crea la apariencia de colores “luminosos”:

Tabla 17-2: Secuencias de escape usadas para establecer colores de texto
Secuencia Color del texto Secuencia Color del Texto
\033[0;30m Negro \033[1;30m Gris oscuro
\033[0;31m Rojo \033[1;31m Rojo claro
\033[0;32m Verde \033[1;32m Verde claro
\033[0;33m Marrón \033[1;33m Amarillo
\033[0;34m Azul \033[1;34m Azul claro
\033[0;35m Morado \033[1;35m Morado claro
\033[0;36m Cían \033[0;36m Cían claro
\033[0;37m Gris claro \033[0;37m Blanco

Probemos un prompt rojo. Insertaremos el código de escape al principio:

<me@linuxbox ~>$ PS1="\[\033[0;31m\]<\u@\h \W>\$ "
<me@linuxbox ~>$

Funciona, pero fíjate que todo el texto que escribamos tras el prompt también es rojo. Para arreglarlo, añadiremos otro código de escape al final del prompt que le diga al emulador de terminal que vuelva al color previo:

<me@linuxbox ~>$ PS1="\[\033[0;31m\]<\u@\h \W>\$\[\033[0m\]"
me@linuxbox ~>$

¡Así está mejor!

También es posible establecer el color de fondo usando los códigos listados a continuación. Los colores de fondo no soportan el atributo negrita.

Tabla 13-3: Secuencias de escape usadas para establecer el color de fondo
Secuencia Color de fondo Secuencia Color de fondo
\033[0;40m Negro \033[0;44m Azul
\033[0;41m Rojo \033[0;45m Morado
\033[0;42m Verde \033[0;46m Cían
\033[0;43m Marrón \033[0;47m Gris claro

Podemos crear un prompt con un fondo rojo aplicando un simple cambio al primer código de escape:

<me@linuxbox ~>$ PS1="\[\033[0;41m\]<\u@\h \W>\$\[\033[0m\]"<me@linuxbox ~>$

Prueba los códigos de color y ¡Mira lo que puedes crear!

Nota: Además de los atributos de carácter normal (0) y negrita (1), el texto también tiene atributos para subrayado (4), parpadeante (5) e invertido (7). En beneficio del buen gusto, muchos emuladores de terminal rechazan el honor de tener el atributo parpadeante.

martes, 26 de enero de 2016

Probando algunos diseños de prompt alternativos

Con esta lista de caracteres especiales, podemos cambiar el prompt para ver el efecto. Primero, haremos una copia de seguridad de la cadena existente para poder recuperarla más tarde. Para hacer esto, copiaremos la cadena existente en otra variable de shell que agregaremos nosotros mismos:

[me@linuxbox ~]$ ps1_old="$PS1"

Creamos una nueva variable llamada ps1_old y le asignamos el valor PS1. Podemos verificar que la cadena ha sido copiada usando el comando echo:

[me@linuxbox ~]$ echo $ps1_old
[\u@\h \W]\$

Podemos recuperar el prompt original en cualquier momento de nuestra sesión de terminal simplemente revirtiendo el proceso:

[me@linuxbox ~]$ PS1="$ps1_old"

Ahora que estamos listos para seguir, veamos que ocurre si tenemos una cadena de prompt vacía:

[me@linuxbox ~]$ PS1=

Si no asignamos nada a la cadena de prompt, no tendremos nada. ¡Ninguna cadena de prompt! El prompt está ahí, pero no muestra nada, tal como le pedimos. Como así es un poco desconcertante, la reemplazaremos por un prompt minimalista:

PS1="\$ "

Así está mejor. Al menos ahora podemos ver que estamos haciendo. Fíjate el espacio en blanco dentro de las comillas. Esto nos proporciona un espacio entre el signo del dólar y el cursor cuando se muestre el prompt.

Añadamos un tono a nuestro prompt:

$ PS1="\[\a\]\$ "

Ahora deberíamos escuchar un beep cada vez que se muestre el prompt. Esto podría volverse molesto, pero podría ser util si necesitamos que nos notifique cuándo un comando, con un trabajo especialmente largo, ha sido ejecutado. Fijate que hemos incluido las secuencias \[ y \]. Como el tono ASCII (\a) no se “imprime”, o sea, no mueve el cursor, necesitamos decírselo a bash para que pueda determinar correctamente la longitud del prompt.

A continuación, probemos a hacer un prompt informativo con información sobre el nombre del host y la hora:

$ PS1="\A \h \$ "
17:33 linuxbox $

Añadir la hora a nuestro prompt será útil si necesitamos seguir la pista a la hora en que se han realizado ciertas tareas. Finalmente, haremos un nuevo prompt similar al original:

17:37 linuxbox $ PS1="<\u@\h \W>\$ "
<me@linuxbox ~>$

Prueba otras secuencias de la lista anterior a ver si puedes conseguir un nuevo y brillante prompt.

lunes, 25 de enero de 2016

Anatomía de un prompt

Nuestro prompt por defecto es algo así:

[me@linuxbox ~]$

Fíjate que contiene nuestro nombre de usuario, el nombre de nuestro host y nuestro directorio de trabajo actual, pero ¿cómo ha tomado esta forma? Es muy simple. El prompt es definido por la variable de entorno llamada PS1 (abreviatura de “prompt string one” - “cadena de prompt uno”) Podemos ver el contenido de PS1 con el comando echo:

[me@linuxbox ~]$ echo $PS1
[\u@\h \W]\$

Nota: No te preocupes si tus resultados no son exactamente los mismos que en el ejemplo. Cada distribución Linux define, de forma algo diferente, la cadena del prompt, algunas de una manera un tanto exótica.

De los resultados, podemos ver que PS1 contiene algunos caracteres que vemos en nuestro prompt como los corchetes, el signo arroba, el signo del dólar, pero el resto son un misterio. Nuestra astucia los reconocerá como caracteres especiales ocultos tras la barra invertida como los que vimos en el capítulo 7. Aquí hay una lista parcial de los caracteres que el shell trata especialmente en la cadena del prompt:

Tabla 13-1: Códigos de escape usado en los prompts de shell
Secuencia Valor mostrado
\a Tono ASCII. Hace que el ordenador haga un beep cuando lo encuentre.
\d Fecha actual con el siguiente formato: día de la semana, mes y día. Por ejemplo, “Lunes Mayo 26.”
\h Nombre de host de la máquina local sin el nombre de dominio al final.
\H Nombre de host completo.
\j Número de trabajos corriendo en la sesión de shell actual.
\l Nombre del dispositivo terminal actual.
\n Carácter de nueva línea.
\r Retorno de carro.
\s Nombre del programa shell.
\t Hora actual en formato 24 horas. Horas:minutos:segundos.
\T Hora actual en formato 12 horas.
\@ Hora actual en formato 12 horas AM/PM.
\A Hora actual en formato 24 horas. Horas:minutos.
\u Nombre de usuario del usuario actual.
\v Número de versión del shell.
\V Números de versión y de lanzamiento del shell.
\w Nombre del directorio de trabajo actual.
\W Última parte del nombre del directorio de trabajo actual.
\! Número del comando actual en el historial.
\# Número de comandos introducidos durante esta sesión de shell.
\$ Muestra un carácter “$” a menos que tengas privilegios de superusuario. En ese caso, muestra un “#” en su lugar.
\[ Señal de comienzo de una serie de uno o más caracteres no imprimibles. Se usa para añadir caracteres de control no imprimibles que manipulará el emulador de terminal de alguna forma, como mover el cursor o cambiar colores de texto.
\] Señales de fin de una secuencia de caracteres no imprimibles.

viernes, 22 de enero de 2016

Personalizando el Prompt

En este capítulo veremos un detalle que aparentemente es trivial, nuestro prompt de shell. Al examinarlo revelaremos algunos de los mecanismos internos del shell y del emulador de terminal.

Como muchas cosas en Linux, el prompt de shell es muy configurable, y aunque lo hemos dado por hecho, el prompt es un dispositivo muy útil una vez que hemos aprendido a controlarlo.

jueves, 21 de enero de 2016

Para saber más

Incluso con todo lo que hemos cubierto en este capítulo, apenas hemos arañado la superficie de lo que vi y vim pueden hacer. Aquí tienes un par de recursos en línea que puedes usar para continuar tu viaje para hacerte un maestro de vi:

miércoles, 20 de enero de 2016

Resumiendo

Con esta serie básica de habilidades ya podemos realizar la mayoría de las ediciones de texto necesarias para mantener un sistema Linux típico. Aprender a usar vim en el día a día será beneficioso a largo plazo. Como los editores, del estilo de vi, están tan profundamente incluidos en la cultura Unix, veremos muchos otros programas que han estado influenciados por su diseño. less es un buen ejemplo de esta influencia.

martes, 19 de enero de 2016

Salvando nuestro trabajo

Como todo lo demás en vi, hay varias formas distintas de salvar nuestros archivos editados. Ya hemos visto el comando ex :w, pero hay otros que podríamos encontrar útiles.

En el modo comando, escribir ZZ salvará el archivo actual y saldrá de vi. Igualmente, el comando ex :wq combinará los comandos :w y :q en uno que salvará el archivo y saldrá.

El comando :w también puede especificar un nombre de archivo opcional. Esto actúa como “Guardar como...” Por ejemplo, si estuviéramos editando foo.txt y quisiéramos salvar una versión alternativa llamada foo1.txt, escribiríamos lo siguiente:

:w foo1.txt

Nota: Mientras que el comando anterior salva el archivo bajo un nuevo nombre, no cambia el nombre del archivo que estás editando. Si continuas editando, estarás todavía editando foo.txt, no foo1.txt.

lunes, 18 de enero de 2016

Insertando un archivo entero dentro de otro

También es posible insertar un archivo entero dentro de otro que estemos editando. Para verlo en acción, terminemos nuestra sesión vi y comencemos una nueva con un único archivo:

[me@linuxbox ~]$ vi ls-output.txt

Veremos nuestra lista de archivos de nuevo:

total 343700
-rwxr-xr-x 1 root root  31316 2007-12-05 08:58 [
-rwxr-xr-x 1 root root   8240 2007-12-09 13:39 411toppm
-rwxr-xr-x 1 root root 111276 2008-01-31 13:36 a2p
-rwxr-xr-x 1 root root  25368 2006-10-06 20:16 a52dec
-rwxr-xr-x 1 root root  11532 2007-05-04 17:43 aafire
-rwxr-xr-x 1 root root   7292 2007-05-04 17:43 aainfo

Movemos el cursor a la tercera línea, luego introduce el siguiente comando ex:

:r foo.txt

El comando :r (abreviatura de “leer”) inserta el archivo especificado antes de la posición del cursor. Nuestra pantalla debería aparecer ahora así:

total 343700
-rwxr-xr-x 1 root root 31316 2007-12-05 08:58 [
-rwxr-xr-x 1 root root  8240 2007-12-09 13:39 411toppm
The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5
-rwxr-xr-x 1 root root 111276 2008-01-31 13:36 a2p
-rwxr-xr-x 1 root root  25368 2006-10-06 20:16 a52dec
-rwxr-xr-x 1 root root  11532 2007-05-04 17:43 aafire
-rwxr-xr-x 1 root root   7292 2007-05-04 17:43 aainfo

viernes, 15 de enero de 2016

Copiando contenido de un archivo a otro

A menudo, mientras editamos múltiples archivos, querremos copiar una porción de un archivo en otro archivo que estamos editando. Esto se hace fácilmente usando los comandos usuales de copiar y pegar que hemos usado antes. Podemos demostrarlo como sigue. Primero, usando nuestros dos archivos, cambia al buffer 1 (foo.txt) escribiendo:

:buffer 1

que debería darnos esto:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5

A continuación, mueve el cursor a la primera línea y escribe yy para copiar (yank) la línea.

Cambia al segundo buffer escribiendo:

:buffer 2

La pantalla contendrá ahora listas de archivos como esta (sólo se muestra una porción aquí):

total 343700
-rwxr-xr-x 1 root root  31316 2007-12-05 08:58 [
-rwxr-xr-x 1 root root   8240 2007-12-09 13:39 411toppm
-rwxr-xr-x 1 root root 111276 2008-01-31 13:36 a2p
-rwxr-xr-x 1 root root  25368 2006-10-06 20:16 a52dec
-rwxr-xr-x 1 root root  11532 2007-05-04 17:43 aafire
-rwxr-xr-x 1 root root   7292 2007-05-04 17:43 aainfo

Mueve el cursor a la primera línea y pega la linea copiada del archivo precedente escribiendo el comando p:

total 343700
The quick brown fox jumped over the lazy dog. It was cool.
-rwxr-xr-x 1 root root  31316 2007-12-05 08:58 [
-rwxr-xr-x 1 root root   8240 2007-12-09 13:39 411toppm
-rwxr-xr-x 1 root root 111276 2008-01-31 13:36 a2p
-rwxr-xr-x 1 root root  25368 2006-10-06 20:16 a52dec
-rwxr-xr-x 1 root root  11532 2007-05-04 17:43 aafire
-rwxr-xr-x 1 root root   7292 2007-05-04 17:43 aainfo

jueves, 14 de enero de 2016

Abriendo archivos adicionales para editar

También es posible añadir archivos a nuestra actual sesión de edición. El comando ex :e (abreviatura de “edit”) seguido por el nombre del archivo abrirá el archivo adicional. Terminemos nuestra sesión de edición actual y volvamos a la línea de comandos.

Arranca vi de nuevo con un sólo archivo:

[me@linuxbox ~]$ vi foo.txt

Para añadir un segundo archivo, escribe:

:e ls-output.txt

Y debería aparecer en la pantalla. El primer archivo está todavía presente como podemos comprobar:

:buffers
  1 #    "foo.txt"                      line 1
  2 %a   "ls-output.txt"                line 0
Press ENTER or type command to continue

Nota: No puedes cambiar a archivos cargados con el comando :e usando el comando :n o el comando :N. Para cambiar entre archivos, usa el comando :buffer seguido del número de buffer.

miércoles, 13 de enero de 2016

Cambiando entre archivos

Para cambiar de un archivo al siguiente, usaremos este comando ex:

:n

Para volver al archivo previo usa:

:N

Como podemos movernos de un archivo a otro, vi impone una política que nos previene de cambiar de archivo si el archivo actual tiene cambios sin guardar. Para forzar a vi a cambiar de archivo y abandonar tus cambios, añade un signo de exclamación (!) al comando.

Además del método de cambio descrito antes, vim (y algunas versiones de vi) también cuenta con algunos comandos ex para hacer más fácil el manejo de múltiples archivos. Podemos ver una lista de los archivos que están siendo editados con el comando :buffers. Hacer esto mostrará una lista de los archivos en la parte inferior de la pantalla:

:buffers
  1 %a   "foo.txt"                   line 1
  2      "ls-output.txt"             line 0
Press ENTER or type command to continue

Para cambiar a otro buffer (archivo), escribe :buffer seguido del número del buffer que quieres editar. Por ejemplo, para cambiar del buffer 1 que contiene el archivo foo.txt al buffer 2 que contiene el archivo ls-output.txt deberías escribir esto:

:buffer 2

y nuestra pantalla ahora muestra el segundo archivo.

martes, 12 de enero de 2016

Editando múltiples archivos

A veces es útil editar más de un archivo a la vez. Podrías necesitar hacer cambios en múltiples archivos o necesitar copiar contenido de un archivo a otro. Con vi podemos abrir múltiples archivos, para editar, especificándolos en la línea de comandos:

vi file1 file2 file3...

Salgamos de nuestra sesión de vi existente y creemos un nuevo archivo para editar. Escribe :wq para salir de vi, salvando nuestro texto modificado. A continuación, crearemos un archivo adicional en nuestro directorio home para que podamos jugar con él. Crearemos el archivo capturando salida del comando ls:

[me@linuxbox ~]$ ls -l /usr/bin > ls-output.txt

Editemos nuestro antiguo archivo y el nuevo con vi:

[me@linuxbox ~]$ vi foo.txt ls-output.txt

vi arrancará y veremos el primer archivo en la pantalla:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5

lunes, 11 de enero de 2016

Búsqueda y reemplazo global

vi usa un comando ex para realizar operaciones de búsqueda y reemplazo (llamadas “sustituciones” en vi) sobre un rango del líneas o sobre todo el archivo. Para cambiar la palabra “Line” a “line” en todo el archivo, utilizaríamos el siguiente comando:

:%s/Line/line/g

Dividamos este comando en elementos separados y veamos que hace cada uno:

Tabla 12-5: Un ejemplo de la sintaxis de la búsqueda y reemplazo global
Elemento Significado
: El carácter dos puntos comienza un comando ex.
% Especifica el rango de líneas para la operación. % es una abreviatura que significa desde la primera a la última línea. Alternativamente, el rango podría ser especificado como 1, 5 (ya que nuestro archivo tiene cinco líneas), o 1, $ que significa “de la línea 1 a la última línea del archivo.” Si el rango de líneas se omite, la operación sólo se realiza en la línea actual.
s Especifica la operación. En este caso, sustitución (buscar y reemplazar).
/Line/line/ El patrón de búsqueda y el texto de reemplazo.
g Significa “global” en sentido de que la búsqueda y reemplazo se realiza en todas las instancias de la cadena de búsqueda existentes en la línea. Si la omitimos, sólo la primera instancia de la cadena de búsqueda de cada línea se reemplazará.

Después de ejecutar nuestro comando de búsqueda y reemplazo nuestro archivo aparece así:

The quick brown fox jumped over the lazy dog. It was cool.
line 2
line 3
line 4
line 5

Podemos especificar también un comando de sustitución con confirmación del usuario. Esto se hace añadiendo una “c” al final del comando. Por ejemplo:

:%s/line/Line/gc

El comando cambiará nuestro archivo de nuevo a su forma previa; sin embargo, antes de cada sustitución, vi para y nos pregunta que confirmemos la sustitución con este mensaje:

replace with Line (y/n/a/q/l/^E/^Y)?

Cada uno de los caracteres dentro del paréntesis es una posible elección de la siguiente forma:

Tabla 12-6: Claves de confirmación de reemplazo
Clave Acción
y Realiza la sustitución.
n Se salta esta instancia del patrón.
a Realiza la sustitución en esta y todas las siguientes instancias del patrón.
q o Esc Salir de sustituir
l Realiza esta sustitución y luego salir. Abreviatura de “último”.
Ctrl-e, Ctrl-y Desplazamiento arriba y abajo, respectivamente. Útil para ver el contexto de la sustitución prevista.

Si escribes y, la sustitución se realizará, n hará que vi se salte esta instancia y se mueva a la siguiente.

viernes, 8 de enero de 2016

Buscando en el archivo completo

Para mover el cursor a la siguiente aparición de una palabra o frase se usa el comando /. Esto funciona de la misma forma, que aprendimos anteriormente, con el programa less. Cuando escribes el comando / una “/” aparecerá en la parte de abajo de la pantalla. A continuación, escribe la palabra o frase a buscar, seguida de la tecla Enter. El cursor se moverá a la siguiente posición que contenga la cadena buscada. Una búsqueda puede ser repetida, usando la cadena de la búsqueda anterior, con el comando n. Aquí tenemos un ejemplo:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3
Line 4
Line 5

Coloca el cursor en la primera línea del archivo. Escribe:

/Line

Seguido de la tecla Enter. El cursor se moverá a la línea 2. A continuación, escribe n y el cursor se moverá a la línea 3. Repitiendo el comando n moverá el cursor hacia abajo por el archivo hasta que se quede sin resultados. Aunque hasta ahora sólo hemos usado palabras y frases para nuestras búsquedas, vi permite el uso de expresiones regulares, un potente método de expresar patrones complejos de texto. Veremos las expresiones regulares en más detalle en un capítulo posterior.

jueves, 7 de enero de 2016

Buscando dentro de una línea

El comando f busca en una línea y mueve el cursor a la siguiente instancia de un carácter especificado. Por ejemplo, el comando fa movería el cursor hasta la siguiente aparición del carácter “a” dentro de la línea actual. Después de realizar una búsqueda de un carácter en una línea, esta puede repetirse escribiendo un punto y coma.

martes, 5 de enero de 2016

Buscar y reemplazar

vi tiene la capacidad de mover el cursor a localizaciones basadas en búsquedas. Puede hacer esto tanto en una línea individual como en un archivo completo. También puede realizar reemplazos de texto con o sin confirmación del usuario.

lunes, 4 de enero de 2016

Uniendo líneas

vi es bastante estricto acerca de su idea de línea. Normalmente, no es posible mover el cursor al final de una línea y borrar el carácter de fin de línea para unirla con la linea que está debajo. Por esto, vi provee un comando específico, J (no confundir con j, que es para mover el cursor) para unir líneas.

Si colocamos el cursor en la línea 3 y escribimos el comando J, aquí tenemos lo que ocurre:

The quick brown fox jumped over the lazy dog. It was cool.
Line 2
Line 3 Line 4
Line 5