Ve třetí a současně i poslední části článku o novinkách, které můžeme nalézt v osmé verzi populárního textového editoru Vim, dokončíme popis změn a rozšíření provedených ve skriptovacím engine Vimu a tedy i v jeho skriptovacím jazyku nazvaném VimScript. Jedná se především o podporu práce s formátem JSON, práci s takzvanými kanály (channels) a úlohami (jobs).

Obsah

1. Textový editor Vim 8 – dokončení popisu novinek ve skriptovacím engine

2. Práce s datovým formátem JSON

3. Demonstrační příklady: použití funkcí pro práci s formátem JSON

4. Převody hodnot mezi VimScriptem a formátem JSON

5. Použití seznamů (polí, vektorů)

6. Použití slovníků (hashů, asociativních polí)

7. Speciální hodnoty pro reprezentaci nekonečna a NaN při použití typu Float

8. Speciální hodnoty určené pro reprezentaci true, false a null ve formátu JSON

9. Kanály (channels)

10. Vytvoření kanálu a přenos dat

11. Demonstrační plugin

12. Úlohy (jobs)

13. Repositář s demonstračními příklady

14. Odkazy na Internetu

1. Textový editor Vim 8 – dokončení popisu novinek ve skriptovacím engine

Ve druhé části článku o novinkách, které nalezneme v osmé verzi populárního textového editoru Vim, jsme se seznámili s některými změnami provedenými ve skriptovacím engine Vimu. S těmito změnami a vylepšeními se sice v naprosté většině případů přímo setkají pouze vývojáři pluginů, ovšem těžit z nich (alespoň nepřímo) mohou i všichni ostatní uživatelé textového editoru Vim, protože implementované změny a rozšíření (anonymní funkce, časovače, unikátní čísla oken, asynchronní spouštění programového kódu atd.) umožňují tvorbu složitějších pluginů pracujících asynchronně s operacemi prováděnými uživatelem. Připomeňme si, že minule byly popsány následující změny a vylepšení:

  1. Podpora pro použití unikátních čísel (identifikátorů) oken.
  2. Anonymní funkce a uzávěry (closures) ve VimScriptu.
  3. Reference na funkce (to sice ve skutečnosti není úplná novinka, ale úzce souvisí s předchozím bodem).
  4. Časovače a s nimi související asynchronně spouštěný kód.

Obrázek 1: Všechny demonstrační příklady budou funkční ve Vimu 8. Verzi Vimu zjistíte snadno – pokud se při spouštění tohoto textového editoru neotevře žádný soubor, zobrazí se toto hlášení.

V dnešním článku popis všech změn a rozšíření VimScriptu dokončíme, protože si postupně popíšeme a na demonstračních příkladech ukážeme tyto novinky:

  1. Použití datového formátu JSON
  2. Převody hodnot (jak skalárních, tak i strukturovaných) do JSONu a zpět
  3. Využití takzvaných kanálů (channels)
  4. Tvorba takzvaných úloh (jobs)

Obrázek 2: Druhá možnost zjištění verze Vimu spočívá ve spuštění příkazu :ver.

2. Práce s datovým formátem JSON

Na první pohled sice možná ne příliš výraznou, ale o to důležitější a užitečnější novinkou, je přidání čtyř nových funkcí do skriptovacího engine Vimu. Tyto čtyři funkce slouží pro převod datových struktur VimScriptu do JSON formátu a zpět. Proč je vlastně tato novinka tak důležitá? Souvisí totiž s další novou technologií, konkrétně s úlohami (jobs) a kanály (channels). Úlohy umožňují přesně definovaným způsobem vytvářet pluginy (i externí pluginy) s tím, že tyto pluginy mohou běžet asynchronně, tj. částečně nezávisle na samotném Vimu. Důležité je, že pluginy s Vimem komunikují právě přes JSON formát, což je pěkně navržené řešení, protože JSON je dnes podporovaný v prakticky všech relevantních programovacích jazycích, v nichž se externí pluginy většinou píšou (typicky se jedná o Python, ale lze použít i jazyk Lua apod.).

