├── README.md ├── capitulos ├── vim3.md ├── vim2.md ├── vim10.md ├── vim4.md ├── vim7.md ├── vim9.md ├── vim6.md ├── vim16.md ├── vim13.md ├── vim8.md ├── vim15.md ├── vim12.md ├── vim1.md ├── vim11.md ├── vim14.md └── vim5.md └── index.html /README.md: -------------------------------------------------------------------------------- 1 | # curso-de-vim 2 | Un curso sobre el editor de código Vim. 3 | 4 | 5 |
6 | 7 | 8 | 9 | 10 |
11 | 12 | 16 | -------------------------------------------------------------------------------- /capitulos/vim3.md: -------------------------------------------------------------------------------- 1 | # Cómo usar Vim desde cero : 3 - El modo normal 2 | 3 | Vim nos proporciona una interfaz modal. Esto significa que el resultado de pulsar cualquier tecla de nuestro teclado, puede variar dependiendo el modo que esté activado en ese momento. Es vital saber el modo que está activado y también saber la forma de cambiar de un modo a otro. En esta parte de la guía sobre cómo usar Vim vamos a ver lo que podemos hacer en el modo normal. 4 | 5 | Se podría decir que el modo normal de Vim es el estado de reposo. Otros editores de texto pasan la mayor parte del tiempo en lo que a Vim equivale al modo insertar. Para alguien que acaba de llegar a este editor modal, puede parecer extraño que pasemos la mayor parte del tiempo en ese modo. Para explicarlo podemos basarnos en la metáfora del modo de trabajo de un pintor. 6 | 7 | ¿Cuánto tiempo piensas que un pintor está con el pincel sobre el cuadro? Es obvio que el tiempo va a variar dependiendo del artista pero sumando el tiempo que emplea en estudiar las formas, perspectivas, combinaciones de colores y el modo de aplicarlas... Posiblemente llegue a la mitad del tiempo que tarda en realizar su obra. Un pintor no descansa dejando el pincel sobre el cuadro, ni nosotros tampoco lo haremos en Vim. 8 | 9 | ## Regula como deshaces tus cambios 10 | 11 | En otros editores de texto pulsar el comando deshacer nos eliminará las últimas palabras o caracteres. En Vim el comando de deshacer se invoca pulsando `u` y el de rehacer con `Ctrl-R`. Se puede deshacer cualquier cosa que haya cambiado texto del documento, eso incluye cambios realizados desde el modo normal, visual o incluso del modo de línea de comandos. Por lo tanto, un cambio puede ser simplemente `i{insertamos texto}`. 12 | 13 | Si invocamos el comando deshacer en otro editor de texto no modal, pueden pasar dos cosas. Puede eliminar el último carácter o puede eliminar las últimas palabras escritas. Sin embargo, en Vim podemos controlar el nivel de lo que queremos deshacer. 14 | 15 | Desde el momento en el que insertamos texto hasta que volvemos al modo normal, todo lo que escribamos cuenta como un cambio. Así que podemos moderar el efecto del comando deshacer sobre caracteres, frases o párrafos dependiendo del uso que hagamos de la tecla ``. 16 | 17 | ## Comandos esenciales 18 | 19 | En el post anterior hicimos una modificación en nuestro `.Vimrc` en el que cambiamos las teclas de dirección a unas más acordes con el teclado español. Por lo tanto para movernos por el texto usaremos las teclas `jklñ`. Pero tenemos muchos más comandos para movernos por el texto, como `gg` que nos llevará a la primera línea del documento, mientras que `G` nos llevará a la última. `0` nos llevará al inicio de la frase y `$` al final. 20 | 21 | En Vim tenemos que diferenciar una *palabra* de una *PALABRA*. Una *palabra* se diferencia por puntos, guiones u otros caracteres mientras que una *PALABRA* se diferencia por espacios. `e` nos lleva al final de las *palabras* mientras que `E` sirve para el final de las *PALABRAS*. `w` y `W` hacen lo mismo pero para el inicio de las palabras y por último, `b` y `B` es igual que el anterior pero hacia atrás. `{` y `}` nos mueven al inicio y al final del párrafo. 22 | 23 | En el primer post de está guía vimos lo que hacían comandos como `d`, `f`, `t` y `x`. No podemos olvidarnos de `y` (copiar) ni de `p` (pegar). Dependiendo de si los invocamos con mayúscula o minúscula tendrán efectos distintos en el texto. `F` y `T` irán marcha a tras, `P` pegará el texto en la misma línea, `Y` actuará sobre la línea completa y `D` tendrá el mismo efecto que `d$`. Por último, están `ctrl+a` y `ctrl+x` que invocados sobre un número harán operaciones aritméticas de sumar o restar. Por ejemplo, `10 ctrl+a` sumará 10 al número donde tengamos el cursor, ideal para cuando editamos CSS. 24 | -------------------------------------------------------------------------------- /capitulos/vim2.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 2 - Editar al estilo VIM 2 | 3 | En esta segunda entrada sobre cómo usar [**Vim**](http://www.vim.org/), antes de adentrarnos en los modos de edición, vamos a aprender una de las características estrella de Vim, los comandos de repetición de tareas. A parte, también haremos nuestras primeras modificaciones al archivo `.vimrc`, el cual, se encuentra en la raíz de nuestra carpeta personal. 4 | 5 | Durante nuestras sesiones de edición de código, cuántas veces habremos pensado lo genial que sería que algunas tareas repetitivas se hicieran solas. Si nunca has usado un editor que pudiera automatizar tareas, ya sea con macros o con otra característica, **esto te va a sorprender gratamente. Se podría decir que Vim es un editor para vagos**. 6 | 7 | **No importa si usas la versión de Vim con interfaz gráfica o la que se ejecuta en terminal, podrás seguir la guía de igual manera**. Lo primero que haremos será añadir las siguientes líneas a nuestro `.vimrc`, las cuales activarán más funciones de Vim que por defecto vienen bloqueadas. Además del resaltado de sintaxis. 8 | 9 | `set nocompatible` 10 | 11 | `filetype plugin on` 12 | 13 | `syntax on` 14 | 15 | | Comandos | Contenido del buffer | 16 | |---|---| 17 | | {posición inicial} | `L`ínea uno | 18 | | x | `í`nea uno | 19 | | . | `n`ea uno | 20 | 21 | El comando `dd`, sirve para eliminar una línea. Si después usamos el comando punto, eliminaremos otra línea. De forma que si nos movemos por el documento **podremos eliminar líneas completas solamente pulsando el comando punto**, ¿bastante cómodo verdad? 22 | 23 | ## Muévete en Vim como en un teclado español 24 | 25 | Vim por defecto, nos tiene acostumbrados a movernos por el archivo con las teclas **hjkl**, pero en un teclado español nosotros ponemos los dedos sobre **jklñ**. Por lo tanto, he decidido que para mí es más cómodo cambiar esas teclas, de tal forma que siempre tendré mis dedos en la posición del teclado español. Para ello he añadido esto a mi `.vimrc`. 26 | 27 | teclas de dirección en el modo normal como en el teclado español 28 | 29 | `nnoremap j h` `nnoremap k j` `nnoremap l k` `nnoremap ñ l` 30 | 31 | teclas para movernos por paneles como en el teclado español 32 | 33 | `nnoremap j h` `nnoremap k j` `nnoremap l k` `nnoremap ñ l` `nnoremap J H` `nnoremap K J` `nnoremap L K` `nnoremap Ñ L` 34 | 35 | teclas para cambiar de línea en frases largas como en un teclado español 36 | 37 | `nnoremap gk gj` `nnoremap gl gk` 38 | 39 | teclas para el modo visual como en el teclado español 40 | 41 | `vnoremap j h` `vnoremap k j` `vnoremap l k` `vnoremap ñ l` 42 | 43 | ## Casos prácticos 44 | 45 | Podemos **indentar un archivo** con `>>`, de esta forma, si queremos continuar indentando más líneas solo tendremos que movernos a ellas y pulsar el comando punto. No importa en que lugar de la línea estemos, podemos indentar aunque estemos a final de la frase, pulsando el punto. 46 | 47 | | Comandos | Contenido del buffer | 48 | |---|---| 49 | |{posición inicial}|`L`ínea uno| 50 | | |Línea dos| 51 | | | Línea tres| 52 | |k>>|Línea uno| 53 | | |      `L`ínea dos| 54 | | | Línea tres| 55 | 56 | **Un error habitual cuando editamos JavaScript es olvidarnos del ; final** de algunas líneas de código. Si nos hemos olvidado de ello en varias líneas, el comando punto también nos puede ayudar. La tecla `$` lleva a nuestro cursor al final de la línea y la tecla `a`, nos cambia al modo insertar en un carácter siguiente de donde tenemos el cursor. Sin embargo, **la misma funcionalidad se puede conseguir simplemente pulsando `A`**. 57 | 58 | | Comandos | Contenidos del buffer | 59 | |---|---| 60 | |{Posición inicia}|`v`ar foo = 1| 61 | |A;| var foo = 1`;` 62 | 63 | Después, saldremos del modo insertar al normal pulsando la tecla ``. Ahora, si tenemos más líneas a las que les falten el `;` simplemente con pulsar el comando `.` se añadirá, sin importar la posición de la frase en la que estemos. **Como podéis ver, el comando `.` es todoterreno y nos ayudará a hacer las cosas mucho más rápido que manualmente**. 64 | -------------------------------------------------------------------------------- /capitulos/vim10.md: -------------------------------------------------------------------------------- 1 | Aprende a usar Vim desde cero: 10 – Cómo moverse rápido por los archivos 2 2 | 3 | En el capítulo anterior estuvimos viendo formas que podemos usar para movernos rápido por nuestros archivos. Algunos de los comandos fueron mencionados en posts anteriores de forma suelta, divididos por los diferentes modos de Vim. Al ser comandos con un propósito similar, tiene sentido hacer una lista con todos ellos y profundizar más en el tema que nos ocupa añadiendo unos cuantos más. De esta forma, los tendremos a mano para consultar más adelante. 4 | 5 | Esta semana en este décimo (doble cifra ya) post sobre Vim, vamos a seguir viendo formas de movernos rápido por nuestro archivo sin usar el ratón. Además, veremos **una de mis características favoritas de Vim, las llamadas *marcas***, con las que podremos marcar secciones relevantes del archivo para poder saltar a ellas cuando sea preciso. 6 | 7 | ##Hacer selecciones precisas 8 | 9 | Movernos rápido por el archivo también tiene que ver con hacer selecciones de una manera rápida, sencilla y eficaz. De eso mismo va este apartado, en el que si os fijáis reconoceréis varios de los comandos que he puesto en la siguiente lista. **i** significa *dentro de X elemento*, mientras que **a** significa *alrededor de X elemento*. La gracia de estos comandos que vais a ejecutar desde el modo normal es que vayan precedidos de `v` (selección visual), `c` (cambiar texto) o `d` (borrar texto) ya que por sí solos no hacen ninguna función. 10 | 11 | 12 | - **a)** / a** paréntesis. 13 | - **i)** / ib** paréntesis. 14 | - **a}** / aB** llaves. 15 | - **i}** / iB** llaves. 16 | - **a]** corchete. 17 | - **i]** corchete. 18 | - **a>** para mayor o menor que. 19 | - **i<** para mayor o menor que. 20 | - **a’** comillas simples. 21 | - **i’** comillas simples. 22 | - **a”** comillas dobles. 23 | - **i”** comillas dobles. 24 | - **a`** acento grave. 25 | - **i`** acento grave. 26 | - **at** para tags HTML. 27 | - **it** para tags HTML. 28 | - **aw** palabras. 29 | - **iw** palabras. 30 | - **aW** PALABRAS. 31 | - **iW** PALABRAS. 32 | - **as** frase. 33 | - **is** frase. 34 | - **ap** párrafo. 35 | - **ip** párrafo. 36 | 37 | ## Marca lugares relevantes para volver a ellos fácilmente 38 | 39 | El comando `m{a-zA-Z}` crea una marca (o varias si definimos más) en el archivo a la que podremos saltar cuando queramos usando el acento grave más la letra del alfabeto que hayamos usado. Por ejemplo, podríamos usar la marca mm movernos por el archivo y volver a ella con ``m`. Con el tiempo os daréis cuenta de que esta es una herramienta muy útil y podréis moveros por el archivo sin miedo a perder la posición de interés. Lo bueno de las marcas es que hay algunas que se añaden solas, aquí tenéis unos cuantos comandos que se ejecutan desde el modo normal y sin los dos puntos: 40 | 41 | 42 | - **“** ir a la posición antes del último salto en el archivo actual. 43 | - **`.** ir a la localización del último cambio. 44 | - **`^** ir a la posición de la última inserción. 45 | - **`[** ir a la posición inicial del último cambio o copia (yank). 46 | - **`]** ir a la posición final del último cambio o copia (yank). 47 | - **`<** ir a la posición inicial de la última selección visual. 48 | - **`>** ir a la posición final de la última selección visual. 49 | 50 | Si queréis saber más de esta función podéis consultar la ayuda con `:h m`. 51 | 52 | ## Plugin de interés 53 | 54 | En Vim hay un **plugin llamado machit** que hay que activar editando el `.vimrc`. Su función es la de aumentar el alcance del comando `%` que por defecto, si lo pulsamos sobre paréntesis o llaves nos lleva a su pareja de cierre. Mediante *machit* conseguiremos que nos lleve en un archivo HTML de una etiqueta a su cierre o en un archivo Ruby nos lleve a los pares de `class/end`, `def/end` y `if/end`. 55 | 56 | `set nocompatible` 57 | 58 | `filetype plugin on` 59 | 60 | `runtime macros/matchit.vim` 61 | 62 | Hay otro plugin que nos va a facilitar mucho la vida para **cambiar el elemento que se encuentre rodeando nuestra selección**, su nombre es [vim-surround](https://github.com/tpope/vim-surround). Usando este plugin, podremos sustituir por ejemplo las dobles comillas por paréntesis o por lo que elijamos, añadir etiquetas HTML que se cierran solas en una selección o borrar lo que rodea a nuestra selección. 63 | -------------------------------------------------------------------------------- /capitulos/vim4.md: -------------------------------------------------------------------------------- 1 | # Cómo usar Vim: 4 - El modo insertar 2 | 3 | Bienvenido a la cuarta entrega del curso sobre cómo usar Vim, el editor de código modal que te haceser más productivo. Esta vez toca que hablemos del modo insertar. 4 | 5 | La mayoría de los comandos de Vim se ejecutan en otros modos, pero algunas de las funciones también se pueden usar en el modo insertar. En esta entrada, vamos explorar algunos de esos comandos y veremos cómo insertar caracteres especiales. 6 | 7 | También hablaremos del modo reemplazar, el cual sobreescribe los caracteres existentes en el documento por lo que escribamos. Veremos ejemplos de cúando puede sernos de utilidad esta función y descubriremos el modo insertar-normal (*insert normal mode*), un submodo que nos permite usar un comando y volver directos al modo insertar. 8 | 9 | En este modo también se puede usar la función de autocompletado de Vim, pero eso es algo que lo veremos más adelante. 10 | 11 | ## Haz correcciones al instante desde el modo Insertar 12 | 13 | Cometer un fallo en Vim no significa que tengamos que cambiar de modo para poder corregirlo. Lo podemos hacer directamente desde el modo insertar. Además de usar la tecla de retroceso tenemos más combinaciones que permitirán una corrección rápida y precisa. Aprender mecanografía para usar correctamente Vim es esencial. No podremos ser productivos si tenemos que estar mirando al teclado por cada caracter que tenemos que insertar en nuestro documento. Cuando ya hemos dominado nuestro teclado al aprender caligrafía llegamos a un momento en el que cuando escribimos desarrollamos una especie de sexto sentido en el que sabemos que nos vamos a equivocar en una tecla justo antes de escribirla, es como si nos hubiéramos tropezado. Es cierto que podemos usar la tecla retroceso para corregir rápidamente ese traspiés. Pero, ¿qué pasa cuando el fallo ocurre al inicio de la palabra? 14 | 15 | Mecanógrafos expertos recomiendan medidas drásticas como eliminar las palabras completas, es una medida que podemos aplicar si podemos escribir al menos 60 palabras por minuto ya que solo nos tomaría un segundo escribir la palabra. También podríamos salirnos del modo, borrar la palabra y después pulsar `A` para volver al modo insertar. Pero esta vez vamos a usar comandos que funcionan tanto en el modo insertar, en el modo de comandos e incluso en la shell Bash. 16 | 17 | > Borra un caracter hacia atrás (igual que el retroceso) 18 | > Borra una palabra hacia atrás 19 | > Borra hasta el principio de la línea 20 | >0 Pega el texto que hayamos copiado al registro 0 (el de por defecto) 21 | >= Podemos hacer operaciones aritméticas e insertará el resultado 22 | > Entra la modo insertar-normal 23 | 24 | El modo insertar-normal de Vim es un modo que nos regala una bala. Esa bala es uncomando que podremos disparar, después nos devuelve directamente al modo insertar. Podremos usarlo por ejemplo para situar nuestra vista al centro de la pantalla como si hubiéramos hecho scroll hacia abajo `zz`. 25 | 26 | ## Insertar caracteres especiales 27 | 28 | En Vim podremos insertar cualquier caracter por su código númerico, algo fantástico para cuando queremos insertar elementos que no aparecen en nuestro teclado. Lo único que haremos será escribir `{código}`, por ejemplo, al caracter `A` le corresponde `065`. Si quieres saber cuál es el código numérico de cualquier caracter sitúate sobre el desde el modo normal y pulsa `ga`. 29 | 30 | {123} Insertar caracter por código decimal 31 | u{1234} Insertar caracter por código hexadecimal 32 | {char1}{char2} Ejemplo `¿` == ?I 33 | 34 | ## Sobreescribe el texto con el modo reemplazar 35 | 36 | El modo reemplazar es idéntico al modo insertar con la peculiaridad de que si escribimos y delante tenemos texto, en lugar de moverlo un espacio hacia adelante, escribe sobre él sustituyendo el caracter que teníamos delante por el que hemos escrito. Para entrar a ese modo lo haremos simplemente pulsando la tecla `R`. 37 | 38 | Otra variante es el modo reemplazar para un solo caracter, se invoca con `r` y es muy útil para sustituir el caracter que queramos corregir. `r` nos devuelve al modo normal, mientras que `s` hace lo mismo pero nos deja en el modo insertar. Si lo que queremos corregir es la capitalización de un caracter lo podemos hacer pulsando `~`, es más rápido que pasarlo a mayúsculas o minúsculas a mano. 39 | -------------------------------------------------------------------------------- /capitulos/vim7.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 7 - Trabajar con múltiples archivos 2 | 3 | Bienvenido a la séptima entrega del curso sobre cómo usar Vim, el editor de código modal que te hace ser más productivo. Esta vez trabajaremos con múltiples archivos. 4 | 5 | Después de hacer un tour por los modos que tiene Vim ya va siendo hora de que nos pongamos a trabajar con múltiples archivos. La forma que tiene Vim de manejar los archivos me encanta. No se vosotros, pero yo cuando usaba editores de código como Sublime Text acababa llenando el espacio de trabajo con multitud de pestañas. Puede que la culpa fuese mía por no saber administrarme bien con editores así pero no importa, porque con Vim ya no tengo un espacio de trabajo abarrotado. He pasado del caos al orden y es de eso de lo que voy a hablar en este post. 6 | 7 | Vim no solo soporta pestañas, también soporta paneles, es decir, unas divisiones por cada pestaña que pueden ser horizontales o verticales. Si alguna vez habéis usado [tmux]() ya sabéis de lo que estoy hablando. Hablaremos de ello en el siguiente post. 8 | 9 | ## La lista de buffers 10 | 11 | Algo importante que tenemos que saber es que Vim hace una distinción entre archivos y *buffers*. Un archivo está guardado ene l disco mientras que un buffer se guarda en la memoria. Cuando decimos que estamos editando un archivo lo que en realidad editamos es un buffer. Imaginemos que tenemos una carpeta con varios archivos de texto, ya sabéis esos que acaban en `.txt`. Desde nuestra terminal podemos abrir todos los archivos que tengan esa terminación con el comando `vim *.txt`. Cuando Vim se abra veremos que en la ventana solo tenemos un archivo abierto, pero en realidad Vim ha creado un buffer para todos los archivos `.txt` de la carpeta, solo que solo vemos un archivo en pantalla. Veamos que podemos hacer con esos buffers: 12 | 13 | + `:ls` nos muestra una lista de los buffers. Si vemos el símbolo `#` delante del nombre de un buffer significa que es el buffer anterior al que hemos estado. Podemos volver al buffer anterior con ``. No es una combinación muy cómoda para el teclado español, pero siempre podemos editar nuestro `.vimrc` para ponerlo al gusto. Por otro lado si un archivo de la lista va precedido por el símbolo `%` significa que es el archivo que estamos editando en este momento. 14 | + `:bn[ext]` podemos escribir `:bn` o `:bnext` para que se ejecute este comando. Su función es la de abrir el siguiente buffer de la lista. 15 | + `:bp[revious]` abre el buffer anterior. 16 | + `:bf[irst]` abre el primer buffer de la lista. 17 | + `:bl[ast]` abre el último buffer de la lista. 18 | + `:bd[elete]` eliminar buffer de la lista, no elimina el archivo del disco. 19 | + `:args` muestra la lista de argumentos, a diferencia de `:ls` solo muestra el nombre de los archivos y en cual estamos. Podemos añadir por ejemplo todos los archivos `.js` de las carpetas con el comando `:args **/*.js`. 20 | + `:argdo [comando]` nos permite realizar un comando en todos los archivos de la lista a la vez. Muy útil si queremos reemplazar algun texto en todos los archivos. 21 | + `w[rite]a[all]` guarda todos los archivos. 22 | + `q[uit]a[all]` sale de todos los archivos. Si le añadimos el signo `!`, saldrá sin guardar los cambios. 23 | 24 | Aquí os dejo un remapeo de teclas de ejemplo para que podáis añadir a vuestro `.vimrc`. Solo es un ejemplo, para mí funciona pero si se te ocurre una combinación que funcione mejor para ti cámbialo a tu gusto. Lo que hace estas líneas es que cuando pulsemos por ejemplo `[b` será lo mismo que si hubiéramos escrito `:bprevious`. Si no lo estáis haciendo ya recomiendo que os acostumbréis a crear vuestros atajos, os hará más productivo con las acciones que repitáis a menudo. Si todavía no usáis el plugin [vim-airline]() os lo recomiendo, para más información podéis visitar este sensual [post](). 25 | 26 | nnoremap [b :bprevious 27 | nnoremap ]b :bnext 28 | nnoremap [B :bfirst 29 | nnoremap ]B :blast 30 | 31 | ## Posts anteriores sobre cómo usar Vim 32 | 33 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 34 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 35 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 36 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 37 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 38 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) -------------------------------------------------------------------------------- /capitulos/vim9.md: -------------------------------------------------------------------------------- 1 | Puede chocar mucho la forma de trabajar que tiene Vim para todos aquellos que vienen de usar otros [editores de código]. El objetivo principal de Vim es la productividad y su filosofía se centra en que no hay que levantar las manos del teclado jamás. Puede que parezca una tontería, pero si nos ponemos a pensar en las veces que dejamos el teclado para coger el ratón, con el tiempo nos ahorramos varios segundos que al cabo de un tiempo serán minutos y al final horas. No solo por el simple hecho de mover la mano fuera del teclado sino por que cuando *hablamos Vim* podemos hacer selecciones muy precisas en apenas un segundo. 2 | 3 | Poder realizar cambios en los rextos de esta manera es muy útil, pero una de las cosas que notaremos las primeras veces que usamos Vim es la necesidad (el autoreflejo) de querer mover la mano a las teclas del dirección o al ratón. Cuando inicié el estudio de este editor, al estar acostumbrado a moverme con las teclas de dirección y sabiendo que no debería de usar el ratón para moverme por el archivo, casi me desespero. ¿Cómo iba a moverme rápido por el archivo si tenía que moverme pulsando teclas? 4 | 5 | Los desarrolladores de Vim no son idiotas y en todos estos años de desarrollo de esta completa herramienta, han conseguido añadirle unas características llamadas *motions* cuya traducción aproximada podría ser la de *movimientos*. 6 | 7 | ## Las teclas de dirección te hacen más lento 8 | 9 | - Imagen del remapeo 10 | 11 | Ya hemos hablado en otras ocasiones de algunas de estas *motions*, pero al ser una función tan importante para nuestra productividad merece que nos detengamos un poco en ellas. Además, voy a dar unos consejos para que nos acostumbremos a usar Vim sin las teclas de dirección y sin el ratón. Lo priemro de todo es que debemos reposar siempre los dedos en la línea media del teclado. Las teclas para movernos en Vim por defecto en el teclado inglés serán `h` (izquierda), `j` (línea abajo), `k` (línea arriba), `l` (derecha) pero ya vimos en un post [anterior] cómo cambiarlas al equivalente del teclado español si queríamos. Yo las he dejado por defecto, ya que estoy dejando el teclado qwerty y empezando a usar dvorak, así que para mí no tiene mucho sentido cambiarlas. 12 | 13 | " inhabilitar las teclas de dirección 14 | noremap 15 | noremap 16 | noremap 17 | noremap 18 | 19 | A veces no podemos evitar ir a las teclas de dirección, por esa razón os he dejado unas líneas para que insertéis en vuestro `.vimrc`, con ellas quitaréis el hábito de ir a las teclas de dirección. Incluso podéis remapearlas para que tengan una fucnión máś útil. 20 | 21 | ## Usa las *motions* para moverte más rápido por el archivo 22 | 23 | - imagen frase 24 | 25 | Hemos hablado antes de las *motions* cuando hablábamos de los comandos que podíamos usar en los diferentes modos de Vim. Para tenerlo un poco más ordenado he pensado en dejaros esta lista: 26 | 27 | + **j** bajar un número de línea, es decir, líneas separadas por un retorno de carro. 28 | + **gj** bajar una línea visible, comportamiento habitual de los editores normales. 29 | + **k** sube un número de línea. 30 | + **gk** sube una línea como lo haría un editor corriente. 31 | + **0** va al principio de la línea real. 32 | + **g0** va al principio de la línea visible en pantalla. 33 | + **^** va al primer carácter no en blanco de la línea real. 34 | + **g^** va al primer carácter no en blanco de la línea visible en pantalla. 35 | + **$** va al final de la línea real. 36 | + **g$** va al final de la línea visible en pantalla. 37 | + **w** va hacia el principio de la siguiente palabra. 38 | + **b** va hacia atrás, al principio de la palabra actual o de la anterior. 39 | + **e** va al final de la palabra actual y si estamos allí, de la siguiente palabra. 40 | + **ge** va al final de la palabra anterior. 41 | + **/búsqueda** muy útil para dirigirno hacia palabras concretas en el texto. Además se puede combinar por ejemplo con `d` para borrar desde nos encrontramos hasta donde está nuestra búsqueda `d/palabra`. 42 | + **f{carácter}** va hacia delante hasta que encuentre el carácter. 43 | + **F{carácter}** lo mismo que el anterior pero en dirección contraria. 44 | + **t{carácter}** va hacia adelante y se para en una columna antes del carácter. 45 | + **T{carácter}** lo mismo que el anterior pero en dirección contraria. 46 | + **;** repite la última búsqueda de carácter. 47 | + **,** da la vuelta a la última búsqueda. 48 | 49 | ## Un plugin útil para movernos 50 | 51 | Normalmente con esto tendremos suficiente para movernos por el archivo pero hay plugins que nos pueden ayudar. El nombre de uno de ellos es [**vim-easymotion**](https://github.com/Lokaltog/vim-easymotion). -------------------------------------------------------------------------------- /capitulos/vim6.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 6 - El modo de comandos 2 | 3 | Bienvenido a la sexta entrega del curso sobre cómo usar Vim, el editor de código modal que te hace ser más productivo. Esta vez toca que hablemos del modo de comandos. 4 | 5 | Vim hereda comandos de su ancestro vi, con el cual se popularizó el modo de edición modal de archivos. A su vez, vi se basa en un editor antiguo llamado ex, esa es la razón por la que hoy en día tenemos comandos ex en Vim. La sangre de los antiguos editores de Unix corre por las venas de Vim. En este post hablaremos de como podemos usar el modo de comandos de Vim para realizar comandos en diferentes líneas, haciendo nuestras tareas habituales mucho más rápido y de esa manera, para tener más tiempo libre para dedicar a otros menesteres (o para picar más y más código si todavía te quedan fuerzas). 6 | 7 | Esta sección de la guía es poca teoría y mucha práctica así que harás bien en tener Vim abierto desde la terminal para ir practicando los comandos a medida que vas leyendo. Empecemos con ello. 8 | 9 | ## Te presento la línea de comandos de Vim 10 | 11 | Lo fundamental que hay que saber es que para entrar al modo de comandos de Vim hay que pulsar `:` y no lo olvides porque en Vim lo usarás mil y una veces. En este modo se escriben los comandos y se ejecutan pulsando `enter`. También hay otro modo de comandos especializado en búsquedas que se activa desde el modo normal pulsando `/`, pero hablaremos de él en detalle en otra ocasión. Desde este modo también podremos abrir pestañas, ventanas y manejar iferentes archivos pero lo veremos en los próximos posts. 12 | 13 | + `:[rango]d[elete]` **borra** las líneas especificadas. 14 | + `:[rango]y[ank]` **copia** líneas. 15 | + `:[línea]put` **pega** el texto en la línea descrita. 16 | + `:[rango]co[py] {dirección}` **copia** líneas especificadas **debajo de la dirección**. También se le invoca pulsando `:t`. 17 | + `:[rango]m[ove] {dirección}` **mueve** líneas especificadas **a la dirección** elegida. 18 | + `:[rango]j[oin]` **junta** líneas. 19 | + `:[rango]norm[al] {comando}` **ejectuda comandos del modo normal** en las líneas especificadas. 20 | + `:[rango]s[ubstitute]/{pattern}/{string}/[flags]` **Reemplaza las ocurrencias** de {pattern} con {string} en cada línea especificada. 21 | + `:[rango]g[lobal]/{pattern}/[comando]` **ejecuta un comando** en cada línea especificadas que coincidan pon el **patrón de búsqueda** {pattern}. 22 | + `:[rango]p[rint]` su misión es **mostrarnos el rango**, perfecto para practicar. 23 | + `:h [comando]` **información detallada de cada comando**. 24 | 25 | En la lista anterior, podemos ver diferentes comandos que podemos ejecutar. Es importante saber que no hace falta que escribamos la palabra completa. En el caso de `delete` podremos usar solo `d`, y en el de `normal` podríamos usar solo `norm`. En cuanto al rango de alcance de nuestro comando, tendremos que aprender a definirlo. Para ello hay que aprender como denomina Vim a las posiciones: 26 | 27 | + `1` **primera línea** del arhivo. 28 | + `$` **última línea** del archivo. 29 | + `0` **línea encima de la primera** (no existe la línea 0), se usa para mover o pegar texto encima de la primera línea. 30 | + `.` el punto, es la **línea está ubicado nuestro cursor**. 31 | + `'m` **línea que contiene la marca** (hablaremos de las marcas más adelante) *m*. 32 | + `'<` inicio de la **seleción visual**, `'>` final de la **selección visual**. Si seleccionamos unas líneas en el modo visual y seguido pulsamos `:` **se creará el siguiente rango automáticamente**: `:'<,'>`. 33 | + `%` **todo el archivo**, un atajo para el rango `:1,$`. 34 | 35 | ## Manos a la obra 36 | 37 | Ahora que ya sabemos unos cuantos comandos y las indicaciones de posición de Vim podremos *hablar Vim* indicando los rangos de acción. Para ello, aquí os dejo un ejemplo de las funciones que podréis hacer con el comando `:[rango]p[rint]`, perfecto para practicar rangos (podréis aplicar lo que hacemos con print a otros comandos): 38 | 39 | + `:5p` muestra lo que hay en la línea 5. 40 | + `2,10p` muestra las líneas desde la número 2 hasta la 10. 41 | + `.,+3p` muestra la línea donde está nuestro cursor y 3 más hacia abajo (con `-` sería hacia arriba). 42 | + `:'<,'>p` muestra la selección visual 43 | 44 | Ahora que ya nos hemos hecho una idea de como se definen los rangos hagamos ejemplos que podemos aplicar en una situación de verdad: 45 | 46 | + Hemos puesto el punto y coma final usando `A;` a una línea de JavaScript y queremos hacer lo mismo en varias líneas más. Podemos hacer una selección visual líneal con `V` y ejecutar el comando en todas ellas con `:'<,'>norm .` (recordad que el `.` es para repetir el último comando.) 47 | + `.m0` mover la línea en la que estamos al principio del archivo. 48 | + `4t9` copiar la línea 4 debajo de la línea 9 49 | + `%s/Madrid/Bilbao` reemplaza Madrid por Bilbao en todo el archivo. 50 | + `@:` repetir el último comando. 51 | 52 | Y lo que se os vaya ocurriendo a vosotros. -------------------------------------------------------------------------------- /capitulos/vim16.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 16 – Autocompletado 2 | 3 | **¿Qué editor de código que se precie no tiene una función de autocompletado?** Uno de mis editores favoritos siempre ha sido el famoso [Sublime Text](http://bitelia.com/2014/04/sublime-text-vs-brackets). Aparte de sus muchas bondades, una de las características que siempre me pareció tremendamente útil era el autocompletado. Recuerdo que en [otros programas](http://bitelia.com/2014/09/editores-codigo-mas-versatiles), escribía una variable y cuando tenía que voverla a escribir en otros lugares del archivo siempre había alguna en el que metía la pata y terminaba escribiendola mal, con los errores que acarreaba luego. 4 | 5 | El autocompletado es una de las funciones que yo al menos, considero más útiles cuando editamos [código](http://bitelia.com/tag/codigo). Escribir el principio de una variable o de una palabra larga y que nuestro editor nos muestre sugerencias es fantástico. Pero... **¿y si os dijera que Vim va un paso más allá?** 6 | 7 | Hoy, en esta sección de nuestro curso de Vim, echaremos un vistazo a las **opciones diferentes que nos proporciona Vim para el autocompletado**. 8 | 9 | ## El autocompletado más completo 10 | 11 | La [guía](http://bitelia.com/tag/como-usar-vim) de esta semana va a ser más teoría que otra cosa, pues no hay mucho que mostrar. Eso sí, os recomiendo que probéis con vuestro Vim lo que vamos a ir mirando en breve. Lo primero que tenemos que aclarar es que en** Vim tendremos varias opciones para el autocompletado y que este se realiza siempre en el *modo insertar***. Para activar las diferentes opciones de autocompletado tenemos los siguientes atajos de teclado (`` equivale a ``): 12 | 13 | + `` **el autocompletado de Vim se activa mediante el atajo de teclado anterior o mediante **``, el primero seleccionara el siguiente resultado en una lista de palabras mientras que el segundo seleccionara el resultado anterior. 14 | + `` sirve para **buscar una lista de palabaras en el buffer** (el archivo que estamos editando) en el que estemos. 15 | + `` muestra **autocompletado de archivos incluidos**. Muchos lenguajes de programación permiten incluir archivos, este atajo sirve para buscar palabras en ellos. 16 | + `` su función es `<>`. Un archivo *tags* tiene un índice de funciones, clases u otro tipo de estructuras. Pero esto se merece un post completo más adelante para entenderlo. 17 | + `` mira una **lista de palabras en el diccionario**. Así es, en Vim también podemos tener un corrector de palabras en español, pero esto lo discutiremos más a fondo en otro post. 18 | + `` este atajo hace un **autocompletado de líneas completas**. Imaginad que estamos editando un archivo CSS y vamos a repetir ciertas propiedades, como por ejemplo el *background*. Podríamos usar `ba` y nos rellenaría la línea completa, perfecto para ahorrarnos tiempo en escribirlo. 19 | + `` **autocompletado para nombres de archivos o carpetas**. En mi caso, encuentro tremendamente útil esta opción a la hora de escribir localización. Por ejemplo `/bin/b` nos mostraría una lista con los archivos que empiezan por la letra `b` en el directorio `/bin/`. 20 | + `` sirve para la *omni-completion*, **sugerencias basadas en el código como propiedades CSS** que podemos utilizar (imagen anterior). Hay varios lenguajes de programación soportados y mediante plugins podemos agregar más. 21 | 22 | Como habéis podido leer, el autocompletado de Vim toma en cuenta diferentes contextos y solo nos muestra lo que necesitamos. Toma un tiempo recordar los [comandos](http://bitelia.com/tag/comandos) pero una vez aprendidos, nuestra productividad se disparará. Espero que os haya sido útil y volveremos con más la semana que viene. **¿Cómo lo lleváis hasta ahora?** 23 | 24 | ## Posts anteriores sobre cómo usar Vim 25 | 26 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 27 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 28 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 29 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 30 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 31 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 32 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 33 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 34 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 35 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 36 | [11: Dominar los registros](http://bitelia.com/2014/11/como-usar-vim-11) 37 | [12: El poder de las macros](http://bitelia.com/2014/12/como-usar-vim) 38 | [13: Patrones](http://bitelia.com/2014/12/como-usar-vim-13) 39 | [14: Sustituciones](http://bitelia.com/2015/01/como-usar-vim-14) 40 | [15: Comandos globales](http://bitelia.com/2015/01/como-usar-vim-15) -------------------------------------------------------------------------------- /capitulos/vim13.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 13 - Patrones 2 | 3 | Ya estamos en la recta final del curso sobre [cómo usar Vim](http://bitelia.com/tag/curso-de-vim) desde cero. En estos últimos capítulos **hablaremos sobre los métodos que podemos usar para buscar texto (o patrones) y hacer sustituciones**. También me gustaría hacer después una entrega final en la que haga un recopilatorio de los mejores plugins que he encontrado durante todo este tiempo usando Vim. 4 | 5 | En la entrega de hoy, vamos a hablar de la búsqueda de patrones específicos. En los [editores de código](http://bitelia.com/2014/09/editores-codigo-mas-versatiles) más convencionales, solemos encontrar una función en un menú o una caja de texto en la que podemos insertar el texto a encontrar y hacer una búsqueda hacia adelante o hacia atrás. En algunos incluso podemos usar **expresiones regulares en nuestras búsquedas, una de las mejores funciones que podemos esperar de un buen editor de texto**. Vim también hace uso de esa función, con la diferencia que dependiendo del *modo de búsqueda* especificado escribiremos el patrón de forma diferente. 6 | 7 | **Para hacer una búsqueda hacia adelante simplemente pulsaremos`/` desde el modo normal (hacia atrás es con `?`), introduciremos el texto a buscar y pulsaremos la tecla `enter`.** Si queremos que nos redirija al siguiente resultado pulsaremos `n` y para el anterior será con `N`. 8 | 9 | ## ¿Tener en cuenta las mayúsculas? 10 | 11 | Podemos decirle a Vim que tome o no en cuenta las mayúsculas de forma global o especificarlo en cada búsqueda. Si **no queremos que Vim tome en cuenta las mayúsculas** pondremos en nuestro `.vimrc` lo siguiente: 12 | 13 | `set ignorecase` 14 | 15 | Sin importar la opción que tengamos definida por defecto, podemos **especificar si queremos que las tome en cuenta en la propia búsqueda** mediante los elementos `\c` y `\C`. El primero hará que no tenga en cuenta las máyusculas mientras que el segundo sí lo hará, de forma que podemos esperar el comportamiento siguiente (no importa si los ponemos al principio o al final): 16 | 17 | + `hola` encontrará (si activamos *ignorecase*) `Hola hola HoLa` 18 | + `hola` encontrará (sin *ignorecase*) `hola` 19 | + `\chola` encontrará (sin importar la opción por defecto) `hola Hola HoLa` 20 | + `hola\C` encontrará (sin importar la opción por defecto) `hola` 21 | 22 | De todas formas. **tenemos otro amigo más en nuestro repertorio**: 23 | 24 | `set smartcase` 25 | 26 | Cuya función es la de **tomar en cuenta las mayúsculas si en nuestra búsqueda incluímos una**. De no ser así, buscará todos los resultados posibles. 27 | 28 | ## Expresiones regulares en Vim 29 | 30 | Supongamos que tenemos un código como el siguiente en un archivo `.css` de nuestra página web y nuestro objetivo es buscar todos los colores hexadecimales que haya. 31 | 32 | `a { color: #0000EE; }` (ejemplo) 33 | 34 | Lo primeto que tendríamos que hacer es una búsqueda con el siguiente contenido (no os asustéis lo vamos a reducir mucho): 35 | 36 | `#\([0-9a-fA-F]\{6}\|[0-9a-fA-F]\{3}\)` 37 | 38 | Explicar las expresiones regulares va más hallá de los propósitos de este curso pero voy a intentar explicar brevemente su funcionamiento. Lo que hace esta expresión es buscar las palabras que empiecen por `#` y que contengan 6 o 3 caracteres con un contenido alfanumérico. Los `\` sirven para escapar caracteres que tienen un significado especial. 39 | 40 | Escribir esto cada vez que queremos hacer una búsqueda así es muy doloroso a la par que poco productivo. Para ello tenemos `\v` también llamado *very magic search*. 41 | 42 | `\v#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})` 43 | 44 | Con esto conseguiremos el mismo efecto y hecmos recortado la expresión, pero podemos reducirla todavía más: 45 | 46 | `\v#(\x{6}|\x{3})` 47 | 48 | En vez de escribir `[0-9a-fA-F]` podemos utilizar una clase para caracteres llamada `\x` que tiene el mismo contenido (para más información sobre estas clases `:h /character-classes`). 49 | 50 | **NOTA**: Si usamos busquedas para palabras como `a.k.a.` que tienen puntos en medio, no podríamos usar la búsqueda `/a.k.a.` ya que el punto significa *todos los caracteres* y podría darnos resultados que no queremos. Para hacerlo bien escaparíamos los puntos `/a\.k\.a\.` o **usaríamos el *very nomagic* search** que se hace con `\V` de la siguiente manera: `/\Va.k.a.` 51 | 52 | 53 | ## Posts anteriores sobre cómo usar Vim 54 | 55 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 56 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 57 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 58 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 59 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 60 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 61 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 62 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 63 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 64 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 65 | [11: Dominar los registros](http://bitelia.com/2014/11/como-usar-vim-11) 66 | [12: El poder de las macros](http://bitelia.com/2014/12/como-usar-vim) -------------------------------------------------------------------------------- /capitulos/vim8.md: -------------------------------------------------------------------------------- 1 | Aprende a usar Vim desde cero: 8 – Paneles y pestañas 2 | 3 | Ya son 8 semanas escribiendo sobre cómo usar Vim, los que me hayáis podido seguir hasta aquí podéis sentiros orgullosos. Hemos tocado los temas más básicos con los que poder manejar Vim con un poco de soltura, pero ahora toca expandir los conocimientos un poquito más. En cuanto a hablar Vim podríamos decir que ya hemos terminado así que de ahora en adelante nos vamos a centrar en conocer las funciones adicionales de este editor de código. 4 | 5 | En cuanto a dichas funciones que veremos en los siguientes posts, se incluyen las **macros, la administración de los registros, navegación dentro del archivo que estamos editando, búsquedas, sustituciones** y aparte de lo que se me vaya ocurriendo me gustaría dedicar un par de posts a hablar sobre los diferentes plugins que me parecen útiles. Si os interesa que hablemos más de plugins avisadme por los comentarios, yo creo que da para varios posts interesantes. De todas formas, si queréis un adelanto sobre plugins siempre podéis visitar este sensual post. Hoy hablaremos de los paneles y las pestañas de Vim, una función de la que hace tiempo que quería hablar. 6 | 7 | ## Paneles 8 | 9 | Esto, que nosotros conocemos como paneles de emuladores de terminal como Terminator, Vim lo llama ventanas. Si habéis usado Sublime Text alguna vez, lo conoceréis como layouts. **Cuando abrimos Vim, tiene solo un panel pero podemos dividirlo tanto horizontalmente como verticalmente** con los comandos que veis en la imagen anterior o desde el modo de comandos de esta manera: 10 | 11 | 12 | - `:sp[lit] {archivo}` divide el panel de forma horizontal, cargando el archivo si lo especificamos en el nuevo panel. Si no especificamos un archivo se divide el panel con el mismo archivo, muy útil cuando queremos estar mirando dos partes de un mismo archivo al mismo tiempo. 13 | - `:vsp[lit] {archivo}` divide el panel de forma vertical. 14 | 15 | Nótese que **un panel que se ha dividido con el mismo archivo no son dos instancias abiertas del archivo**. ¿Qué significa esto? Que los cambios en un panel serán reflejados en el otro automáticamente sin tener que recargar el archivo, pensad en ello como en **tener los ojos puestos en dos partes del archivo a la vez**. Podríamos movernos por los paneles usando el cursor, pero eso le quitaría el objetivo principal a Vim, dejar las manos siempre sobre el teclado. Así que vamos a ver que comandos se usan para movernos de un panel a otro. **NOTA**: Vim llama `C` a `Ctrl`. 16 | 17 | - `w` moverse por los paneles. Pulsaremos de forma conjunta la tecla control y `w`, soltaremos las teclas y pulsaremos `w` de nuevo. 18 | - `h` ir al panel de la izquierda. 19 | - `j` ir al panel de abajo. 20 | - `k` ir al panel de arriba. 21 | - `l` ir al panel de la derecha. 22 | - `c` cerrar panel. También hace lo mismo `:cl[ose]`. 23 | - `o` mantener el panel activo, cerrando los demás. También nos sirve `:on[ly]`. 24 | - `=` iguala la altura y anchura de los paneles. 25 | - `_` maximiza la altura del panel activo. 26 | - `|` maximiza el alncho del panel activo. 27 | - `[N]_` la alturá será de `[N]` filas. 28 | - `[N]|` la anchura será de `[N]` columnas. 29 | - `:h window-moving` como siempre me gusta hacer, os dejo un **comando de ayuda** para que os acostumbréis a buscar en la documentación. En realidad, la mayoría de lo que veis escrito aquí sale de comandos de ayuda como este de Vim. Con este en concreto aparecen comandos para mover los paneles, echadles un vistazo. 30 | 31 | 32 | ##Pestañas 33 | 34 | Sinceramente, no es que use mucho las pestañas de Vim. Puede parecer raro porque la mayoría de editores de código se vale de este diseño para editar múltiples archivos simultáneamente. Por otra parte, los paneles los uso muchísimo pero he aprendido a administrar los archivos como lo hicimos en el anterior post y es bastante más cómodo para mí. De todas formas, organizarnos con pestañas y paneles puede ser una buenísima idea, ya que podemos dividir las distintas áreas del proyecto por pestañas y en cada una tendremos paneles con los archivos que pertenezcan a esa área. Es una idea, con la libertad que nos da Vim cada uno que se organice a su manera. Veamos los comandos que se usan para las pestañas. 35 | 36 | 37 | - `:tabnew` abre una nueva pestaña. 38 | - `:lcd {ruta}` cambia la ruta (la carpeta) donde apunta el panel. 39 | - `:windo lcd {ruta}` cambia la ruta donde apuntan todos los paneles de una pestaña. Como ya he dicho antes, muy útil para organizar nuestro proyecto por áreas. 40 | - T mueve el panel actual a una nueva pestaña. 41 | - :tabe[dit] {archivo} abre un archivo en una nueva pestaña 42 | - :tabc[lose] cerrar la pestaña. Como podéis comprobar son muy parecidos a los comandos de los paneles. 43 | - :tabo[nly] cerrar todas las pestañas menos la activa. 44 | - :tabn[ext] {N} ir a la pestaña {N}. También nos sirve {N}gt 45 | - :tabn[ext] ir a la siguiente pestaña. gt hará lo mismo. 46 | - :tabp[revious] ir a la pestaña anterior. gT tiene el mismo resultado. 47 | - :tabmove [N] sirve para mover las pestañas. 48 | - :h tabpage por último, el comando de ayuda. Hay muchos más comandos que podemos usar para organizar las pestañas. Hemos visto los que usaremos con más frecuencia pero si queréis saber más mirad la documentación. 49 | -------------------------------------------------------------------------------- /capitulos/vim15.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 15 - Comandos globales 2 | 3 | En estos últimos posts hemos estado aprendiendo las bondades de los comandos del modo Ex de [Vim](http://bitelia.com/tag/curso-de-vim). Ahora que ya sabemos crear patrones y aplicarlos para sustituir diferentes elementos, va siendo hora de subir el nivel y conocer **otra de las herramientas más productivas de Vim, el comando `:global`, el cual es usado para trabajos repetitivos**. Seguro que se convierte en uno de vuestros comandos favoritos. 4 | 5 | Como suelo hacer, **primero vamos a aprender un poco de la teoría sobre este comando y después voy a mostrar varios ejemplos** útiles que he ido recopilando, estoy seguro que os van a encantar. 6 | 7 | ## ¿Qué hace el comando `:global`? 8 | 9 | **El comando `:global` nos permite ejecutar un comando Ex en las líneas que coincidan con el patrón que le indicquemos**. Su estructura es la siguiente (para más información consultad `:h :g`): 10 | 11 | `:[range] global[!] /{pattern}/ [cmd]` 12 | 13 | + **El rango de este comando por defecto es todo el archivo**, es importante diferenciarlo de otros comandos como `:delete` por ejemplo, que actçua sobre la línea en la que estemos posicionados. 14 | + `{pattern}` es el **patrón de busqueda**. Como vimos en el [post anterior](http://bitelia.com/2015/01/como-usar-vim-14), podemos dejarlo en blanco para que tome el patrón de la búsqueda anterior. 15 | + `[cdm]` no es más que **el [comando](http://bitelia.com/tag/comandos) Ex que queramos ejecutar**, si lo dejamos en blanco por defecto utilizará el comando `:print`. Perfecto para que nos muestre el lugar de actuación antes de usar un comando. 16 | + Os habréis fijado en el signo de exclamación junto a `global[!]`. Todo lo que está entre corchetes es opcional escribirlo. En este caso, **si añadimos la exclamación (o escribimos `:vglobal`) el comando actuará sobre las líneas que no coincidan** con el patrón, muy útil. 17 | 18 | Ahora veamos unos ejemplos en la vida real donde podamos usar estos comandos. 19 | 20 | ## Ejemplos para dominar el comando `:global` 21 | 22 | **Extraer contenido tags HTML con `:g/re/d`** 23 | 24 | Si habéis escrito alguna vez [HTML](http://bitelia.com/tag/html) sabéis que para poner listas se puede usar el tag `
    Contenido
