Hlavní navigace

Textový editor Vim jako IDE (7.část – Vim Script)

Pavel Tišnovský 11. 8. 2011

V předchozí části seriálu o textovém editoru Vim ve funkci vývojového prostředí jsme si řekli o interním programovacím jazyku Vim Script, který byl do Vimu přidán v roce 1998. Dnes budeme v popisu jazyka pokračovat, protože se budeme zabývat strukturovanými příkazy a zpracováním výjimek.

Obsah

1. Základní řídicí příkazy – podmínky

2. Programová smyčka typu while

3. Programová smyčka typu foreach při práci se seznamy (list)

4. Seznamy seznamů – jeden ze způsobů reprezentace matic

5. Programová smyčka typu foreach při práci se slovníky (dictionary)

6. Jak lze ve Vim Scriptu elegantně vytvořit počítané programové smyčky?

7. Zpracování výjimek

8. Ukázka využití bloku try-catch-endcatch

9. Odkazy na Internetu

1. Základní řídicí příkazy – podmínky

V šesté části seriálu o využití textového editoru Vim ve funkci vývojového prostředí jsme si řekli základní informace o Vim Scriptu, tj. o interním skriptovacím jazyce, v němž je možné psát jak jednoduché pomocné funkce, tak i poměrně složité moduly typu JavaBrowser či NERD tree. Víme již, že ve skriptech je možné používat číselné hodnoty či řetězce a taktéž je možné využívat seznamy (list) a slovníky (dictionary). Taktéž jsme si řekli, že před jména proměnných lze zapisovat prefixy, pomocí nichž se rozlišují lokální proměnné, globální proměnné, proměnné vztažené k editovanému bufferu atd. Pomocí dalších prefixů lze přistupovat k takzvaným pseudoproměnným, například ke konfiguračním parametrům či proměnným prostředí (shellu). Ovšem prozatím jsme se neseznámili s tím, jakým způsobem je možné řídit běh programu, tj. jak lze tvořit větvení a programové smyčky.

Pro větvení se využívá, tak jako v naprosté většině dalších imperativních programovacích jazyků, příkaz if s ukončujícím příkazem endif. Kromě toho lze použít i nepovinnou větev else, popř. větev else s podmínkou, pro niž se používá klíčové slovo elseif. Syntaxe zápisu všech možností vypadá následovně:

if podmínka
    blok spuštěný při splnění podmínky
endif
if podmínka
    blok spuštěný při splnění podmínky
else
    blok spuštěný při nesplnění podmínky
endif
if podmínka
    blok spuštěný při splnění první podmínky
elseif podmínka
    blok spuštěný při splnění druhé podmínky
elseif podmínka
    blok spuštěný při splnění třetí podmínky
else
    blok spuštěný při nesplnění žádné podmínky
endif

Obrázek 1: Příklad použití příkazů if v souboru .vimrc, který je automaticky načítán při spouštění Vimu. V zobrazeném zdrojovém kódu je na základě obsahu globální proměnné resolution provedeno nastavení počtu zobrazených sloupců a řádků.

Ukažme si nyní základní využití příkazu if. Většina skriptů nebo doplňkových modulů (plugins) nemusí pracovat korektně v tom případě, když je nastaven režim kompatibility s původním textovým editorem vi. Do tohoto režimu se Vim může dostat například tehdy, pokud je spuštěn příkazem vi (zde ovšem záleží na konkrétní konfiguraci systému) nebo tehdy, když je použita volba:

:set compatible

Obrázek 2: Na začátku tohoto skriptu je proveden test, zda se textový editor Vim nenachází v režimu kompatibility s původním textovým editorem „vi“. V režimu kompatibility není možné provádět velké množství užitečných operací.

V režimu kompatibility přestane pracovat velká část zajímavých a užitečných funkcí Vimu (ostatně si to sami můžete vyzkoušet), proto mnohé skripty a zásuvné moduly na začátku svého běhu testují, zda je režim kompatibility nastaven a pokud tomu tak skutečně je, tak napíšou chybovou zprávu a skončí běh skriptu pomocí řídicího příkazu finish. U mnoha skriptů tedy můžeme na jejich začátku nalézt následující kód:

if &compatible
    echo "Tento skript nebude pracovat v rezimu kompatibility"
    finish
endif