Skriptovací engine Vimu nabízí programátorům dvě funkce určené pro převod datových struktur do formátu JSON (encode) a dvě funkce určené pro parsování JSON dat do interních struktur VimScriptu (decode). Dvě varianty jsou implementovány z toho důvodu, že někdy je zapotřebí, aby byly klíče objektů (či slovníků) reprezentovány řetězci a jinde se může jednat o identifikátory bez uvozovek (záleží na konkrétní situaci):

Funkce Stručný popis
json_encode(výraz) převod výrazu do JSON formátu, který se vrátí ve formě řetězce
json_decode(řetězec) opak předchozí funkce, parsování řetězce s daty uloženými v JSON formátu do interních datových struktur VimScriptu
js_encode(výraz) podobné funkci json_encode(), ovšem klíče nejsou umístěny v uvozovkách
js_decode(řetězec) podobné funkci json_decode(), ovšem při parsingu se nevyžaduje, aby byly klíče umístěny v uvozovkách

Poznámka: převod do JSON formátu se někdy nazývá serializace, zpětný převod pak pochopitelně deserializace.

Obrázek 3: Nápověda k funkcím js_decode() a js_encode().

3. Demonstrační příklady: použití funkcí pro práci s formátem JSON

Chování výše popsaných funkcí si můžeme velmi snadno otestovat. Pro jednoduchost si nejprve ukážeme, jakým způsobem se do formátu JSON (a zpět) převádí skalární datové typy, tj. zejména numerické hodnoty a řetězce. První příklad používá funkci json_encode():

" ---------------------------------------------
" Vim8 example script #8 - usage of json_encode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let integerNumber = 42
echo json_encode(integerNumber)

let realNumber = 3.0/2
echo json_encode(realNumber)

let booleanValueTrue = 1==1
echo json_encode(booleanValueTrue)

let booleanValueFalse = 1==2
echo json_encode(booleanValueFalse)

let greetings = "VimPerfect"
echo json_encode(greetings)

Obrázek 4: Výsledek po spuštění demonstračního příkladu json_encode_scalars.vim. Povšimněte si především toho, že výsledek výrazů 1==1 (pravda) a 1==2 (nepravda) se převede na celé číslo 0 či 1. Pokud skutečně budeme do JSON formátu zapisovat pravdivostní hodnoty „true“ a „false“, je nutné na straně VimScriptu použít speciální hodnoty zmíněné v osmé kapitole.

V případě použití funkce js_encode() bude výsledek totožný, protože chování této funkce se odlišuje především při práci se slovníky (dict) nazývanými také asociativní pole či objekty:

" ---------------------------------------------
" Vim8 example script #9 - usage of js_encode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let integerNumber = 42
echo js_encode(integerNumber)

let realNumber = 3.0/2
echo js_encode(realNumber)

let booleanValueTrue = 1==1
echo js_encode(booleanValueTrue)

let booleanValueFalse = 1==2
echo js_encode(booleanValueFalse)

let greetings = "VimPerfect"
echo js_encode(greetings)

Obrázek 5: Výsledek po spuštění demonstračního příkladu js_encode_scalars.vim.

Ve chvíli, kdy se nám nějakým způsobem podaří získat textový řetězec obsahující data v JSON formátu (může se jednat o obsah souboru, data přečtená z kanálu atd.), je parsing takového řetězce snadný. Lze použít funkci json_decode() či js_decode(). Podívejme se nejprve na výsledek použití první z těchto funkcí:

" ---------------------------------------------
" Vim8 example script #10 - usage of json_decode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let integerNumber = 42
let jsonValue = json_encode(integerNumber)
echo json_decode(jsonValue)

let realNumber = 3.0/2
let jsonValue = json_encode(realNumber)
echo json_decode(jsonValue)

let booleanValueTrue = 1==1
let jsonValue = json_encode(booleanValueTrue)
echo json_decode(jsonValue)