`. Supongamos que tenemos un archivo en el solo **queremos quedarnos con el contenido de una lista con multitud de elementos**, es decir, queremos deshacernos de esas etiquetas automáticamente porque borrarlas a mano es una lata. Para ello haríamos lo siguiente. 25 | 26 | 1. `/\v\<\/?\w+>` primero hacemos la búsqueda. Busca un `\<` y un `\/?` después si existe. A la búsqueda le siguen uno o más caracteres `\w+` y termina con un `>`. Si no sabéis hacer expresiones regulares os recomiendo que las aprendáis, son muy útiles. 27 | 2. `:g//d` ahora ejecutamos el comando, lo dejamos vacío y adoptará el contenido de la expresión regular (`re`) anterior. La `g` es el comando `global` y la `d` es `delete`. 28 | 29 | **Quedarnos solo con los enlaces de un texto HTML con `v/re/d`** 30 | 31 | Recordemos que el comando `:vglobal` (abreviado `:v`) afectará a todo menos a nuestro patrón. Este es un ejemplo sencillito: 32 | 33 | `:v/href/d` 34 | 35 | Se traduce en 'elimina todo menos las líneas que contengan un `href`'. Hemos usado un simple comando para quedarnos con lo que nos interesa. 36 | 37 | **Recoger tareas pendientes con `g/re/p` u otros** 38 | 39 | `//TODO: crear ua función que haga...` **Esta es una buena forma de manejar nuestras tareas en el código**. En este caso hemos usado un comentario en un archivo [JavaScript](http://bitelia.com/tag/javascript), pero como están desperdigados por el archivo estaría bien recogerlso para saber que es lo que nos toca hacer ahora. 40 | 41 | + `:g/TODO` es una opción, no hace falta la `p` porque es el comportamiento por defecto. 42 | + `g/TODO/yank A` ahora las hemos copiado al registro`A`. Podemos ver el contenido con `:reg a` 43 | + `g/TODO/t$` copia las tareas al final del archivo. 44 | 45 | **Ordenar contenido de propiedades CSS alfabéticamente** 46 | 47 | `:g/{/ .+1,/}/-1 sort` Ordena alfabeticamente lo que este entre `{` y `}`, suponiendo que los corchetes están en líneas aparte de su contenido. 48 | 49 | ## Posts anteriores sobre cómo usar Vim 50 | 51 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 52 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 53 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 54 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 55 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 56 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 57 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 58 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 59 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 60 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 61 | [11: Dominar los registros](http://bitelia.com/2014/11/como-usar-vim-11) 62 | [12: El poder de las macros](http://bitelia.com/2014/12/como-usar-vim) 63 | [13: Patrones](http://bitelia.com/2014/12/como-usar-vim-13) 64 | [14: Sustituciones](http://bitelia.com/2015/01/como-usar-vim-14) -------------------------------------------------------------------------------- /capitulos/vim12.md: -------------------------------------------------------------------------------- 1 | Hoy hemos llegado a mi tema favorito en el curso sobre cómo usar [Vim](http://bitelia.com/tag/vim). **Si hay una característica en especial que me hiciera plantearme dar el paso a usar este editor de código son las macros.** Ya sabemos múltiples formas con las que podemos repetir comandos o cambios en el código en Vim, pero no son todas las formas que existen en este programa. De repetir va la cosa, pues las macros nos permiten almacenar en un registro una serie de cambios específicos que podremos repetir más tarde a nuestra merced. 2 | 3 | Con el [comando](http://bitelia.com/2014/11/bro-pages) punto "`.`" vimos que podíamos repetir una serie de pasos hasta que pulsábamos la tecla `escape` pero, ¿qué pasa si los cambios que queremos hacer son una serie de comandos en los que cambiaremos de modo varias veces? 4 | 5 | ## Grabar y ejecutar una macro 6 | 7 | **Las macros se empiezan a grabar en cuanto pulsamos la tecla `q` y le asignamos un registro**, para parar de grabar pulsaremos de nuevo `q`. Si quisiéramos guardar la macro escogida en el registro `a` usaríamos el comando `qa`. Por [comodidad](http://bitelia.com/2014/11/fondo-pantalla-y-productividad) yo siempre grabo mis macros con el comando `qq` ya que siendo la misma letra me evita pensar en que registro he guardado mi macro, **para dejar de grabar de nuevo `q`**. Para entender como funciona esta fantástica característica de Vim solo tenemos que seguir el siguiente ejemplo, en el que corregiremos el `;` final y añadiremos el `var` que falta. Empezamos a grabar con `qq`: 8 | 9 | **Este es nuestro código sin modificar** 10 | `uno = 1` 11 | `dos = 2` 12 | `suma = uno + dos` 13 | 14 | **En la primera línea añadimos el punto y coma con `A;`, declaramos la variable con `Ivar`, nos movemos una casilla abajo con `j` y dejamos de grabar con `q`** 15 | `var uno = 1;` 16 | `dos[ ]= 2` 17 | `suma = uno + dos` 18 | 19 | **¿Por qué nos hemos movido hacia abajo?** Muy sencillo, lo primero es saber que para ejecutar la macro pulsaremos `@q` (si hemos grabado con `qa` sería con `@a`). Pero recordad que las macros van de repetición, imaginad que en lugar de 3 líneas tenemos 20. No sería muy [productivo](http://bitelia.com/productividad) ir bajando nosotros cada línea y ejecutar `@q` cada vez. Por lo tanto, bajar una vez nos permite ejecutar la macro las veces seguidas deseadas (si queremos por ejemplo que sean 3 veces usaremos `3@q`) ya que los cambios se aplicarán en una línea y bajarán a la siguiente antes de volver a ejecutarse. A esto se le llama **ejecutar las macros en serie**. 20 | 21 | ## Jugando con variables 22 | 23 | Tenemos una lista que tenemos que numerar: 24 | 25 | `Bilbao` 26 | `Madrid` 27 | `París` 28 | `...etc` 29 | 30 | **El resultado será dejar la lista ordenada del tipo `1) Bilbao`**. Para ello primero crearemos una variable que se irá incrementando, con el comando `:let i=1` (para ver el contenido podemos hacer `:echo i`). Ahora comenzamos a [grabar](http://bitelia.com/2014/09/asciinema) con por ejemplo `qa` y empezamos a hacer los cambios en la primera línea. 31 | 32 | `I=i)` nos dejará un resultado de `1) Bilbao`. Ahora, aumentaremos la variable `i` mediante el comando `:let i+=1`. Ya podemos dejar de grabar la macro con `q`. Podemos hacer como antes y ejecutar la macro en serie si además nos movemos hacia abajo antes de guardar o podemos hacer una selección en el modo visual, pulsar `:` y escribir `normal @q`. A esto se le llama ejecutar la macro en paralelo y sirve para que si tenemos un fallo en una línea, no se nos pare de ejecutar la macro en las siguientes. En cualquier caso, **cada vez que usemos la macro aumentará en uno el número de nuestra lista.** 33 | 34 | ***Nota**: el comando `=i` sirve para pegar el contenido de la variable.* 35 | 36 | ## Trucos útiles 37 | 38 | + Para las macros usa [comandos](http://bitelia.com/2014/04/comandos-basicos-terminal) como `A` y `I` que normalicen la posición del cursor. 39 | + Para repetir una macro que acabamos de ejecutar por ejemplo con `@q` usaremos `@@` las veces que queramos. 40 | + Para ver el contenido de nuestra macro `a` podemos usar el comando `:reg a`. 41 | + Para editar una macro llamada por ejemplo `a`, podemos pegar su contenido con `:put a` y cuando la hayamos editado al gusto copiarla de nuevo al registro con `"ay$`. 42 | + Ejecutar una macro en todos los buffers abiertos `:argdo normal @a`. 43 | 44 | Coger soltura con las macros nos va a hacer muy productivos, espero que os sea útil en vuestros proyectos. 45 | 46 | ## Posts anteriores sobre cómo usar Vim 47 | 48 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 49 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 50 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 51 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 52 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 53 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 54 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 55 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 56 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 57 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 58 | [11: Dominar los registros](http://bitelia.com/2014/11/como-usar-vim-11) -------------------------------------------------------------------------------- /capitulos/vim1.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 1 - Introducción a Vim 2 | 3 | Si quieres saber cómo usar Vim desde cero sigue leyendo, este post será la primera toma de contacto con este maravilloso editor de código. 4 | 5 | como usar vim 6 | 7 | [**Vim**](http://www.vim.org/), del inglés *Vi Improved*, **es una versión mejorada del editor de texto Vi**, el cual, fue creado en 1976 por Bill Joy que tomó recursos de ed y ex, dos editores de texto para Unix. Vim, fue presentado en el año 1991 y desde entonces no ha dejado de experimentar infinidad de mejoras. **La madurez de este editor de código es indiscutible pues lleva desarrollándose más de 20 años**. 8 | 9 | La característica más destacable de este [editor](http://bitelia.com/2014/09/editores-codigo-mas-versatiles) es su **modo de edición modal**, en los que seremos capaces de realizar distintos tipos de operaciones. Si nunca has usado un editor modal, te recomiendo que te olvides por un momento de lo que sabes hasta ahora sobre editar archivos de texto, pues aquí no te va a servir. **La gracia de usar Vim está en que no tendremos que usar más el ratón ni las teclas de dirección para editar archivos**. 10 | 11 | Os debo advertir que las primeras veces que lo uséis os sentiréis muy lentos, **aprender a hablar Vim requiere de una gran curva de aprendizaje** pero no os desaniméis, os prometo que cuando os hayáis acostumbrado a él, **vuestra productividad aumentará notablemente**. Tenemos la versión Vim, que se ejecuta en la terminal escribiendo `Vim` y gVim que se ejecuta en una ventana, tiene menús y ayudas para novatos. Recomiendo instalar este último para empezar pero podéis usar el que queráis. Podéis instalarlo con `sudo apt-get install vim-gtk` en Ubuntu 14.04. Hay binarios para Windows y Mac en la [página oficial](http://www.vim.org/). 12 | 13 | ## Los diferentes modos de Vim 14 | 15 | **Modo Normal**. 16 | Vim empieza en este modo. Se pueden emplear combinaciones de teclas para, por ejemplo, copiar líneas y trabajar en el formato del texto. Éste es el modo central, desde el que se cambia a los otros modos. Pulsando la tecla `Escape` siempre se puede volver al modo normal. Por defecto, podremos mover el cursor por el archivo con `hjkl` (izquierda, abajo, arriba y derecha respectivamente) o con las teclas de dirección. 17 | 18 | **Modo insertar**. 19 | Es el modo en el que podemos introducir texto. Se puede entrar a este modo desd el modo normal pulsando la tecla `i`. Existen otros comandos que nos llevarán al modo inserción pero se diferencian uno del otro por la acción que realizan, como cambiar una palabra dentro de unas comillas, cambiar el texto hasta el final de la línea o hasta el cierre de un corchete, `}` etc. Un usuario avanzado ahorrará mucho tiempo utilizando estos atajos. 20 | 21 | **Modo de comandos**. 22 | Se accede pulsando `:`. Permite introducir diferentes comandos, como buscar y reemplazar con expresiones regulares. También podremos personalizar aspectos de Vim para esa sesión, ya que no quedarán guardados los cambios permanentemente. 23 | 24 | **Modo visual**. 25 | Se entra pulsando la tecla `v`. Es como seleccionar texto con el cursor, solo que podremos escribir comandos para manipularlo. 26 | 27 | **Modo selección**. 28 | Se entra desde el modo visual pulsando `Ctrl-G`. Tiene un comportamiento similar al modo visual solo que al escribir no realizaremos comandos sino que reemplazaremos el texto, como en un editor de texto normal, 29 | 30 | **Modo Ex**. 31 | Este modo se asemeja al modo de comandos, con la diferencia de que tras la ejecución de una orden no se vuelve al modo normal. Se entra pulsando `Q` y se sale con `vi`. 32 | 33 | ## Vim es como un lenguaje 34 | 35 | Usar Vim es una experiencia completamente distinta a usar cualquier otro editor de código. Vamos a hacer una breve desmostración. **Se utiliza una sintaxis de** `verbo-modificador-objeto`. Empezaremos en el modo normal, pulsaremos `i` para introducir unos cuantos párrafos de texto, pulsaremos `Esc` para volver al modo normal y aquí empieza la magia. **No os procupéis, iremos mirando cada uno de ellos detalle en siguientes posts, pero podéis ir echándoles un vistazo**. 36 | 37 | **Aprende algunos verbos**: **v** (visual), **c** (change/cambiar), **d** (delete/borrar), **y** (yank/copiar). 38 | 39 | **Aprende algunos modificadores**: **i** (inside/dentro de), **a** (around/alrededor), **t** (till../hasta que encuentra el carácter), **f** (find../hasta que encuentra el carácter incluyéndolo), **/** (buscar). 40 | 41 | **Aprende algunos objetos**: **w** (word/palabra), **s** (sentence/frase) **p** (paragraph/párrafo) **b** (block/parentesis), **t** (tag/ para html/xml). 42 | 43 | ## Hablemos Vim 44 | 45 | **Ahora que estamos en el modo normal podemos hablar Vim (no se pulsa todo a la vez, se hace letra a letra)**: 46 | >Elimina la palabra donde esté el cursor: **diw** (delete inside word)
47 | Cambia la frase en la que estés: **cis** (change inside sentence)
48 | Cambia lo que haya dentro de las comillas: **ci”** (change inside quote)
49 | Cambia lo que haya hasta ‘foo’: **c/foo** (change search foo)
50 | Cambia todo lo que haya hasta la letra X: **ctX**
51 | Selecciona un párrafo: **vap** (visual around paragraph) 52 | 53 | Con esto tenéis material para ir probando Vim esta semana. **En los siguientes post de esta serie nos iremos deteniendo en profundidad por cada modo** y veremos con detalle lo que podremos hacer en cada uno. Hemos acabado la teoría para entender Vim, lo siguiente será todo práctica. **¿Qué os ha parecido Vim?** 54 | -------------------------------------------------------------------------------- /capitulos/vim11.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 11 - 2 | 3 | Bienvenido a la onceava entrega del curso sobre cómo usar Vim, el editor de código modal productivo. Esta semana aprenderemos a usar los registros de Vim. 4 | 5 | Cómo usar Vim desde cero: 10 - Moverse por el archivo 2 6 | 7 | cómo usar Vim 8 | 9 | En el post de esta semana vamos a hablar sobre una de las funciones que es vital entender en [Vim](http://bitelia.com/tag/vim), los registros. Lo primero que debemos tener claro es que **un registro es un contenedor que guarda texto**. De la misma forma que usamos el portapapeles del sistema para copiar, pegar y cortar texto aunque también se puede utilizar como macro, para guardar comandos. Hoy veremos como funcionan estos registros para las acciones del portapapeles, la semana que viene iremos con las macros. 10 | 11 | En Vim, a diferencia de otros [editores de código](http://bitelia.com/2014/09/editores-codigo-mas-versatiles) más convencionales, **tendremos varias casillas en nuestro portapapeles para guardar el texto. A esas diferentes casillas las llamaremos registros** y por defecto, determinadas acciones guardarán el texto en un registro determinado. Ahora veremos unos ejemplos para poder sacarle el máximo partido y no confundirnos. 12 | 13 | ## Eliminar (delete), copiar (yank) y pegar (put) 14 | 15 | Se que no es la traducción exacta en español pero es la manera más sencilla de entender lo que hacen estos [comandos](http://bitelia.com/2014/07/comandos-basicos-terminal-parte-iii). **Cuando borramos algo, se guarda en el registro sin nombre**. Por ejemplo si nos colocamos : 16 | 17 | var a = [;]2 // colocamos el cursor sobre sobre ; 18 | var a = [2] // pulsamos X para borrar ; 19 | var a = 2[;] // pulsamos p para pegar ; 20 |
21 | 22 | ¿Qué acaba de pasar? El comando `delete` de Vim hace lo mismo que el comando cortar, es decir, si borramos algo de forma automática se guarda en el registro si nombre. **Por lo tanto debemos tener cuidado con el típico problema que tendremos con los registros, fastidiar el contenido del registro**. Supongamos que queremos cambiar el orden de las palabras `dos` y `uno` en la siguiente línea. Intuitivamente cometeríamos el siguiente error: 23 | 24 | resultado("[d]os", "uno"); // nos situaríamos sobre "dos" 25 | resultado("[d]os", "uno"); // copiaríamos con yi" 26 | resultado("dos", "[u]no"); // nos situaríamos sobre "uno" 27 | resultado("dos", "["]); // borraríamos con di" 28 | // ahora viene el error 29 | resultado("dos", ["]uno"); // a la izquierda con h, pegamos con p 30 |
31 | 32 | ¿Qué acaba de pasar? Hemos vuelto a copiar lo mismo, el registro se ha sobreescrito con lo que hemos [borrado](http://bitelia.com/2013/06/borrado-seguro-de-archivos-windows). 33 | 34 | ## Los registros de Vim 35 | 36 | Acceder a los registros de Vim es sencillo, solamente hay que especificarlos con `"{registro}`. En el ejemplo anterior hemos visto como Vim con el comando `delete` guarda lo borrado en el registro sin nombre, al que se accede con `""`. Imaginemos que queremos copiar algo al registro llamado `a`, lo haríamos con el comando `"ayiw` (copiar una palabra al registro *a*). O imaginemos que queremos pegar algo del registro *b*, lo haremos con el comando `"bp`. **Si no especificamos el registro a usar Vim simplemente usará el registro sin nombre**. Por lo tanto, fastidiar nuestro registro es muy sencillo y nos puede traer problemas, aquí es cuando es necesario saberse bien la teoría. Ahora veremos cómo solucionar el error. 37 | 38 | Es importantísimo saber que **el comando `yank` no solo copia al registro sin nombre, si no que también copia al registro *0***. Por lo tanto si en el último comando donde cometimos el error hubiéramos hecho lo siguiente: 39 | 40 | // ahora viene el error -> corregido 41 | resultado("dos", ["]dos"); // a la izquierda con h, pegamos con "0p 42 |
43 | 44 | Al pegar con `"0p` hemos pegado el contenido del registro *0* que se ha guardado con el comando `yank`. **Otra opción sería no borrar la palabra `uno`, sino seleccionarla con `ve`** y pegar nuestro texto con `p`. Mucho más fácil ya que no tendremos que andar pensando en los registros, pero para esta guía había que explicar con el anterior ejemplo como funcionan los registros. 45 | 46 | ## Otros registros 47 | 48 | Aparte del registro sin nombre y los que creemos nosotros, hay mas registros que tenemos que conocer. 49 | 50 | + `"_` **el registro *agujero negro***. Es un registro que no guarda texto, útil si queremos borrar algo `"d{motion}` sin que se sobreesriba la [copia](http://bitelia.com/2014/03/copias-seguridad-importancia) que tenemos en el registro sin nombre. 51 | + `"+` / `"*` **el portapapeles del sistema**. Importantísmo. Gracias a este registro podremos copiar al portapapeles del sistema y pegar texto externo en Vim. 52 | + Como siempre para saber más de los registros **os dejo el comando de ayuda `:h registers`**, hay muchísima información y se habla de muchos más registros. Pero nosotros, para un primer contacto con estos nos sobra. 53 | 54 | 55 | ## Posts anteriores sobre cómo usar Vim 56 | 57 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 58 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 59 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 60 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 61 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 62 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 63 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 64 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 65 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 66 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 67 | 68 | -------------------------------------------------------------------------------- /capitulos/vim14.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 14 - Sustituciones 2 | 3 | En el [anterior post](http://bitelia.com/2014/12/como-usar-vim-13) estuvimos hablando acerca de la elaboración de patrones de búsqueda. Hoy, **vamos a utilizar lo aprendido anteriormente para entender el funcionamiento de uno de los comandos *Ex* más poderosos que encontraremos en Vim, las sustituciones**. Hablaremos de los diferentes modos de sustitución y de ciertos aspectos que debemos tener en cuenta para sacar el mejor provecho a este [comando](http://bitelia.com/tag/comandos), además de algunos trucos útiles como por ejemplo reusar los patrones de búsqueda anteriores para no tener que repetir las búsquedas o que Vim nos pida confirmación por cada encuentro. Los más avanzados también podrán usar scripts de Vim en las sustituciones con las que incluso se pueden realizar operaciones aritméticas, pero enseñar el lenguaje de Vim queda por encima del objetivo de este curso. 4 | 5 | ## El comando sustituir 6 | 7 | El comando `:substitute` es un comando que puede parecer más complejo que el típico `ctrl+f` de otros [editores de código](http://bitelia.com/tag/editor-de-texto), **le proporcionaremos un patrón de búsqueda y después el texto que queramos sustituir**. Su complejidad radica en las múltiples opciones que cambiarán el comportamiento de este comando, esas opciones son llamadas *flags*. El comando sustituir tiene la siguiente estructura: 8 | 9 | `:[range]s[ubstitute]/{pattern}/{string}/[flags]` 10 | 11 | Estas son unas cuantas flags útiles (para más información consultad `:h :s_flags`): 12 | 13 | + `g`: hace que el comado de sustitución **actúe de forma global**, cambiando cada patrón que encuentre en una línea en lugar de cambiar únicamente el primero. 14 | + `c`: nos da la oportunidad de **confirmar los cambios**, para mí es una de las más útiles. 15 | + `n`: suprime el comportamiento habitual del comando sustituir, **nos informa del número de casos que se verían afectados** si ejecutásemos el comando. 16 | + `&`: esta flag le indica al comando sustituir que **reutilice las flags del comando anterior**. 17 | 18 | Es importante saber los **carácteres especiales que podemos usar** como reemplazo (para más info consultad `:h sub-replace-special`): 19 | 20 | + `\r`: inserta un retorno de carro (en palabras llanas, un *enter*). 21 | + `\t`: inserta una tabulación. 22 | + `\\`: inserta un `\`, como es un carácter que se usa como especial necesita estar precedido de un `\`. 23 | + `\1`: inserta el primer *submatch* (lo veremos en acción enseguida). 24 | + `\2`: inserta el segundo *submatch*, y así sucesivamente. 25 | + `\0`: inserta el patrón de búsqueda completo. 26 | + `&`: inserta el patrón de búsqueda completo. 27 | + `~`: usa el `{string}` de comando de sustitución anterior. 28 | + `\={Vim Script}`: evalua una expresión {Vim script} y usa el resultado como el `{string}` a reemplazar. 29 | 30 | ## Empecemos con la práctica 31 | 32 | La mejor forma para entender el funcionamiento del comando de sustitución es fijarnos en estas sencillas líneas: 33 | 34 | `[L]ínea 1 - Madrid, Madrid.` (`[]` -> nuestra posición) 35 | `Línea 2 - Madrid, Madrid.` 36 | 37 | **Supongamos que queremos sustituir la palabra *Madrid* por cualquier otra de nuestra elección**. Dependiendo de las flags que usemos obtendremos diferente resultado. 38 | 39 | + `s/Madrid/Bilbao`: sustiuirá **el primer Madrid** de la primera línea. 40 | + `s/Madrid/Bilbao/g`: sustiruitá **todos** los Madrid **de la primera línea**. 41 | + `%s/Madrid/Bilbao/`: sustituirá **el primer Madrid de todas las líneas** del archivo. 42 | + `%s/Madrid/Bilbao/g`: sustituirá **todos** los Madrid del archivo. 43 | + `%s/Madrid/Bilbao/gc`: nos pedirá **confirmación** para sustituir cada Madrid. Podemos contestar: `y` sí, `n` no, `q` (quit) terminar de sustituir, `l` (last) sustituir este y dejar de sustituir, `a` (all) todos, `Ctrl+e` mover la pantalla hacia arriba o `Ctrl+y` mover la pantalla hacia abajo. 44 | + Supongamos que se nos ha olvidado indicar con `%` que queríamos ejecutar el comando en todo el archivo. No hay problema, podemos usar `g&` que es equivalente a `:%s//~/&`. 45 | 46 | ## Trucos útiles 47 | 48 | **Es común dividir el patrón de la sustitución**, ya que normalmente, si usamos expresiones regulares suele llevarnos más de un intento elaborar correctamente la que queremos. Tomando como ejemplo la búsqueda de colores hexadecimales del post anterior, podríamos dividir el proceso de esta manera: 49 | 50 | 1. `\v#(\x{6}|\x{3})` Es el primer paso, para encontrar lo que queremos. 51 | 2. `%s//#FFFFFF/gc` Como podéis ver, si no indicamos nada en el patrón utiliza el de la búsqueda anterior, pero si aún así queréis escribirlo podéis pegar la búsqueda anterior ejecutando `:%s/Control+r//#FFFFFF/gc`. La primera forma es menos intimidante que escribir `%s/\v#(\x{6}|\x{3})/#FFFFFF/gc`. También podemos indicar el contenido de otros registros con `\=@0` por ejemplo, que pegará el contenido del registro del *yank* mientras que `@"` lo hará del registro por defecto. 52 | 53 | Supongamos que tenemos un archivo *CSV* con una estructura de `apellido,nombre,email` por cada línea y **nuestro objetivo es reordenar las columnas de forma que nos queden en orden contrario** `email,nombre,apellido`. Podríamos utilizar los *submatch* mencionados anteriormente: 54 | 55 | 1. `/\v^([^,]*),([^,]*),([^,]*)$` 56 | 2. `:%s//\3,\2,\1` 57 | 58 | Hay muchos apartados que se podrían cubrir en detalle, pero **aquí tenéis una buena introducción a las bondades de este comando** en este [curso de Vim](http://bitelia.com/tag/curso-de-vim). Aprender a elaborar expresiones regulares es muy útil y combinado con el poder de este editor nos hará muy productivos. 59 | 60 | ## Posts anteriores sobre cómo usar Vim 61 | 62 | [1: Introducción a Vim](http://bitelia.com/2014/09/como-usar-vim-1-introduccion-a-vim) 63 | [2: Editar al estilo Vim](http://bitelia.com/2014/09/como-usar-vim-cero-2) 64 | [3: El modo normal](http://bitelia.com/2014/09/como-usar-vim-3) 65 | [4: El modo insertar](http://bitelia.com/2014/10/como-usar-vim-4) 66 | [5: El modo visual](http://bitelia.com/2014/10/como-usar-vim-5) 67 | [6: El modo de comandos](http://bitelia.com/2014/10/como-usar-vim-6) 68 | [7: Editar múltiples archivos](http://bitelia.com/2014/10/como-usar-vim-7) 69 | [8: Paneles y pestañas](http://bitelia.com/2014/11/como-usar-vim-8) 70 | [9: Cómo moverse rápido por los archivos](http://bitelia.com/2014/11/como-usar-vim-9) 71 | [10: Cómo moverse rápido por los archivos 2](http://bitelia.com/2014/11/como-usar-vim-10) 72 | [11: Dominar los registros](http://bitelia.com/2014/11/como-usar-vim-11) 73 | [12: El poder de las macros](http://bitelia.com/2014/12/como-usar-vim) 74 | [13: Patrones](http://bitelia.com/2014/12/como-usar-vim-13) -------------------------------------------------------------------------------- /capitulos/vim5.md: -------------------------------------------------------------------------------- 1 | # Aprende a usar Vim desde cero: 5 – El modo visual 2 | 3 | Hemos llegado al quinto post sobre cómo usar Vim, nuestro editor modal de código favorito. Llevamos más de un mes hablando de este editor y de las cosas magníficas que podemos hacer con él. Nos quedan muchos temas por tratar, pero **a lo que modos de Vim se refiere solo nos queda comentar el modo visual y el modo de la línea de comandos**. Cuando acabemos con ellos, empezaremos a mirar cómo podemos manejar múltiples archivos a la vez. 4 | 5 | Conozcamos **el modo visual**, un modo que se asemeja a la selección de texto en otros editores de código. Normalmente, seleccionaríamos el texto y lo copiaríamos, pegaríamos o lo sustituiríamos, pero el enfoque que toma Vim es un poco diferente. **Seleccionaremos texto y ejecutaremos acciones sobre él**. Lo más importante que hay que saber sobre el modo visual es que **Vim tiene tres variantes de este modo**. Uno que selecciona por caracteres y palabras, otro que selecciona líneas completas y por último uno que selecciona bloques rectangulares de texto. 6 | 7 | ## Domina el modo visual 8 | 9 | **Para entrar al modo visual pulsaremos desde el modo normal la tecla** `v`. Si utilizamos las teclas de dirección seremos capaces de aumentar o disminuir la longitud de nuestra selección. Mientras estamos en el modo visual la tecla o cambia la dirección por la que modificamos la extensión de nuestra selección. 10 | 11 | Como en todos los modos de Vim, tendremos diferentes teclas que ejecutarán diversas funciones. Hay varias que tienen la misma función como las teclas de dirección, el comando `f{letra}` que nos llevará hacia la primera letra que contenga nuestra búsqueda (podremos usar `;` o `,` para repetir la búsqueda). También hará lo mismo el comando `c`, con el que borraremos la selección y entraremos directos al modo insertar parar hacer los cambios necesarios. También seremos capaces de hablar Vim con comandos como `vi)` o `viw`. 12 | 13 | **Podemos entrar al modo visual-lineal con el comando** `V`, ejecutándolo desde el modo normal. Este es un modo que nos sirve para seleccionar líneas completas y ejecutar comandos sobre ellas. Por último, tenemos **el modo visual-bloque, el cual se activa con la combinación** `Ctrl-v` y sirve para seleccionar columnas, dejándonos con una selección con forma de tetraedro en el texto. 14 | 15 | ## Veamos unos ejemplos prácticos de cómo usar el modo Visual 16 | 17 | **Usa el modo visual para editar la capitalización de las palabras** 18 | 19 | Una de las situaciones en las que nos veremos con frecuencia será la de **editar el texto para ponerlo en mayúsculas o minúsculas**. En el siguiente ejemplo usaremos vit desde el principio de la línea para seleccionar directamente el texto dentro de los tags. Una vez seleccionado podemos **convertir el texto a mayúsculas** usando la tecla `U`. Para el **efecto contrario** usaremos `u` o `~` que cambia las mayúsculas a minúsculas y al contrario. En este caso la idea es poner en mayúsculas la palabra inicio, probadlo y veréis como se capitaliza con cualquiera de los dos comandos que describe la imagen. 20 | 21 | **Usa el modo visual lineal para indentar el texto** 22 | 23 | El ejemplo más típico que podíamos ver es el de la indentación de texto, algo que hacemos de forma regular cuando editamos código. Mediante el modo visual-lineal seleccionaremos las líneas que queremos indentar y después ejecutaremos el **comando de indentación** `>` o `<`, el cual, también funciona en el modo normal. 24 | 25 | **Usa el modo visual-bloque para la maquetación de tablas** 26 | 27 | Este es un ejemplo un poco más complejo pero de gran utilidad. Saber realizar este último apartado nos va a ayudar a entender cómo funciona este modo y seremos capaces de aplicarlo en otras situaciones que se nos ocurran. El ejemplo que muestro es la maquetación de una tabla. **Eliminamos espacios que sobran y los sustituimos por un borde** hecho con |. Por último copiamos una línea y la sustituimos por - para **crear un borde superior**. Parece mucho pero una vez entendido se hace en pocos segundos. 28 | 29 | `set nocompatible` 30 | 31 | `filetype` 32 | 33 | `plugin on` 34 | 35 | `syntax on` 36 | 37 | | Comandos | Contenido del buffer | 38 | |---|---| 39 | | {posición inicial} | `L`ínea uno | 40 | | x | `í`nea uno | 41 | | . | `n`ea uno | 42 | 43 | El comando `dd`, sirve para eliminar una línea. Si después usamos el comando punto, eliminaremos otra línea. De forma que si nos movemos por el documento **podremos eliminar líneas completas solamente pulsando el comando punto**, ¿bastante cómodo verdad? 44 | 45 | ## Muévete en Vim como en un teclado español 46 | 47 | Vim por defecto, nos tiene acostumbrados a movernos por el archivo con las teclas **hjkl**, pero en un teclado español nosotros ponemos los dedos sobre **jklñ**. Por lo tanto, he decidido que para mí es más cómodo cambiar esas teclas, de tal forma que siempre tendré mis dedos en la posición del teclado español. Para ello he añadido esto a mi `.vimrc`. 48 | 49 | teclas de dirección en el modo normal como en el teclado español 50 | 51 | `nnoremap j h` `nnoremap k j` `nnoremap l k` `nnoremap ñ l` 52 | 53 | teclas para movernos por paneles como en el teclado español 54 | 55 | `nnoremap j h` `nnoremap k j` `nnoremap l k` `nnoremap ñ l` `nnoremap J H` `nnoremap K J` `nnoremap L K` `nnoremap Ñ L` 56 | 57 | teclas para cambiar de línea en frases largas como en un teclado español 58 | 59 | `nnoremap gk gj` `nnoremap gl gk` 60 | 61 | teclas para el modo visual como en el teclado español 62 | 63 | `vnoremap j h` `vnoremap k j` `vnoremap l k` `vnoremap ñ l` 64 | 65 | ## Casos prácticos 66 | 67 | Podemos **indentar un archivo** con `>>`, de esta forma, si queremos continuar indentando más líneas solo tendremos que movernos a ellas y pulsar el comando punto. No importa en que lugar de la línea estemos, podemos indentar aunque estemos a final de la frase, pulsando el punto. 68 | 69 | | Comandos | Contenido del buffer | 70 | |---|---| 71 | |{posición inicial}|`L`ínea uno| 72 | | |Línea dos| 73 | | | Línea tres| 74 | |k>>|Línea uno| 75 | | |      `L`ínea dos| 76 | | | Línea tres| 77 | 78 | **Un error habitual cuando editamos JavaScript es olvidarnos del ; final** de algunas líneas de código. Si nos hemos olvidado de ello en varias líneas, el comando punto también nos puede ayudar. La tecla `$` lleva a nuestro cursor al final de la línea y la tecla `a`, nos cambia al modo insertar en un carácter siguiente de donde tenemos el cursor. Sin embargo, **la misma funcionalidad se puede conseguir simplemente pulsando `A`**. 79 | 80 | | Comandos | Contenidos del buffer | 81 | |---|---| 82 | |{Posición inicia}|`v`ar foo = 1| 83 | |A;| var foo = 1`;` 84 | 85 | Después, saldremos del modo insertar al normal pulsando la tecla ``. Ahora, si tenemos más líneas a las que les falten el `;` simplemente con pulsar el comando `.` se añadirá, sin importar la posición de la frase en la que estemos. **Como podéis ver, el comando `.` es todoterreno y nos ayudará a hacer las cosas mucho más rápido que manualmente**. 86 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Curso-de-vim by AnderRasoVazquez 7 | 8 | 9 | 10 | 11 | 14 | 15 | 16 | 17 | 18 | 19 |
20 |

Aprende a usar Vim desde 0

21 |

El curso de habla hispana definitivo para aprender a usar este editor de código

22 |
23 | 24 | 36 | 37 |
38 | 41 |
42 |
43 | 44 | 45 | 46 | 47 |
48 |
49 |

Bienvenido a Aprende a usar Vim desde 0

50 | 51 |

52 | 53 | 54 | 
"Vim es un editor de código que requiere una curva de
 55 | aprendizaje, te sentirás muy lento las primeras veces que lo uses,
 56 | pero llega un momento en el que algo hace clic,
 57 | y empiezas a editar código tan rápido que parece imposible."
 58 |
59 | 60 |

Este curso tenía pensado ser simplemente una guía de iniciación al editor de código Vim, pero cada vez que encontraba algo nuevo o interesante sobre este magnífico programa lo he ido añadiendo y finalmente, lo que en un principio iban a ser simplemente un par de artículos, han acabado por convertirse en un verdadero curso completo de 16 capítulos. He pasado meses disfrutando mientras escribía este curso, hicieron falta muchísimas horas (y muchos cafés) para buscar información útil y organizarla a conciencia para que pudiera ser comprendida de la forma más sencilla posible. Creo sinceramente que aprender a usar Vim es una de las decisiones que más tiempo le puede ahorrar a la larga a cualquiera que esté interesado en la programación. Esa es la razón por la que he dedicado tanto tiempo a compartir las bondades de este editor.

61 | 62 |

Cuando descubrí Vim, no había una fuente de información en el idioma español con la que empezar y adquirir una destreza significativa. Es cierto que si buscamos encontraremos muchos artículos sobre este programa, pero no suelen pasar de una breve introducción. Creo que con este curso hemos logrado que toda persona interesada en aprender un poquito de este editor tenga un punto inicial de referencia por donde empezar. Todavía queda muchísimo por hacer y esa es la razón por la que este curso va a seguir desarrollándose en GitHub.

63 | 64 |

Estado actual del proyecto

65 | 66 |

2015-02-09

67 | 68 |

Hasta el momento tenemos 16 entregas:

69 | 70 |
    71 |
  1. Introducción a Vim
    2. 72 |
  2. Editar al estilo Vim
    3. 73 |
  3. El modo normal
    4. 74 |
  4. El modo insertar
    5. 75 |
  5. El modo visual
    6. 76 |
  6. El modo de comandos
    7. 77 |
  7. Editar múltiples archivos
    8. 78 |
  8. Paneles y pestañas
    9. 79 |
  9. Cómo moverse rápido por los archivos
    10. 80 |
  10. Cómo moverse rápido por los archivos 2
    11. 81 |
  11. Dominar los registros
    12. 82 |
  12. El poder de las macros
    13. 83 |
  13. Patrones
    14. 84 |
  14. Sustituciones
    15. 85 |
  15. Comandos globales
    16. 86 |
  16. Autocompletado
    17. 87 |
88 | 89 |

Tareas pendientes

90 | 91 |
    92 |
  • Terminar la migración de Bitelia a este repositorio (blog donde se inició esta guía) y en formato Markdown para que sea sencillo contribuir para todos. (12/16)
    • 93 |
  • Pasar la guía a formato PDF, en este momento está en Markdown.
    • 94 |
95 | 96 |

Créditos y contribuidores

97 | 98 |
    99 |
  • Vimcasts: una página web que muestra vídeos gratuitos de lo que podemos hacer con Vim y donde tienen publicaciones interesantes.
    • 100 |
  • La comunidad Vim de Google+: la gente comparte las cosas interesantes que encuentra, muchas de ellas han sido material para estos artículos.
    • 101 |
  • La wiki de Vim: ha sido un buen recurso para consultar dudas.
    • 102 |
  • Todos esos blogs de Internet que me descubrieron Vim y que me han enseñado trucos geniales para compartir aquí.
    • 103 |
  • Y a todos vosotros que habéis seguido el curso hasta ahora, muchas gracias.
    • 104 |
105 | 106 |

Soporte y contacto

107 | 108 |

Podéis contactar conmigo enviándome un correo a la dirección anderraso@gmail.com

Este proyecto es y siempre será gratuito, pero si te ha servido y te gustaría que lo siguiera desarrollando puedes hacer un donativo mediante el siguiente botón: 109 | 110 |

Ahora que el curso ha adquiridoi un volumen considerable, mi objetivo es abrirlo para que toda persona interesada en él pueda colaborar. Esa es la razón por la que he decidido alojar este curso en GitHubi. La idea es seguir sacando entregas en este repositorio y que la gente proponga mejoras o destaque fallos, con el objetivo de hacer el mejor curso de Vim de habla hispana posible. Pienso que la educación y todo material de aprendizaje deberían ser siempre gratuitos y accesibles a todo el mundo. Por eso, el curso de Vim es y siempre será gratuito, estudiaré las licencias libres que se puedan usar para que todo el mundo pueda compartirlo sin condiciones. Quizá en un futuro podamos hacer un ebook de aspecto profesional si recaudamos los suficientes fondos, pero la información contenida en él siempre podrá ser accesible vía GitHub.

111 | 112 |

En definitiva, si el curso te ha parecido útil y te gustaría dar tu apoyo a este proyecto de educación libre invitándome a un café, puedes hacerlo desde el siguiente botón. Toda contribución será bienvenida sin importar su importe y servirá para mantener este curso actualizado.

113 | 114 |
115 | 116 | 117 | 118 | 119 |
120 | 121 | 122 |
123 | 127 |
128 | 129 | 130 | 131 | 132 | --------------------------------------------------------------------------------