Připomeňme si, že prefixem & začíná jméno pseudoproměnné obsahující hodnotu stejně pojmenovaného konfiguračního parametru. Výše uvedený příklad skutečně pracuje, ovšem korektnější je, aby skript vypisovat chybová hlášení pouze v případě, kdy je nastaven konfigurační parametr verbose. U „slušných“ skriptů respektujících uživatelské nastavení textového editoru Vim tedy můžeme nalézt dvojici do sebe vnořených podmínek:

if &compatible
    if &verbose
        echo "Tento skript nebude pracovat v rezimu kompatibility"
    endif
    finish
endif

2. Programová smyčka typu while

Kromě větvení běhu programu na základě nějaké podmínky je mnohdy nutné provádět určitou část kódu opakovaně. Může se například jednat o kód, který prochází všemi editovanými buffery, popř. prochází položkami seznamu či dvojicemi klíč-hodnota uloženými ve slovníku. Pro tyto účely jsou ve Vimu k dispozici dva typy smyček. První smyčkou – tou zcela základní, na níž lze postavit jakýkoli algoritmus – je smyčka typu while, která začíná příkazem while společně s podmínkou a blokem programového kódu a končí příkazem endwhile. Podmínkou může být jakýkoli výraz, který se vyhodnotí na pravdu či nepravdu. Pokud se výraz vyhodnotí na pravdu (nenulová hodnota), je provedeno tělo smyčky, tj. jedna iterace a řízení se posléze vrátí zpět na vyhodnocení podmínky. Pokud se naopak výraz vyhodnotí na nepravdu, je řízení ihned přesunuto za tělo smyčky, což mj. znamená, že se programová smyčka typu while ve skutečnosti nemusí provést ani jednou:

while podmínka
    blok kódu
endwhile

Obrázek 3: Použití programových smyček typu while v modulu justify.vim, který je dodáván společně se samotným Vimem.

Ukažme si velmi jednoduchý ilustrační příklad, v němž je programová smyčka typu while použita ve funkci počítané smyčky, kterou Vim Script ve skutečnosti neobsahuje (i když ji lze částečně nahradit, jak si řekneme v páté kapitole):

let i = 1
while i <= 10
    echo "aktualni hodnota pocitadla: " . i
    let i = i + 1
endwhile

Pokud si tento příklad uložíte do samostatného souboru while.vim, postačuje tento soubor otevřít ve Vimu a v příkazovém režimu napsat následující příkaz:

:source %

popř.:

:so %

Obrázek 4: Ukázka běhu demonstračního příkladu využívajícího programovou smyčku typu while.

Ve druhém demonstračním příkladu je ukázána jednoduchá manipulace s řetězcem – postupné odstraňování prvního znaku z řetězce s využitím operace substring, kterou lze zapsat pomocí konstrukce [ start : end ]:

let str = "http://www.root.cz"
while str != ""
    echo str
    let str = str[1 : strlen(str) - 1]
endwhile

Podobně jako v dalších programovacích jazycích, i ve Vimu je možné ovlivnit smyčku while dvojicí příkazů breakcontinue. První z těchto příkazů ihned ukončí běh smyčky, přičemž běh programu bude pokračovat na prvním příkazu uvedeným za smyčkou. Naproti tomu příkaz continue vrátí běh programu na podmínku testovanou před prvním provedením těla smyčky. Příkaz break je použit v následujícím příkladu pro ukončení programové smyčky v případě, že testovaný řetězec začíná znaky „root“. Již v předchozí části tohoto seriálu jsme si řekli, že pomocí operátoru =~ je možné zapsat test na to, zda obsah nějakého řetězce (popř. proměnné obsahující řetězec) odpovídá zadanému regulárnímu výrazu:

let str = "http://www.root.cz"
while str != ""
    echo str
    if str =~ "^root.*"
        break
    endif
    let str = str[1 : strlen(str) - 1]
endwhile

3. Programová smyčka typu foreach při práci se seznamy (list)

Již v předchozí části tohoto seriálu jsme si řekli, že ve Vim Scriptu je od verze Vim 7.0 podporován i datový typ seznam (list). Připomeňme si, že seznam lze vytvořit pomocí takzvaného konstruktoru, který může mít následující podobu:

:let seznam1=[1, 2, 3, 4]

Se seznamem je možné pracovat jako s celkem:

:echo seznam1
[1, 2, 3, 4]

popř. lze přistupovat k jednotlivým prvkům seznamu:

:let prvni=seznam1[0]
:echo prvni
:let seznam1[1]="pokus"
:echo seznam1

