You are on page 1of 3

http://es.kioskea.net/contents/linux/linvi.

php3
Linux - El editor de Vi

Introducción a Vi
A pesar de su ergonomía muy limitada, Vi es uno de los editores de texto más populares de los sistemas
Unix (con Emacs y pico). En Linux, hay una versión gratuita de Vi denominada Vim (Vi Improved
[mejorada]). Vi (que se pronuncia vi-ái) es un editor completamente en modo texto, lo cual significa que
todas las acciones se llevan a cabo con la ayuda de comandos de texto. Si bien en principio este editor
parece tener poco uso práctico, es muy eficaz y puede ser muy útil en caso de que falle la interfaz
gráfica.
La sintaxis para abrir Vi es la siguiente:
vi nombre_del_archivo
Una vez que se abrió el archivo, podrá desplazarse en él con los cursores o las teclas h, j, k y l (si el
teclado no posee ningún cursor de flecha).

Modos Vi
Vi posee tres modos operativos:
Modo regular: Éste es el modo que introduce cada vez que abre un archivo. Este modo permite la
introducción de comandos.
Modo de inserción: Este modo permite la inserción de caracteres que se capturan dentro del
documento. Para pasar al modo de inserción, simplemente pulse la tecla Insert en su teclado o la tecla i
predeterminada.
Modo de reemplazo: Este modo le permite reemplazar el texto existente por el texto que captura. Solo
pulse r nuevamente para ir al modo de reemplazo y pulse la tecla Esc para regresar al modo regular.
-------------------------------------------------------------------------------------------------------------------------------------------
Comandos básicos
Comando Descripción
:q Salir del editor (sin guardar la información)
:q! Obliga al editor a cerrarse sin guardar la información (incluso si se realizaron cambios en
el documento)
:wq Guarda el documento y cierra el editor
:filenombre Guarda el documento con el nombre especificado
--------------------------------------------------------------------------------------------------------------------------------------------
Comandos de edición
Comando Descripción
x Elimina el carácter que está en ese momento bajo el cursor
dd Elimina la línea que está en ese momento bajo el cursor
dxd Elimina x líneas empezando por la que en ese momento está bajo el cursor
nx Elimina n caracteres empezando por el que en ese momento está bajo el cursor
x>> Indenta x líneas a la derecha empezando por la que en ese momento está bajo el cursor
x<< Indenta x líneas a la izquierda empezando por la que en ese momento está bajo el cursor

Buscar y reemplazar
Para buscar una palabra en un documento, en modo regular, sólo introduzca / seguido de la cadena de
caracteres que se buscarán. Después pulse la tecla Enter para confirmar. Utilice la tecla n para ir de
aparición en aparición.
Para reemplazar una cadena de caracteres por otra en una línea, encontrará un comando muy eficaz
en Vi al utilizar las expresiones regulares.
Su sintaxis es la siguiente:
:s/chaine_a_remplacer/chaine_de_remplacement/
:s/cadena_a_ser_reemplazada/cadena_de_reemplazo/
Se puede realizar el reemplazo a lo largo de todo el documento con la siguiente sintaxis:
%s/chaine_a_remplacer/chaine_de_remplacement/
:%s/cadena_a_ser_reemplazada/cadena_de_reemplazo/

Copiar y pegar y cortar y pegar
En Vi es posible copiar y pegar una selección de líneas. Para hacerlo, sólo debe introducir el siguiente
comando para copiar n líneas: nyy
Para hacer esto, sólo debe introducir el siguiente comando para copiar n líneas: nyy
Por ejemplo, el siguiente comando copiará 16 líneas en el portapapeles: 16yy
Para pegar la selección, sólo debe introducir la letra p.
El proceso de cortar y pegar n líneas es similar mediante el comando: ndd
Después, introduzca la tecla p para pegar.