let booleanValueFalse = 1==2
let jsonValue = json_encode(booleanValueFalse)
echo json_decode(jsonValue)

let greetings = "VimPerfect"
let jsonValue = json_encode(greetings)
echo json_decode(jsonValue)

Obrázek 6: Výsledek po spuštění demonstračního příkladu json_decode_scalars.vim.

Použití funkce js_decode() je shodné s použitím výše zmíněné funkce json_decode():

" ---------------------------------------------
" Vim8 example script #11 - usage of js_decode()
" function for scalar values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let integerNumber = 42
let jsonValue = json_encode(integerNumber)
echo js_decode(jsonValue)

let realNumber = 3.0/2
let jsonValue = json_encode(realNumber)
echo js_decode(jsonValue)

let booleanValueTrue = 1==1
let jsonValue = json_encode(booleanValueTrue)
echo js_decode(jsonValue)

let booleanValueFalse = 1==2
let jsonValue = json_encode(booleanValueFalse)
echo js_decode(jsonValue)

let greetings = "VimPerfect"
let jsonValue = json_encode(greetings)
echo js_decode(jsonValue)

Obrázek 7: Výsledek po spuštění demonstračního příkladu js_decode_scalars.vim.

4. Převody hodnot mezi VimScriptem a formátem JSON

Ve VimScriptu existuje celkem deset datových typů, přičemž pět z těchto typů do jisté míry koresponduje s typy používanými ve formátu JSON (Number, Float, String, List a Dictionary) a dva další typy (Boolean, None) lze taktéž do formátu JSON převést, pokud se ovšem dodrží určitá pravidla. Výše zmíněné čtyři funkce json_encode(), json_decode(), js_encode() a js_decode() provádí převody mezi jednotlivými typy (resp. mezi hodnotami různých typů) zcela automaticky, ovšem existuje několik potenciálně problematických výjimek, kterými se budeme zabývat v navazujících kapitolách. V následující tabulce jsou vypsány korespondující datové typy. Povšimněte si, že v JSON formátu se nerozlišuje mezi celými čísly a čísly s plovoucí řádovou čárkou, což do značné míry souvisí s původním návrhem tohoto formátu založeném na JavaScriptu:

Typ ve VimScriptu Převod do JSONu
Number celé číslo, výjimky viz sedmou kapitolu
Float číslo s desetinnou čárkou a/nebo exponentem
String řetězec umístěný v uvozovkách
List pole hodnot, viz pátou kapitolu
Dictionary objekt (asociativní pole), viz šestou kapitolu
Funcref nelze (teoreticky by se jednalo o serializaci kódu)
Boolean True/False (viz kapitolu číslo 8)
None Null (viz kapitolu číslo 8)
Job nelze
Channel nelze

Obrázek 8: Prakticky vše o datových typech používaných ve VimScriptu se dozvíte po zadání příkazu :help variables.

5. Použití seznamů (polí, vektorů)

Převod mezi skalárními typy je ve většině běžných případů triviální, proto se podívejme, jakým způsobem je možné v JSON formátu reprezentovat složený datový typ. Prvním typem, s nímž se setká prakticky každý programátor používající VimScript, je seznam (list), který je ovšem někdy taktéž nazýván vektorem (vector) či polem (array), což ale není zcela přesné. V následujícím příkladu je do JSON formátu převeden seznam čísel, dále seznam řetězců a dvě matice reprezentované seznamem seznamů. Povšimněte si, že ve VimScriptu je nutné při zápisu výrazu či příkazu na více řádků použít zpětné lomítko na začátku (nikoli na konci!) řádku, což je dosti neobvyklé:

" ---------------------------------------------
" Vim8 example script #12 - usage of json_encode()
" function for vector (array) values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let vector1 = [1, 2, 3]
echo json_encode(vector1)

let vector2 = ["Hello", "world", "!"]
echo json_encode(vector2)

let matrix1 = [[1,2,3], [4,5,6], [7,8,9]]

echo json_encode(matrix1)

let matrix2 = [[1,2,3],
\             [4,5,6],
\             [7,8,9]]