Obrázek 5: Zdrojový kód demonstračního příkladu uvedeného v předchozí kapitole.

Velmi často je nutné postupně procházet všemi prvky seznamu a provádět s nimi nějakou operaci, například hodnoty prvků postupně předávat do nějaké funkce. Pro tuto činnost lze samozřejmě použít v předchozí kapitole popsanou programovou smyčku typu while, pomocí níž se bude postupně zvyšovat hodnota pomocné numerické proměnné (počitadla) takovým způsobem, aby se postupně prošlo indexy všech prvků v seznamu. Základní podoba této smyčky může vypadat následovně:

let seznam1=[1,2,3,4,5]
let i=0
while i < 5
    echo seznam1[i]
    let i = i + 1
endwhile

Ovšem jednodušší je použít namísto magické konstanty 5 funkci len(), popř. lze navíc pro přístup k prvkům seznamu používat funkci get:

let seznam1=[1,2,3,4,5]
let i=0
while i < len(seznam1)
    echo get(seznam1, i)
    let i = i + 1
endwhile

Ani to však není nejlepší řešení, protože se musí relativně složitě pracovat s čítačem smyčky, explicitně přistupovat ke každému prvku seznamu apod. Textový editor Vim zde nabízí mnohem lepší řešení, které je používáno i v mnoha dalších vyšších programovacích jazycích. Jedná se o smyčku typu foreach, která automaticky projde všemi prvky seznamu, a to ve správném pořadí. I když se pro zápis této smyčky používá klíčové slovo for, je význam smyčky odlišný od podobně nazvaných C-čkovských smyček. Výše uvedená smyčka while – endwhile se tedy může přepsat následovně:

let seznam1=[1,2,3,4,5]
for item in seznam1
    echo item
endfor

Obrázek 6: Příklad použití smyčky typu foreach v reálném skriptu.

4. Seznamy seznamů – jeden ze způsobů reprezentace matic

Můžeme si také vyzkoušet složitější příklad, v němž se seznam používá pro reprezentaci matice (přesněji řečeno seznamu seznamů). Tento příklad po svém spuštění uloží do registru nazvaného " text obsahující matici, jejíž prvky mají dvojnásobnou hodnotu, než odpovídající prvky z původní matice:

let matrix = [ [1,2,3], [4,5,6], [7,8,9] ]
let yank_reg = ""
for row in matrix
    for item in row
        let yank_reg = yank_reg . "\t" . (item*2)
    endfor
    let yank_reg = yank_reg . "\n"
endfor
let @" = yank_reg

Obrázek 7: Demonstrační příklad pracující se seznamem seznamů.

Obsah registru " je možné uložit za pozici kurzoru pomocí příkazu p (put), protože tento registr je u editačních operací používán implicitně. Stejný příkaz je však možné zavolat přímo ze skriptu s využitím klíčového slova normal:

let matrix = [ [1,2,3], [4,5,6], [7,8,9] ]
let yank_reg = ""
for row in matrix
    for item in row
        let yank_reg = yank_reg . "\t" . (item*2)
    endfor
    let yank_reg = yank_reg . "\n"
endfor
let @" = yank_reg
normal p

(dejte si pozor, na kterém místě se textový kurzor při spouštění skriptu nachází).

Obrázek 8: Demonstrační příklad pracující se seznamem seznamů po svém spuštění. V dolní části editační plochy je vypsán výsledek práce tohoto příkladu.

5. Programová smyčka typu foreach při práci se slovníky (dictionary)

Programovou smyčku typu foreach popsanou v předchozí kapitole je možné kromě průchodu seznamem použít i pro procházení slovníků (dictionary). Již v předchozí části tohoto seriálu jsme si řekli, že klíči ve slovnících mohou být pouze řetězce, což však poněkud zmenšuje možnosti průchodu celým slovníkem s využitím programové smyčky typu while. Textový editor Vim však obsahuje interní funkci keys(), která vrací všechny klíče ve slovníku ve formě seznamu řetězců. S využitím této funkce je možné smyčku pro průchod slovníkem napsat – i když dosti nešikovně – například následujícím způsobem:

let dictionary={"one":1, "two":2, "three":3, "four":4}
echo dictionary

let keys=keys(dictionary)
let i = 0
while i < len(keys)
    let key = get(keys, i)
    echo "Klic: " . key . "\thodnota: " . dictionary[key]
    let i = i + 1