Escribir nuestro programa. El editor vi.
Podemos escribir nuestro programa con cualquier editor que conozcamos. El editor estandard para los
sistemas unix es el vi. Ahora linux suele venir con versiones mejoradas del vi, como son el vim o el gvim.
También suele venir con otros editores, como el xemacs. Puesto que el vi es el estandard que viene con
todas las distribuciones de unix, es el que vamos a usar.
La extensión de un programa en c es ".c". Editamos un fichero nuevo HolaMundo.c para escribir en él.
El comando es :$ vi HolaMundo.c
Las mayúsculas y minúsculas son importantes, Podemos poner lo que queramos, pero siempre igual a
partir de ahora. El editor vi se escribe con minúsculas.
El editar con el vi la shell cambia de aspecto y se llena de "gurruñitos" en la primera columna (muchos de
estos ~). Ese es nuestro fichero, que de momento está vacío.
El editor vi tiene dos modos de trabajo: en modo de comandos y en modo de inserción.
En el modo de comandos, cualquier tecla que apretemos se interpreta como un comando, no se
escribe. Es decir, si pulso la x, en vez de escribirse una x, lo que se hace es borrar un carácter (es el
comando asignado a la x).
En el modo de inserción, los caracteres sí se escriben. Si pulso la misma x de antes, ahora se escribe
una x.
Por defecto el vi entra en el modo de comandos. Para pasar al modo de inserción y poder escribir,
pulsamos la i (de insertar). Esto nos pone en el modo de inserción y podemos empezar a escribir
nuestro programa en c. Puede ser como el siguiente
#include <stdio.h>
int main ( )
{
printf ("Hola mundo.\n");
return 0;
}
Si nos equivocamos al escribir, pulsamos la tecla de borrado. Si el error es más gordo, debemos pasar
al modo de comandos para corregirlo. Pasamos al modo de comandos pulsando la tecla <escape>. Nos
movemos a los caracteres erróneos con las flechas (si no funcionan, debemos usar + para bajar de
línea, - para subir una línea, <espacio> para avanzar a la derecha y b para retroceder a la izquierda).
Una vez encima del carácter que queremos borrar, pulsamos la x. Para insertar caracteres, ponemos el
cursor en el sitio en el que queremos insertar y pulsamos la i que nos mete nuevamente en el modo de
inserción y podemos seguir escribiendo.
Una vez terminado el programa, pulsamos <escape> para pasar al modo de comandos y escribimos: wq
(un: una w y una q). Esto hace que se salve el fichero y salgamos del editor vi
El editor vi parece complejo de usar, y de hecho lo es cuando se empieza con él. Sin embargo es de los
editores más potentes y cómodos que he encontrado cuando se conoce y te acostumbras a él. Ahora
programo en Windows con los editores típicos de los entornos de desarrollo de Windows y echo de
menos algunos comandos de vi, además de que el ratón me hace hacer determinadas operaciones más
lentamente de lo que puedo hacerlas en vi simplemente pulsando teclas.

Compilamos nuestro programa
Para compilar nuestro programa usamos el comando (compilador) gcc. Si nuestro programa fuera de
C++ deberíamos usar el g++
$ gcc HolaMundo.c
Esto compila el programa y produce un ejecutable, si no hay errores, que se llama a.out
Ese nombre no es bonito y tampoco es bonito que mi HolaMundo se llame a.out, que mi juego de
marcianos se llame a.out y mi hoja de calculo se llame a.out. Tampoco es bonito tener que cambiarle el
nombre al ejecutable después de compilar. Afortunadamente gcc tiene opciones para poder darle al
ejecutable el nombre que queramos. La opción es -o NombreQueYoQuiera. Borramos el a.out con el
comando rm y volvemos a compilar con la opción -o que sí es bonita.
$ rm a.out
$ gcc HolaMundo.c -o HolaMundo
Ya deberíamos tener el ejecutable HolaMundo

A diferencia de Windows, los ejecutables no tienen que terminar en .exe. Linux marca los ejecutables con
un atributo del fichero (similar a los atributos de escritura o sólo lectura), y le da igual la extensión que
tengan.
Ejecutamos nuestro programa
Suponemos que para ejecutar nuestro programa basta con poner su nombre

$ HolaMundo

¡Lástima! ¡No funciona! El motivo es que por seguridad, linux sólo busca ejecutables en determinados
directorios. Esos directorios son los que se indican en la variable de entorno PATH. Ni el directorio de
nuestro proyecto ni el directorio actual de trabajo están en esa variable (ni deben estar si atendemos a la
seguridad). Para ejecutar nuestro programa hay que poner delante el path donde se encuentra. Este
path puede ser absoluto o relativo al directorio actual. Vale cualquiera de los siguientes:

$ /home/chuidiang/MI_PROGRAMA/HolaMundo
$ ./HolaMundo

Ya está. Cualquiera de estos dos comandos debería ejecutar nuestro programa y mostrarnos el tan
deseado "Hola mundo." (Por supuesto, el /home/chuidiang es dónde está mi directorio como usuario
chuidiang. Tú tendrás que poner el tuyo.)

El siguiente paso (opcional de momento, pero obligatorio cuando hagamos cosas más complejas) será
entrar en el debugger.