echo json_encode(matrix2)

Obrázek 9: Výsledek po spuštění demonstračního příkladu json_encode_vectors.vim.

Samozřejmě můžeme namísto funkce json_encode() použít funkci js_encode(), která ovšem vytvoří shodný výsledek (prozatím totiž nepracujeme se slovníky):

" ---------------------------------------------
" Vim8 example script #13 - usage of js_encode()
" function for vector (array) values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let vector1 = [1, 2, 3]
echo js_encode(vector1)

let vector2 = ["Hello", "world", "!"]
echo js_encode(vector2)

let matrix1 = [[1,2,3], [4,5,6], [7,8,9]]

echo js_encode(matrix1)

let matrix2 = [[1,2,3],
\             [4,5,6],
\             [7,8,9]]

echo js_encode(matrix2)

Obrázek 10: Výsledek po spuštění demonstračního příkladu js_encode_vectors.vim.

6. Použití slovníků (hashů, asociativních polí)

Nejsložitější datovou strukturou, kterou je možné do JSON formátu uložit (serializovat), jsou takzvané slovníky (dictionary, dict), které jsou v jiných programovacích jazycích nazývány hashe či asociativní pole. Právě u slovníků se projeví rozdíl mezi funkcemi json_encode() a js_encode(), a to konkrétně při serializaci klíčů. Rozdíly jsou shrnuty v tabulce:

Typ klíče json_encode() js_encode()
řetězec odpovídající názvu proměnné v JS klíč je zapsán do uvozovek klíč je zapsán bez uvozovek
jiný řetězec (s mezerou, pomlčkou…) klíč je zapsán do uvozovek klíč je zapsán do uvozovek
číslo klíč je zapsán do uvozovek klíč je zapsán do uvozovek
jiný typ (seznam…) nelze použít nelze použít

Název proměnné v JavaScriptu musí začínat písmenem, podtržítkem či znakem dolaru a musí obsahovat čísla, písmena (nikoli jen ASCII, možnosti jsou zde větší), dolary či podtržítka.

V následujícím příkladu je ukázáno, jak je možné do JSON formátu ukládat slovníky, slovníky se seznamy (hodnoty) či naopak seznam slovníků:

" ---------------------------------------------
" Vim8 example script #14 - usage of json_encode()
" function for dictionaries.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let dict1 = {"first": 1, "second" : 2, "third" : 3}
echo json_encode(dict1)

let dict2 = {1 : "first", 2 : "second", 3 : "third"}
echo json_encode(dict2)

let dict3 = {"first" : [1,2,3], "second" : [4,5,6]}
echo json_encode(dict3)

let vectorOfDicts = [ {"first" : 1, "second" : 2}, {"another" : "dictionary"}]
echo json_encode(vectorOfDicts)

Obrázek 11: Výsledek po spuštění demonstračního příkladu json_encode_dict.vim.

Pokud budeme shodné datové struktury serializovat funkcí js_encode(), budou se klíče ukládat rozdílným způsobem, ale pouze pro ty řetězce, které odpovídají jménům proměnných v JavaScriptu:

" ---------------------------------------------
" Vim8 example script #15 - usage of js_encode()
" function for dictionaries.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let dict1 = {"first": 1, "second" : 2, "third" : 3}
echo js_encode(dict1)

let dict2 = {1 : "first", 2 : "second", 3 : "third"}
echo js_encode(dict2)

let dict3 = {"first" : [1,2,3], "second" : [4,5,6]}
echo js_encode(dict3)

let vectorOfDicts = [ {"first" : 1, "second" : 2}, {"another" : "dictionary"}]
echo js_encode(vectorOfDicts)

Obrázek 12: Výsledek po spuštění demonstračního příkladu js_encode_dict.vim.

7. Speciální hodnoty pro reprezentaci nekonečna a NaN při použití typu Float