endwhile

Popř. mnohem jednodušeji a čitelněji s využitím konstrukce foreach:

let dictionary={"one":1, "two":2, "three":3, "four":4}
echo dictionary

for key in keys(dictionary)
    echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor

Obrázek 9: Procházení slovníkem pomocí programové smyčky typu while.

Jak je z předchozího příkladu patrné, nejprve se převedou všechny klíče na seznam a poté se využije výše popsaná smyčka for – endfor, která slouží k průchodu seznamem. Je zde však jeden poměrně zásadní rozdíl: zatímco u seznamů bylo zaručeno, že se prvky seznamu prochází postupně od prvku prvního směrem k prvku poslednímu, u slovníků (neboli asociativních polí, hashů) je pořadí zdánlivě náhodné a odpovídá způsobu interní reprezentace slovníku v operační paměti, což je ostatně patrné i ze zpráv vypsaných předchozím demonstračním příkladem:

{'four': 4, 'one': 1, 'two': 2, 'three': 3}
Klic: four      hodnota: 4
Klic: one       hodnota: 1
Klic: two       hodnota: 2
Klic: three     hodnota: 3

Klíče je však možné například seřadit s využitím interní funkce sort(), čímž se stane průchod slovníkem více deterministický; viz též následující příklad:

let dictionary={"aaa":1, "xxx":2, "ccc":3, "zzz":4}
echo dictionary

let sorted_keys = sort(keys(dictionary))
for key in sorted_keys
    echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor

Výsledek běhu předchozího demonstračního příklad je následující:

{'zzz': 4, 'xxx': 2, 'ccc': 3, 'aaa': 1}
Klic: aaa       hodnota: 1
Klic: ccc       hodnota: 3
Klic: xxx       hodnota: 2
Klic: zzz       hodnota: 4

Obrázek 10: Procházení slovníkem pomocí programové smyčky typu foreach.

Seznam klíčů je samozřejmě možné setřídit opačně, k čemuž lze využít buď vlastní porovnávací funkci, nebo na již setříděný seznam zavolat funkci reverse(). Vzhledem k syntaktickým omezením Vim Scriptu je však v tomto případě nutné tuto funkci volat pomocí konstrukce call (Vim Script by totiž nepoznal, že se jedná a volání funkce a předpokládal by, že reverse je nějaký příkaz):

let dictionary={"aaa":1, "xxx":2, "ccc":3, "zzz":4}
echo dictionary

let sorted_keys = sort(keys(dictionary))
call reverse(sorted_keys)

for key in sorted_keys
    echo "Klic: " . key . "\thodnota: " . dictionary[key]
endfor

Výsledek běhu předchozího demonstračního příklad je zobrazen níže:

{'zzz': 4, 'xxx': 2, 'ccc': 3, 'aaa': 1}
Klic: zzz       hodnota: 4
Klic: xxx       hodnota: 2
Klic: ccc       hodnota: 3
Klic: aaa       hodnota: 1

6. Jak lze ve Vim Scriptu elegantně vytvořit počítané programové smyčky?

Po přečtení předchozích kapitol se možná ptáte, jakým způsobem se tedy ve Vim Scriptu mohou zapisovat počítané smyčky typu for známé z programovacích jazyků náležejících do Algolské větve. Samozřejmě je možné pro implementaci počítané smyčky použít konstrukci whileendwhile. To je však poměrně nečitelné, jak jsme mohli vidět na příkladu uvedeném ve druhé kapitole:

let i = 1
while i <= 10
    echo "aktualni hodnota pocitadla: " . i
    let i = i + 1
endwhile

Vim Script sice neobsahuje „pravou“ počítanou smyčku typu for, ovšem lze ji implementovat s využitím smyčky foreach a interní funkce range(). Tato užitečná funkce na základě svých parametrů vytvoří posloupnost čísel uloženou v seznamu a průchod seznamem (zde konkrétně seznamem čísel) již známe. Nejprve si ukažme, jak funkce range() pracuje. Pokud je funkce zavolána pouze s jedním parametrem n (jímž by mělo být kladné číslo), vrátí aritmetickou řadu začínající nulou a končící hodnotou n-1:

:echo range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Samozřejmě je také možné zadat hodnotu prvního a posledního čísla v aritmetické posloupnosti. V tomto případě má funkce range() dva parametry: hodnotu prvního prvku a hodnotu prvku posledního. Stále se však jedná o rostoucí posloupnost, tj. druhý parametr by měl být vyšší, než parametr první, jinak se vrátí buď jednoprvkový seznam (shodná hodnota obou parametrů) nebo prázdný seznam (popř. se nahlásí chyba):

:echo range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
:echo range(6, 16)
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

Jednoprvkový seznam:

:echo range(10, 10)
[10]

V mnoha skriptech je taktéž nutné zadat krok v aritmetické posloupnosti – právě tímto způsobem je možné vytvořit klesající posloupnost (krok se zadává jako třetí nepovinný parametr):

Kladný krok:

:echo range(0, 10, 2)
[0, 2, 4, 6, 8, 10]

Záporný krok:

:echo range(10, 1, -1)
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Obrázek 11: Zdrojový kód demonstračního příkladu pro výpis sudých řádků z aktuálně editovaného bufferu.

Nyní se již konečně dostáváme k využití této funkce při tvorbě počítaných smyček. Asi nebude velkým překvapením, že smyčku lze s využitím funkce range() zapsat velmi jednoduše

for i in range(1, 10)
    echo "aktualni hodnota pocitadla: " . i
endfor

Podobnou konstrukci je možné použít například při průchodu všemi řádky aktuálně editovaného bufferu. Povšimněte si použití interní funkce line(), která vrací číslo textového řádku v závislosti na řetězci zadaném jako parametr této funkce. Více informací si o této funkci řekneme v následujících částech tohoto seriálu:

let max = line("$")

for n in range(1, max)
    echo getline(n)
endfor

Samozřejmě je možné procházet například všemi sudými řádky od aktuální pozice kurzoru směrem ke konci souboru, atd. atd.:

let max = line("$")
let current = line(".")

for n in range(current, max, 2)
    echo getline(n)
endfor

Obrázek 12: Část zdrojového kódu tohoto článku, z něhož se zobrazují jen sudé řádky.

7. Zpracování výjimek

Skriptovací jazyk Vim Script obsahuje – možná poněkud překvapivě – i konstrukci používanou při zachycování a zpracování výjimek, tj. různých chybových stavů, které mohou během práce skriptu nastat. Samotný princip zachycení výjimek není nijak neobvyklý, ale vzhledem k tomu, že Vim Script sice umožňuje práci s objekty, ale není plně objektově orientovaný, je každá výjimka jednoduše reprezentovaná řetězcem, jehož obsah odpovídá řetězci, který je v případě chyby vypsán uživateli do okna Vimu (zprávy o chybách mohou být samozřejmě ovlivněny aktuálně nastaveným jazykovým prostředím). Právě na základě chybového řetězce nebo jeho části může být výjimka skriptem zachycena a nějakým způsobem zpracována. Přitom se velmi často využívá faktu, že každé chybové hlášení ve Vimu začíná číslem chyby. Toto chování textového editoru si můžete jednoduše vyzkoušet, například zadáním následujících příkazů.

Pokus o zápis obsahu bufferu do souboru či zařízení, pro nějž není zápis povolený:

:set readonly
:w

Obrázek 13: Chybové hlášení vypsané při pokusu o zápis do souboru otevřeného v režimu read only.

Zadání špatného regulárního výrazu pro vyhledávání (závorka není párová):

/\)

Pro odchycení výjimky se používá blok try-catch-endtry, popř. try-catch-finally-endtry, který má následující strukturu:

try
    blok příkazů
catch regulární výraz
    blok s příkazy reagujícími na výjimku
endtry

Popř. lze použít blok rozšířený o větev finally:

try
    blok příkazů
catch regulární výraz
    blok s příkazy reagujícími na výjimku
finally
    blok provedený nezávisle na tom, zda výjimka vznikne
endtry

Taktéž je možné blok catch zcela vynechat:

try
    blok příkazů
finally
    blok provedený nezávisle na tom, zda výjimka vznikne
endtry

Obrázek 14: Chybová zpráva vypsaná ve chvíli, kdy není hledaný vzor v textu nalezen.

8. Ukázka využití bloku try-catch-endcatch

Po rychlém teoretickém úvodu do problematiky výjimek ve Vim Scriptu si již můžeme ukázat jednoduchý příklad (převzatý přímo z nápovědy k Vimu). V tomto příkladu probíhá pokus o otevření souboru na zadané cestě a pokud soubor neexistuje, je o tom uživatel informován hlášením vypsaným pomocí nám již známého příkazu echo:

try
    read ~/templates/pascal.tmpl
catch /E484:/
   echo "Sorry, the Pascal template file cannot be found."
endtry

Jak je z tohoto zdrojového příkladu patrné, je zachycována chyba s číslem 484. Číslo této chyby bude vždy stejné, nezávisle na tom, v jakém jazykovém prostředí je Vim ve skutečnosti spuštěn. Ovšem regulární výraz pro zachycení výjimky může být i složitější, což můžeme vidět z příkladu uvedeném níže:

try
    let config_lines = readfile('/etc/udev/udev.conf')
catch /^Vim\%((\a\+)\)\=:E484/
    return
endtry

Obrázek 15: Chybová zpráva vypsaná ve chvíli, kdy je vyhledávaný vzor chybný kvůli chybějící párové závorce.

Samozřejmě je taktéž možné zachytit a nějakým způsobem reagovat na větší množství výjimek:

try
    call execute_code
catch /E484:/
    echo "No type annotations (.annot) file found"
catch /no_expression/
    echo "No expression found under the cursor"
catch /no_annotation/
    echo "No type annotation found for the given text"
catch /malformed_annot_file/
    echo "Malformed .annot file"
endtry

Obrázek 16: Dvojice výjimek, v jejichž chybovém řetězci jsou sice použita lokalizovaná hlášení, ovšem číslo chyby zůstává stále stejné.

9. Odkazy na Internetu

  1. Clewn home page
    http://clewn.sourceforge.net/
  2. How to connect vim with gdb – using clewn
    http://chunhao.net/blog/how-to-connect-vim-with-gdb-using-clewn
  3. yavdb : Yet Another (Generic) Vim Debugger Integration
    http://www.vim.org/scripts/scrip­t.php?script_id=1954
  4. Vim home page
    http://www.vim.org/
  5. Exuberant ctags
    http://ctags.sourceforge.net/
  6. xxd (man page)
    http://www.linux-tutorial.info/modules.php?na­me=ManPage&sec=1&manpage=xxd
  7. vim (man page)
    http://www.linux-tutorial.info/modules.php?na­me=ManPage&sec=1&manpage=vim
  8. ctags (man page)
    http://www.linux-tutorial.info/modules.php?na­me=ManPage&sec=1&manpage=ctags
  9. cscope (man page)
    http://www.linux-tutorial.info/modules.php?na­me=ManPage&sec=1&manpage=csco­pe
  10. Tutorial: Make Vim as Your C/C++ IDE Using c.vim Plugin
    http://www.thegeekstuff.com/2009/01/tu­torial-make-vim-as-your-cc-ide-using-cvim-plugin/
  11. c.vim : C/C++ IDE
    http://vim.sourceforge.net/scrip­ts/script.php?script_id=213
  12. c.vim : C/C++ IDE key mappings
    http://lug.fh-swf.de/vim/vim-c/c-hotkeys.pdf
  13. Základní základy editoru Vim
    http://www.root.cz/clanky/zakladni-zaklady-editoru-vim/
  14. Jak si přizpůsobit Vim
    http://www.root.cz/serialy/jak-si-prizpusobit-vim/
  15. Novinky ve VIM 7: Úvodní část – speller
    http://www.root.cz/vim-sedm-prvni-cast/
  16. Novinky ve VIM 7: Skriptovací jazyk
    http://www.root.cz/vim-sedm-druha-cast/
  17. vim2elvis: Přednosti a nedostaky Elvise v porovnání s Vimem
    http://www.root.cz/clanky/vim2elvis-1/
  18. vim2elvis: Shodné znaky mezi Elvisem a Vimem, nastaveníeditoru
    http://www.root.cz/clanky/vim2elvis-2/
  19. Nej… VIM pluginy (1)
    http://www.root.cz/clanky/nej-vim-pluginy/
  20. Taglist (plugin)
    http://www.vim.org/scripts/scrip­t.php?script_id=273
  21. The NERD tree: A tree explorer plugin for navigating the filesystem
    http://www.vim.org/scripts/scrip­t.php?script_id=1658
  22. JavaBrowser : Shows java file class, package in a tree as in IDEs. Java source browser.
    http://www.vim.org/scripts/scrip­t.php?script_id=588
  23. snippetsEmu : An attempt to emulate TextMate's snippet expansion
    http://www.vim.org/scripts/scrip­t.php?script_id=1318
  24. Scroll Lock (Necyklopedie)
    http://necyklopedie.wikia­.com/wiki/Scroll_lock
  25. Caps Lock (Necyklopedie)
    http://necyklopedie.wikia­.com/wiki/Caps_Lock
  26. Avoid the escape key
    http://vim.wikia.com/wiki/A­void_the_escape_key
  27. Map caps lock to escape in XWindows
    http://vim.wikia.com/wiki/VimTip166
Našli jste v článku chybu?

13. 8. 2011 9:26

ava (neregistrovaný)

Rozhodování určitě bude subjektivní.

Já skončil u IDEA, protože v první řadě potřebuji integrované vývojové prostředí, a až v druhé textový editor - navigace v *kódu* (nikoliv v textu) a práce s ním je pro mě důležitější než nabušit co nejvíc slov za minutu. V tom zase exceluje vim, i když IDEA díky svému inteligentnímu kontextovému doplňování (umí vim doplňovat v závislosti na kontextu se znalostí příslušného jazyka?) je pro rychlé "bušení" *kódu* také fantastická.

Jsou lidé, kteří maj…

11. 8. 2011 14:05

lzap (neregistrovaný)

Ad IntelliSense - no to je preci OmniSense. Tato featura byla pridana tusim do Vim 7.0. Refaktoring se dela skvele uz v zakladni konfiguraci, ale existuji pluginy. Ostatne jako na vsechno, co tady pisete.

Mala reklama - udelal jsem takovou konzoli, ktera se chova tak trochu jako Run/Lunch/Start v ruznych IDE. S tou si vystacim nejen pro buildy, testy, ale i pro ladeni. S Vimem to komunikuje pres D-BUS: https://github.com/lzap/vide

No vidite, ja jsem zase po 2 letech v IntelliJ (IDEA, pak RubyM…

Podnikatel.cz: E-Ježíšek si i letos zařádí. Nákupy od 2 do 5 tisíc

E-Ježíšek si i letos zařádí. Nákupy od 2 do 5 tisíc

120na80.cz: Pánové, pečujte o svoje přirození a prostatu

Pánové, pečujte o svoje přirození a prostatu

Root.cz: Vypadl Google a rozbilo se toho hodně

Vypadl Google a rozbilo se toho hodně

Měšec.cz: Zdravotní a sociální pojištění 2017: Připlatíte

Zdravotní a sociální pojištění 2017: Připlatíte

Podnikatel.cz: Přehledná titulka, průvodci, responzivita

Přehledná titulka, průvodci, responzivita

120na80.cz: Jak oddálit Alzheimera?

Jak oddálit Alzheimera?

Podnikatel.cz: Babiše přesvědčila 89letá podnikatelka?!

Babiše přesvědčila 89letá podnikatelka?!

Podnikatel.cz: Podnikatelům dorazí varování od BSA

Podnikatelům dorazí varování od BSA

Podnikatel.cz: EET: Totálně nezvládli metodologii projektu

EET: Totálně nezvládli metodologii projektu

Měšec.cz: Kdy vám stát dá na stěhování 50 000 Kč?

Kdy vám stát dá na stěhování 50 000 Kč?

Podnikatel.cz: Udávání kvůli EET začalo

Udávání kvůli EET začalo

Vitalia.cz: Jmenuje se Janina a žije bez cukru

Jmenuje se Janina a žije bez cukru

DigiZone.cz: ČRa DVB-T2 ověřeno: Hisense a Sencor

ČRa DVB-T2 ověřeno: Hisense a Sencor

DigiZone.cz: Sony KD-55XD8005 s Android 6.0

Sony KD-55XD8005 s Android 6.0

Vitalia.cz: Paštiky plné masa ho zatím neuživí

Paštiky plné masa ho zatím neuživí

Vitalia.cz: 9 největších mýtů o mase

9 největších mýtů o mase

DigiZone.cz: Recenze Westworld: zavraždit a...

Recenze Westworld: zavraždit a...

Vitalia.cz: Říká amoleta - a myslí palačinka

Říká amoleta - a myslí palačinka

Vitalia.cz: To není kašel! Správná diagnóza zachrání život

To není kašel! Správná diagnóza zachrání život

Vitalia.cz: Láska na vozíku: Přitažliví jsme pro tzv. pečovatelky

Láska na vozíku: Přitažliví jsme pro tzv. pečovatelky