Při ukládání (serializaci) dat do formátu JSON je v některých případech nutné korektně pracovat se speciálními hodnotami podporovanými typem Float (numerické hodnoty s plovoucí řádovou čárkou). Výsledkem některých aritmetických operací totiž může být kladné či záporné nekonečno, které se ve VimScriptu vypíše jako inf nebo -inf. Dokonce můžeme získat i hodnotu NaN (Not a Number), což je například výsledek dělení nuly nulou, výpočtem rozdílu dvou nekonečen, podílem nekonečen atd. Podívejme se nyní na to, jak s těmito speciálními hodnotami pracují funkce pro serializaci do JSON formátu. Předem upozorňuji na problematickou práci se záporným nekonečnem, které se do JSONu ukládá jako nekonečno kladné (!), i když echo negativeInfinity dokládá, že interně VimScript tuto hodnotu zpracovává korektně:

" ---------------------------------------------
" Vim8 example script #15 - usage of json_encode()
" function for special float values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let positiveInfinity = 1.0/0
let negativeInfinity = -1.0/0
let NaN1 = 0.0/0
let NaN2 = 1 + NaN1
let NaN3 = positiveInfinity - positiveInfinity
let NaN4 = positiveInfinity / positiveInfinity

let originalList = [0, 0.0, 1, 1.0, positiveInfinity, negativeInfinity, NaN1, NaN2, NaN3, NaN4]
let jsonList = json_encode(originalList)
echo jsonList

Obrázek 13: Výsledek po spuštění demonstračního příkladu json_encode_float_values.vim. Povšimněte si, že i původně záporné nekonečno je reprezentováno jako „Infinity“.

8. Speciální hodnoty určené pro reprezentaci true, false a null ve formátu JSON

Mezi další tři speciální hodnoty, s nimiž je v některých případech nutné v JSON formátu pracovat, patří hodnoty true, false a null. Tyto hodnoty je nutné ve VimScriptu explicitně ošetřit, a to zejména z toho důvodu, že interně jsou pravdivostní hodnoty reprezentovány celými čísly: pravda je reprezentována hodnotou 1, nepravda hodnotou 0. To jsme ostatně viděli už v prvním demonstračním příkladu, v němž se výsledky výrazů 1==1 a 1==2 převedly na 1 a 0. Pro reprezentaci „skutečných“ pravdivostních hodnot ve formátu JSON slouží speciální hodnoty v:true a v:false. Totéž platí i pro null (tedy prázdnou hodnotu), kterou je nutné ve VimScriptu zapisovat buď jako v:null či jako v:none. Vše je patrné z následující dvojice demonstračního příkladu. Povšimněte si toho, že prázdný řetězec není považován za hodnotu null (některé starší JSON knihovny právě prázdné řetězce zpracovávaly špatně):

" ---------------------------------------------
" Vim8 example script #16 - usage of json_encode()
" function for special values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let originalDictionary = {
\    "true1"  : 1==1,
\    "true2"  : v:true,
\    "false1" : 1==2,
\    "false2" : v:false,
\    "null1"  : v:null,
\    "null2"  : v:none,
\    "emptyString"  : ""
\}

let jsonDictionary = json_encode(originalDictionary)
echo jsonDictionary

Obrázek 14: Výsledek po spuštění demonstračního příkladu json_encode_special_values.vim.

" ---------------------------------------------
" Vim8 example script #17 - usage of js_encode()
" function for special values.
"
" How to use it:
" 1) start new Vim session
" 2) open this script in it
" 3) call :source %
" ---------------------------------------------

let originalDictionary = {
\    "true1"  : 1==1,
\    "true2"  : v:true,
\    "false1" : 1==2,
\    "false2" : v:false,
\    "null1"  : v:null,
\    "null2"  : v:none,
\    "emptyString"  : ""
\}

let jsonDictionary = js_encode(originalDictionary)
echo jsonDictionary

Obrázek 15: Výsledek po spuštění demonstračního příkladu js_encode_special_values.vim.

9. Kanály (channels)

Zcela novou technologií, s níž se můžeme setkat ve Vimu 8, je koncept takzvaných kanálů (channels). Kanály slouží ke komunikaci mezi Vimem (resp. přesněji řečeno mezi VimScriptem) a externími pluginy, které jsou spuštěny v samostatném procesu. Vim s těmito pluginy komunikuje buď s využitím socketů nebo pipe. Pro přenos dat se typicky používá formát JSON a proto jsou tak užitečné ty funkce, které jsme si popsali v předchozích kapitolách. Ve skutečnosti se mohou používat čtyři typy zpráv: RAW, NL, JSON a JS:

Typ zprávy Význam
RAW obecný formát, s nímž Vim nijak speciálně nenakládá, pouze zprávu pošle či přijme
NL každá textová zpráva je ukončena znakem pro konec řádku (NL)
JSON formát JSON
JS formát JSON s klíči odpovídajícími JavaScriptu

Samotné pluginy mohou pracovat ve čtyřech režimech:

Režim Připojení Popis
démon socket proces, ke kterému se může připojit více instancí Vimu
úloha (job) socket nebo pipe proces, ke kterému se připojuje jedna instance Vimu (ten ho typicky i spustí)
krátká úloha socket nebo pipe dtto jako předchozí, typicky však proces neběží po celou dobu existence Vimu
filtr pipe spouští se synchronně, Vim čeká na výsledek operace

10. Vytvoření kanálu a přenos dat

Nový kanál určený pro komunikaci s démonem či úlohou (viz tabulka v předchozí kapitole), se vytváří funkcí ch_open(). Například pro démona lokálně běžícího na stejném počítači a poslouchajícího na portu 1234 se použije tento příkaz:

let channel1 = ch_open("localhost:1234")

Jakmile je kanál vytvořen, lze démonu poslat data funkcí ch_evalexpr(kanál, data):

ch_evalexpr(channel1, "Hello daemon")

Pokud démon vrátí nějakou zprávu, je tato zpráva vrácena jako výsledek funkce ch_evalexpr():

let response = ch_evalexpr(channel1, "Hello daemon")
echo response

Na konci skriptu je nutné kanál zavřít a uvolnit tak příslušný socket:

ch_close(channel1)

11. Demonstrační plugin

Při instalaci Vimu (či při jeho lokálním překladu) se mj. nainstaluje i demonstrační server, který můžeme použít pro otestování funkce kanálů. Tento server je dostupný v adresáři, který se vrátí zápisem :echo $VIMRUNTIME. Typicky jde o adresář /usr/share/vim/vim80 či /usr/local/share/vim/vim80/. V tomto adresáři nalezneme podadresář nazvaný tools se souborem demoserver.py. Tento soubor spusťte v samostatném terminálu, aby byly vidět jeho zprávy:

/usr/local/share/vim/vim80/tools/demoserver.py 
Server loop running in thread:  Thread-1
Listening on port 8765

Následně otevřeme propojení se serverem (démonem), a to přímo ve Vimu:

:let channel1=ch_open("localhost:8765")

Na straně serveru by se měla objevit zpráva:

=== socket opened ===

Nyní již můžeme serveru poslat nějaká data:

:call ch_evalexpr(channel1, "Hello daemon")

Server zprávu přijme a příslušně odpoví:

received: [1,"Hello daemon"]

sending [1, "what?"]

Nyní můžeme kanál uzavřít (ve skutečnosti však může být otevřen libovolně dlouhou dobu, pokud je to potřeba):

:call ch_close(channel1)

Na straně serveru by se měla objevit zpráva:

=== socket closed ===

Namísto tohoto jednoduchého serveru si můžeme představit mnohem složitější program, například jádro překladače, nástroje pro refaktoring kódu atd.

12. Úlohy (jobs)

Pro spuštění pluginů v samostatných procesech se používá nová funkce nazvaná job_start(). Tato funkce má jeden nepovinný parametr, kterým je příkaz pro spuštění (například cesta ke skriptu atd.). Nepovinným parametrem options je možné funkci job_start() předat způsob spuštění úlohy, například zda se mají pro komunikaci použít kanály či pipy, jak dlouho se má čekat na dokončení volání (timeout) atd. Jakmile je úloha spuštěna, lze její stav zjistit zavoláním funkce job_status() vracející řetězec „run“, „fail“ (nepodařil se start) nebo „dead“ (start se podařil, nicméně úloha již skončila). Explicitní ukončení úlohy zajišťuje funkce pojmenovaná jednoduše job_stop(), které lze navíc v Linuxu předat signál pro ukončení: „term“, „hup“, „quit“ apod. A to nejdůležitější na konec: pokud se úloha spustila, je možné získat komunikační kanál funkcí job_channel() a následně použít techniku popsanou v předchozích třech kapitolách.

13. Repositář s demonstračními příklady

Všechny v předchozích kapitolách popsané demonstrační skripty určené pro textový editor Vim verze 8 byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/presentations. V následující tabulce naleznete na jednotlivé skripty přímé odkazy:

Příklad Adresa
json_encode_scalars.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_encode_scalars.vim
js_encode_scalars.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/js_encode_scalars.vim
json_decode_scalars.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_decode_scalars.vim
js_decode_scalars.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/js_decode_scalars.vim
json_encode_vectors.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_encode_vectors.vim
js_encode_vectors.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/js_encode_vectors.vim
json_encode_dict.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_encode_dict.vim
js_encode_dict.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/js_encode_dict.vim
json_encode_float_values.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_encode_float_values.vim
json_encode_special_values.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/json_encode_special_values.vim
js_encode_special_values.vim https://github.com/tisnik/presentations/blob/master/vim/vim8/js_encode_special_values.vim

Poznámka: ani jeden z těchto skriptů nebude funkční v předchozích verzích Vimu!

14. Odkazy na Internetu

  1. Introducing JSON
    http://json.org/
  2. NULL v JSON formátu
    http://stackoverflow.com/questions/21120999/representing-null-in-json#21122019
  3. Vim – the editor
    http://www.vim.org/
  4. Vim 8.0 is released
    https://laravel-news.com/2016/09/vim-8-0-is-released/
  5. Vim: So long Pathogen, hello native package loading
    https://shapeshed.com/vim-packages/
  6. :smile command was not backported! #5116
    https://github.com/neovim/neovim/issues/5116
  7. Makejob
    http://www.vim.org/scripts/script.php?script_id=5479
  8. Články o Vimu na Root.cz:
    http://www.root.cz/n/vim/clanky/
  9. Vim sedm – první část
    http://www.root.cz/clanky/vim-sedm-prvni-cast/
  10. vim (man page)
    http://www.linux-tutorial.info/modules.php?name=ManPage&sec=1&manpage=vim
  11. History of the Text Editor
    http://vanstee.me/history-of-the-text-editor.html
  12. Interview with Bill Joy
    http://web.cecs.pdx.edu/~kirkenda/joy84.html
  13. vi Editor Commands
    http://www.cs.rit.edu/~cslab/vi.html#A1.4
  14. vi Manual
    http://www.cs.fsu.edu/general/vimanual.html
  15. Mastering the Vi Editor
    http://www.susnet.uk/mastering-the-vi-editor
  16. Vim as a Python IDE, or Python IDE as Vim
    http://blog.jetbrains.com/pycharm/2013/06/vim-as-a-python-ide-or-python-ide-as-vim/
  17. Vi Improved
    https://wiki.python.org/moin/Vim
  18. Popis skriptu Vim Pathogen
    http://www.vim.org/scripts/script.php?script_id=2332
  19. Poslední­verze skriptu Vim Pathogen
    https://tpo.pe/pathogen.vim
  20. Nejlepší pluginy pro Vim
    http://vimawesome.com/
  21. Nejlepší pluginy pro Vim
    http://www.vim.org/scripts/script_search_results.php?order_by=rating
  22. Building Vim
    http://vim.wikia.com/wiki/Building_Vim
  23. Vim plugins for developers
    http://www.linuxtoday.com/upload/vim-plugins-for-developers-140619094010.html