Hlavní navigace

Další užitečná pomůcka při práci v příkazovém řádku: utilita fzf

Dnes se seznámíme s nástrojem nazvaným fzf neboli command-line fuzzy finder. Tento nástroj lze použít pro interaktivní vyhledání a výběr souborů, příkazů z historie, proměnných prostředí, větví v Git repositáři atd.
Pavel Tišnovský 21. 1. 2020
Doba čtení: 19 minut

Sdílet

11. Zjednodušení práce s Gitem

12. Interaktivní příkaz cd

13. Prohlížení obsahu souboru vybraného přes fzf

14. Integrace fzf s projektem Bat

15. Vyhledávání v historii dříve zadaných příkazů

16. Nástroj fd

17. Integrace fzf s Vimem

18. Pokročilejší integrace s Vimem

19. Alternativa ke kombinaci fzf+Vim: plugin CtrlP

20. Odkazy na Internetu

1. Projekt fzf: command-line fuzzy finder

V předchozích dvou částech seriálu o utilitách, které je možné použít pro vylepšení a zrychlení práce v příkazové řádce, jsme se nejprve seznámili s nástrojem Go Bullet Train (GBT), jenž vylepšuje výzvu prompt [1]. Dále jsme si popsali některé možnosti nástrojů bat a ccat, které dokážou vypsat obsah souborů se zdrojovými kódy, konfiguračních souborů atd. se zvýrazněním syntaxe (jedná se tedy o rozšíření standardní utility cat) [2]. Ovšem existuje nepřeberné množství dalších užitečných nástrojů, které mohou práci v příkazové řádce zjednodušit a/nebo urychlit. Jedním z těchto nástrojů, jenž se navíc těší velké popularitě, je utilita nazvaná fzf neboli „command-line fuzzy finder“ (jméno je poněkud nepřesné, protože fzf lze použít například i v textovém editoru Vim atd.).

Poznámka: mimochodem – jedná se o utilitu, která je naprogramovaná v jazyce Go. O opět, jako tomu bylo i minule, je možné tuto utilitu zkombinovat s nástrojem df, který je pro změnu naprogramovaný v Rustu. Vidíme, že v některých oblastech se možnosti nabízené jazyky Go a Rust skutečně překrývají.

Obrázek 1: Použití nástroje fzf společně s minule popsanou utilitou bat při výběru souborů společně se zobrazením obsahu souboru, který je aktuálně uživatelem vybrán.

2. Princip činnosti nástroje fzf

Základní funkce fzf je ve skutečnosti velmi jednoduchá a vlastně i typicky „unixovská“. Nástroj fzf totiž na svém standardním vstupu (stdin) získá libovolný seznam, který následně zobrazí a nechá uživatele vybrat jednu položku z tohoto seznamu. Výsledek následně předá na svůj standardní výstup (stdout) pro další zpracování. To pravděpodobně nezní moc bombasticky ani příliš užitečně, ovšem samotný výběr položky ze seznamu je plně interaktivní a podporuje takzvaný „fuzzy“ výběr (použitelný je i pro ty uživatele, kteří neznají regulární výrazy). A především – největší síla fzf spočívá v tom, že tento nástroj je možné kombinovat s vybranými standardními příkazy, popř. dalšími utilitami, všude tam, kde je nutné vybrat hodnotu ze seznamu (platného například v nějakém kontextu). Možnosti využití jsou prakticky nepřeberné, takže si v dalších kapitolách přiblížíme jen nepatrný zlomek možného nasazení fzf.

Obrázek 2: Použití standardního barvového schématu na terminálu s tmavým pozadím.

3. Funkce nabízené projektem fzf

S principem základní činnosti fzf jsme se již seznámili v předchozí kapitole. Pojďme si ovšem popsat a následně ukázat praktické příklady použití fzf. Tuto utilitu lze použít například k těmto operacím:

  • Vyhledávání v seznamu souborů. Jedná se o základní operaci nabízenou utilitou fzf a už jen díky této vlastnosti se jedná o velmi užitečný nástroj.
  • Vyhledávání souborů společně s prohlížením jejich obsahu v kombinaci s utilitami cat, bat či ccat.
  • Vyhledávání v seznamu procesů, typicky použitelné například pro příkazkill nebo renice.
  • Vyhledávání v seznamu proměnných prostředí (environment variables).
  • Vyhledávání v historii příkazů (jedná se o vylepšení standardního procházení historií přes Ctrl+R, Ctrl+P atd.)
  • Vyhledávání v historii vzdálených počítačů, k nimž se uživatel již dříve připojil s využitím ssh.
  • Spolupráce s Gitem při mnoha operacích – přepnutí do jiné větve, přechod na vybraný commit atd.
  • Interaktivní varianta příkazu cd.
  • Integrace s textovým editorem Vim, například při vyhledávání souborů atd. Ovšem podobným způsobem je možné fzf integrovat i do dalších textových editorů spouštěných z terminálu.

4. Instalace fzf

Instalaci nástroje fzf je možné provést několika způsoby. V některých linuxových distribucích je tato utilita přímo součástí instalačních balíčků (společně s dalšími pomocnými skripty a mnohdy i integrací do Vimu), takže je instalace přímočará. Pro distribuce založené na Fedoře či RHELu (včetně CentOS):

$ sudo dnf install fzf

V případě, že fzf ve vaší distribuci nenaleznete, popř. pokud je v ní umístěna jen starší verze, je možné získat binární spustitelnou verzi fzf přímo z GitHub repositáře, konkrétně z adresy https://github.com/junegunn/fzf-bin/releases/tag/0.20.0. Získaný archiv pro zvolený operační systém a mikroprocesorovou architekturu postačuje rozbalit a umístit do nějakého adresáře, na který ukazuje proměnná prostředí PATH.

Poznámka: stažení, rozbalení a přímé použití binárního obrazu fzf je možné díky tomu, že překladač a linker programovacího jazyka Go implicitně provádí statické linkování.

Po instalaci provedené tímto způsobem by měla být k dispozici mj. i stránka s manuálem:

$ man fzf
 
fzf(1)                 fzf - a command-line fuzzy finder                fzf(1)
 
NAME
       fzf - a command-line fuzzy finder
 
SYNOPSIS
       fzf [options]
 
DESCRIPTION
       fzf is a general-purpose command-line fuzzy finder.
 
OPTIONS
   Search mode
       -x, --extended
              Extended-search  mode. Since 0.10.9, this is enabled by default.
              You can disable it with +x or --no-extended.
 
       -e, --exact
              Enable exact-match
 
       -i     Case-insensitive match (default: smart-case match)
 
       +i     Case-sensitive match
...
...
...

Alternativně je samozřejmě možné získat zdrojové kódy fzf a provést překlad přímo z nich. Pro tento účel postačuje mít nainstalovánu standardní sadu nástrojů jazyka Go a mít korektně nastaveny proměnné prostředí GOPATH a PATH:

$ export GOPATH=~/go
$ export PATH="$PATH:$GOPATH/bin"

Samotné stažení a překlad fzf je v tomto případě již jednoduché:

$ go get github.com/junegunn/fzf

Navíc je vhodné provést nastavení konfigurace vámi používaného shellu. Pro tento účel se použije skript install, popř. lze rekonfiguraci provést ručně.

5. Vyhledávání souborů

V případě, že nástroj fzf spustíme bez dalších parametrů, provede se explicitní příkaz, což je konkrétně příkaz find, který projde celou adresářovou strukturou dostupnou z aktuálního adresáře. Nakonec se seznam nalezených souborů a adresářů zobrazí v okně terminálu s tím, že uživatel může ihned zahájit procházení a především vyhledávání v seznamu:

Obrázek 3: Prakticky okamžité vyhledávání v domácím adresáři s přibližně 300 000 soubory.

Zápisem části jména souboru lze vyhledávání zúžit tak, jak je to ukázáno na dalším screenshotu:

Obrázek 4: Části jména odpovídající vyhledávanému výrazu se průběžně zvýrazňují.

Stiskem klávesy Enter se aktuálně vybraný soubor (tj. soubor, na kterém se nachází kurzor) přenese na standardní výstup a utilita fzf se ukončí. Pokud pouze potřebujeme utilitu ukončit bez výběru souborů, lze pro tento účel použít CTRL-C, CTRL-G nebo Esc.

6. Režim výběru několika souborů

Existuje ještě jeden způsob spuštění utility fzf. Pokud bude spuštění provedeno s přepínačem -m:

$ fzf -m

Bude možné klávesou Tab vybrat několik souborů, které se po stisku Enter přenesou na standardní výstup. Tímto způsobem lze například zajistit výběr zdrojových souborů, které se mají otevřít v textovém editoru Vim:

$ vim -o `fzf -m`

Samozřejmě nám nic nebrání si takový (či jakýkoli jiný podobný) příkaz uložit do .bashrc či .bash_profile ve formě aliasu:

$ alias e='vim -o `fzf -m`'

7. Syntaxe výrazů používaná při vyhledávání

Při vyhledávání v seznamu, resp. přesněji řečeno pro zúžení výběru, lze do vstupního řádku zadávat jednotlivá slova či jejich části oddělená mezerou. Nástroj fzf ze seznamu (například seznamu souborů) vybere pouze ty položky, které daná slova obsahují, popř. obsahují text, kde jsou písmena zapsaných slov obsažena. Mezi písmeny se ovšem mohou nacházet i další znaky. To znamená, že například při zápisu „module.py“ se nabídnou k výběru tyto soubory:

Tools/modulator/ScrolledListbox.py
Tools/modulator/Tkextra.py
modules2.py
test_module.py
...
...
...
Poznámka: právě z tohoto důvodu se používá termín fuzzy search nebo též fuzzy match.

Některé znaky však mají speciální význam:

# Příklad Stručný popis
1 module fuzzy search popsaný výše
2 'module vybere jen ty položky, které skutečně obsahují text „module“
3 ^module položka musí daným textem začínat
4 .py$ položka musí daným textem končit
5 !zip položka nesmí obsahovat daný text
6 !^test kombinace možností ! a ^ (položka nesmí začínat daným slovem)
7 !.jar$ kombinace možností ! a $ (položka nesmí končit daným slovem)

8. Vyhledávání procesů podle jejich jména

Pokud je instalace fzf provedena korektně, je možné vyhledávat procesy podle svého jména, popř. obsahu příkazové řádky. Postačuje napsat například:

$ kill -9<Tab>

Po stisku klávesy Tab by se měl ukázat seznam procesů s možností listování tímto seznamem, vyhledávání atd. (a to včetně výběru více procesů klávesou Tab):

Obrázek 5: Výpis procesů, které je možné „zabít“, včetně systemd :-)

Interně je tato funkce v BASHi implementována následovně:

_fzf_complete_kill() {
  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1
  local selected fzf
  fzf="$(__fzfcmd_complete)"
  selected=$(command ps -ef | sed 1d | FZF_DEFAULT_OPTS="--height ${FZF_TMUX_HEIGHT:-50%} --min-height 15 --reverse $FZF_DEFAULT_OPTS --preview 'echo {}' --preview-window down:3:wrap $FZF_COMPLETION_OPTS" $fzf -m | awk '{print $2}' | tr '\n' ' ')
  printf '\e[5n'
  if [ -n "$selected" ]; then
    COMPREPLY=( "$selected" )
    return 0
  fi
}
Poznámka: právě na tomto příkladu je pěkně vidět, jakým způsobem vznikne kombinací fzf s jiným nástrojem (zde konkrétně s ps a kill) zcela nová utilita.

9. Připojení ke vzdáleným strojům přes ssh

Mezi další užitečné funkce, zejména pro administrátory a devops, patří vyhledání v seznamu strojů, na které se již uživatel připojil s využitím ssh. Primárně se seznam těchto počítačů hledá v souboru ~/.ssh/known_hosts. Na příkazovou řádku je možné zadat jen:

$ ssh **<Tab>

Ihned po stisku klávesy Tab se zobrazí seznam strojů. Podobně je možné vyhledat počítače, ke kterým se uživatel připojil pomocí Telnetu (kupodivu i pro Telnet se dnes ještě najde uplatnění):

$ telnet **<Tab>

Obrázek 6: Vyhledávání v historii připojení ke vzdáleným strojům přes ssh.

Pokud vás opět zajímá, jak je tato funkce implementována, stačí se podívat na příslušný skript pro BASH:

_fzf_host_completion() {
  _fzf_complete '+m' "$@" < <(
    cat <(cat ~/.ssh/config ~/.ssh/config.d/* /etc/ssh/ssh_config 2> /dev/null | command grep -i '^\s*host\(name\)\? ' | awk '{for (i = 2; i <= NF; i++) print $1 " " $i}' | command grep -v '[*?]') \
        <(command grep -oE '^[[a-z0-9.,:-]+' ~/.ssh/known_hosts | tr ',' '\n' | tr -d '[' | awk '{ print $1 " " $1 }') \
        <(command grep -v '^\s*\(#\|$\)' /etc/hosts | command grep -Fv '0.0.0.0') |
        awk '{if (length($2) > 0) {print $2}}' | sort -u
  )
}

10. Práce s proměnnými prostředí

Pro příkazy export, unset a unalias lze vypsat seznam proměnných prostředí, pochopitelně opět s možností interaktivního výběru. Syntaxe zápisu je podobná, jako tomu bylo u příkazů ssh a telnet:

$ unset **<Tab>
$ export **<Tab>
$ unalias **<Tab>

Obrázek 7: Vyhledávání prováděné v seznamu proměnných prostředí.

11. Zjednodušení práce s Gitem

I při práci s Gitem někdy pracujeme se seznamem položek, z nichž je možné si vybírat. Týká se to například příkazu git checkout, který umožňuje přepnutí mezi větvemi (branch). Následuje výpis krátké BASHové funkce, která utilitu fzf využívá právě k zobrazení seznamu větví (včetně větví ve vzdáleném repositáři), mezi nimiž se lze přepínat:

fbr() {
  local branches branch
  branches=$(git branch --all | grep -v HEAD) &&
  branch=$(echo "$branches" |
           fzf -d $(( 2 + $(wc -l <<< "$branches") )) +m) &&
  git checkout $(echo "$branch" | sed "s/.* //" | sed "s#remotes/[^/]*/##")
}

Příklad použití je patrný z následujících screenshotů:

Obrázek 8: Přepínání mezi větvemi Git repositáře.

Obrázek 9: Přepínání mezi větvemi Git repositáře (výsledek z předchozího výběru).

Obrázek 10: Přepínání mezi větvemi Git repositáře.

Podobným způsobem lze vytvořit funkci pro přepnutí na zvolený commit, pochopitelně opět příkazem git checkout:

fcoc() {
  local commits commit
  commits=$(git log --pretty=oneline --abbrev-commit --reverse) &&
  commit=$(echo "$commits" | fzf --tac +s +m -e) &&
  git checkout $(echo "$commit" | sed "s/ .*//")
}

Obrázek 11: Přepínání mezi commity ve vybrané větvi Git repositáře.

12. Interaktivní příkaz cd

Další zajímavý způsob využití nalézá nástroj fzf při implementaci interaktivního příkazu cd. Zatímco klasický příkaz cd (který bývá vestavěn do shellu – je to tedy „builtin“ příkaz) očekává zadání názvu adresáře, upravený příkaz se chová odlišně. Pokud je zavolán bez parametrů, zobrazí seznam adresářů, z nichž je možné provést interaktivní výběr. Implementace, která je opět získaná z oficiálního seznamu rozšíření fzf, vypadá následovně:

function cd() {
    if [[ "$#" != 0 ]]; then
        builtin cd "$@";
        return
    fi
    while true; do
        local lsd=$(echo ".." && ls -p | grep '/$' | sed 's;/$;;')
        local dir="$(printf '%s\n' "${lsd[@]}" |
            fzf --reverse --preview '
                __cd_nxt="$(echo {})";
                __cd_path="$(echo $(pwd)/${__cd_nxt} | sed "s;//;/;")";
                echo $__cd_path;
                echo;
                ls -p --color=always "${__cd_path}";
        ')"
        [[ ${#dir} != 0 ]] || return 0
        builtin cd "$dir" &> /dev/null
    done
}

Příklad použití takto rozšířeného příkazu cd si můžeme ukázat na screenshotu terminálu:

Obrázek 12: Interaktivní příkaz cd.

Poznámka: nevýhodou je, že se ztrácí původní funkce příkazu cd ve chvíli, kdy je zavolán bez parametrů. Namísto přechodu do domácího adresáře se zobrazí seznam podadresářů. Samozřejmě vám ovšem nic nebrání v přejmenování funkce „cd“ na vhodnější název, například „icd“ („interactive cd“).

Obrázek 13: Interaktivní příkaz cd společně se zobrazením souborů.

13. Prohlížení obsahu souboru vybraného přes fzf

Velmi pěkná je kombinace možností utility fzf se standardním nástrojem cat, protože v tomto případě je možné zobrazit obsah souboru v pravé části plochy monitoru (takže se tady využijí i širokoúhlé monitory). Postačuje použít přepínač –preview, kterému se předá název utility použité ve funkci prohlížečky:

$ fzf --preview 'cat {}'

Praktičtější je však vytvoření nového příkazu přes alias, například příkazu fp (fuzzy preview):

$ alias fp="fzf --preview 'cat {}'"

Obrázek 14: Vyhledávání spojené se zobrazením obsahu souboru, zde konkrétně s využitím standardní utility cat.

14. Integrace fzf s projektem Bat

předchozí části seriálu o nástrojích vylepšujících práci s příkazovou řádkou jsme se seznámili s projektem bat a taktéž ccat. Vzhledem k tomu, že Bat se používá jako náhrada za standardní nástroj cat, můžeme i bat zkombinovat s fzf, a to například takto:

$ alias fp="fzf --preview '~/bin/bat {} --color=always'"

Obrázek 15: Vyhledávání spojené se zobrazením souboru se zvýrazněním syntaxe. Tentokrát je použit nástroj bat namísto standardního nástroje cat.

15. Vyhledávání v historii dříve zadaných příkazů

Možností nabízených kombinací fzf s dalšími nástroji je pochopitelně ještě více. Podívejme se na typický příklad – výše zmíněný interaktivní příkaz cd lze zkombinovat s prohlížením obsahu aktuálně vybraného souboru:

Obrázek 16: Interaktivní příkaz cd společně se zobrazením souborů.

Další skript je tentokrát velmi krátký. Umožňuje vyhledávání v historii dříve zadaných příkazů, opět s využitím fuzzy režimu (který je zde velmi užitečný, především ve chvíli, kdy si přesně nepamatujeme přesné pořadí slov v zadávaných příkazech):

fh() {
  eval $( ([ -n "$ZSH_NAME" ] && fc -l 1 || history) | fzf +s --tac | sed -r 's/ *[0-9]*\*? *//' | sed -r 's/\\/\\\\/g')
}

16. Nástroj fd

Nástroj fzf lze, a to velmi úspěšně, zkombinovat s utilitou nazvanou jednoduše https://github.com/sharkdp/fd. Jedná se o náhradu za příkaz find, která je však při běžném používání rychlejší. Přenastavení z výchozího používání find za fd se provede takto:

_fzf_compgen_path() {
  fd --hidden --follow --exclude ".git" . "$1"
}
 
_fzf_compgen_dir() {
  fd --type d --hidden --follow --exclude ".git" . "$1"
}

17. Integrace fzf s Vimem

V závěru dnešního článku se ještě zmíníme o integraci nástroje fzf s textovým editorem Vim. Nejprve se podívejme na spuštění fzf s výběrem souborů, které se otevřou ve Vimu. Připomeňme si, že volba -o instruuje Vim, aby soubory otevřel každý ve svém okně (okno–windows ve Vimu odpovídá určité ploše terminálu):

$ alias e='vim -o `fzf -m`'

Pokud preferujete otevření souborů v tabech, je úprava jednoduchá:

$ alias t='vim -p `fzf -m`'
Poznámka: mezi taby se lze přepínat například kombinací kláves Ctrl+PageUp a Ctrl+PageDown, popř. rychlejšími zkratkami gt a gT.

Další příkaz zobrazí seznam naposledy editovaných souborů, který je (většinou) uložen v souboru .viminfo:

v() {
  local files
  files=$(grep '^>' ~/.viminfo | cut -c3- |
          while read line; do
            [ -f "${line/\~/$HOME}" ] && echo "$line"
          done | fzf-tmux -d -m -q "$*" -1) && vim ${files//\~/$HOME}
}

Samozřejmě je taktéž možné využít klasickou verzi nástroje fzf, nikoli nutně fzf-tmux. Definice funkce v() se v tomto případě nepatrně pozmění:

v() {
  local files
  files=$(grep '^>' ~/temp/_viminfo | cut -c3- |
          while read line; do
            [ -f "${line/\~/$HOME}" ] && echo "$line"
          done | fzf -d -m -q "$*" -1) && vim ${files//\~/$HOME}
}

To ovšem není vše. Přímo v repositáři projektu fzf se nachází skript fzf.vim. Po načtení tohoto skriptu bude mít uživatel k dispozici nový příkaz :FZF, jenž otevře vyhledávání souborů. Pochopitelně je možné si tento příkaz namapovat na vhodnou klávesovou zkratku, například:

:map <F3> :FZF<CR>

18. Pokročilejší integrace s Vimem

Ve skutečnosti nabízí skript fzf.vim, o němž jsme se zmínili v předchozí kapitole, ještě další funkce. Ty jsou ovšem určeny spíše autorům pluginů, než koncovým uživatelům. A právě tyto funkce jsou použity v plnohodnotném pluginu fzf♥️vim. Po instalaci tohoto skriptu dostane uživatel textového editoru Vim k dispozici další příkazy založené právě na možnostech fzf:

# Příkaz Význam
1 :Files jako příkaz :FZF
2 :GFiles výběr souborů v Git repositáři
3 :GFiles? výběr změněných souborů v Git repositáři
4 :Buffers výběr z bufferů
5 :Colors výběr barvového schématu
6 :Ag výběr z výsledku https://github.com/ggreer/the_sil­ver_searcher
7 :Rg výběr z výsledku https://github.com/BurntSushi/ripgrep
8 :Lines přímý výběr z textových řádků dostupných Vimu (opět velmi užitečné)
9 :BLines přímý výběr z textových řádků v aktuálním bufferu
10 :Tags tagy vygenerované pro daný projekt
11 :BTags tagy pro současně otevřený buffer
12 :Marks seznam značek Vimu
13 :Windows seznam oken Vimu
14 :History historie otevřených souborů
15 :History: historie příkazů
16 :History/ historie vyhledávaných řetězců
17 :Snippets seznam snippetů (musí být nainstalová příslušný plugin)
18 :Commits vyhledávání v commitech (Git)
19 :BCommits vyhledávání v commitech (Git)
20 :Maps nastavená mapování
21 :Helptags výběr ze seznamu tagů určených pro pohyb v nápovědě (velmi užitečné!)
22 :Filetypes výběr ze seznamu typů souborů

19. Alternativa ke kombinaci fzf+Vim: plugin CtrlP

Kombinace fzf+Vim umožňuje rychlé výběry z různých seznamů, ovšem existuje i alternativní řešení založené čistě na VimScriptu, bez nutnosti mít k dispozici binární soubor fzf (ovšem za cenu výrazného zpomalení všech operací). Jedná se o modul ctrlp.vim.

Pro mnoho uživatelů textového editoru Vim se stal velmi užitečným přídavným modulem plugin nazvaný ctrlp.vim. Po instalaci tohoto pluginu je možné přes klávesovou zkratku Ctrl-P, která modulu dala název, vyhledávat soubory, buffery atd., a to i s využitím regulárních výrazů. Podobně jako samotný Vim, i plugin ctrlp.vim se může nacházet v několika režimech, mezi nimiž se uživatel přepíná několika klávesovými zkratkami (každý režim je reprezentován jinou výzvou – prompt). Tento plugin taktéž dokáže vytvářet soubory i adresáře, otevřít větší množství souborů současně apod. Jedná se tedy o alternativu k minule popsanému pluginu NERD Tree, i když způsob ovládání NERT Tree se značně odlišuje od ovládání ctrlp.vim – každému uživateli bude vyhovovat něco jiného (druhý jmenovaný plugin má nepochybně větší množství příkazů, ovšem zpočátku je poněkud nepřehledný – tento problém však po několika použitích zmizí).

Obrázek 17: Nápověda k pluginu ctrlp.vim.

Plugin ctrlp.vim se vyvolá v normálním režimu klávesovou zkratkou Ctrl-P (kterou však je možné samozřejmě přemapovat). Po použití této zkratky se zobrazí nové horizontálně rozdělené okno se speciálně naformátovaným stavovým řádkem. Změní se i vstupní řádek, do něhož je možné začít zapisovat jméno souboru, resp. přesněji řečeno část jména – mnohdy postačuje zadat několik počátečních písmen či počáteční a koncové písmeno – ihned při psaní se seznam souborů zmenšuje či zvětšuje tak, aby odpovídal zadané masce. Soubory se vyhledávají jak v aktuálním adresáři, tak i v podadresářích, což je výhodné především ve chvíli, kdy uživatel pracuje na rozsáhlejším projektu. K dispozici je velké množství klávesových zkratek, zejména pak:

Klávesová zkratka Význam
Ctrl+D přepnutí mezi vyhledáváním ve jménech souborů či i ve jménech souborů a adresářů (výchozí)
Ctrl+R přepnutí mezi použitím regexpů či tzv. řetězcového režimu (výchozí)
Ctrl+T otevření vybraného souboru v novém tabu
Ctrl+V vertikální rozdělení okna a otevření vybraného souboru
Ctrl+S horizontální rozdělení okna a otevření vybraného souboru
Ctrl+Z označení souboru (vedle jména souboru se zobrazí značka)
Ctrl+O otevření všech označených souborů
Tab automatické doplnění názvu adresáře
Esc zavření okna pluginu ctrlp.vim

Obrázek 18: Zvýraznění souborů na základě zapsané masky.

Obrázek 19: Výběr souborů pro editaci s využitím pluginu ctrlp.vim.

MIF obecny

V tabulce je mj. zmíněn tzv. řetězcový režim. Jedná se o způsob reprezentace masky bez explicitního použití regexpů. Po zadání řetězce „abc“ v řetězcovém režimu je tento řetězec interně chápán jako regulární výraz „a[^a]\{-}b[^b]\{-}c“, což sice vypadá poněkud složitě, nicméně řetězcový režim je v praxi dosti návykový :-)

Obrázek 20: Výběr souborů pro editaci s využitím pluginu ctrlp.vim.

20. Odkazy na Internetu

  1. Repositář projektu fzf
    https://github.com/junegunn/fzf
  2. fzf wiki – příklady použití
    https://github.com/junegun­n/fzf/wiki/examples
  3. fzf.vim
    https://github.com/junegunn/fzf.vim
  4. Vim universe. fzf – command line fuzzy finder (video)
    https://www.youtube.com/wat­ch?v=qgG5Jhi_Els
  5. FZF Vim integration
    https://github.com/junegun­n/fzf/blob/master/README-VIM.md
  6. fzf: Terminal Fuzzy Finder for Linux (video)
    https://www.youtube.com/watch?v=vt33Hp-4RXg
  7. Fzf Installation and Usage
    https://jdhao.github.io/2018/11/05/fzf_in­stall_use/
  8. Integrated Usage of VIM and Fuzzy Search Artifact FZF – From Simple to Advanced
    https://developpaper.com/integrated-usage-of-vim-and-fuzzy-search-artifact-fzf-from-simple-to-advanced/
  9. Navigating a filesystem quickly with fzf and fd
    https://mike.place/2017/fzf-fd/
  10. Nástroj fd
    https://github.com/sharkdp/fd
  11. Alternativy k batu
    https://github.com/sharkdp/bat/blob/mas­ter/doc/alternatives.md
  12. Ccat
    https://github.com/jingweno/ccat
  13. How to colorizing cat command output or files using ccat app on Linux or Unix system
    https://www.cyberciti.biz/howto/linux-unix-cat-command-with-colours/
  14. Go Bullet Train (GBT)
    https://github.com/tisnik/gbt
  15. bullettrain-sh
    https://github.com/caiogondim/bullet-train.zsh
  16. An oh-my-zsh shell theme based on the Powerline Vim plugin
    https://github.com/caiogondim/bullet-train.zsh
  17. Nerd fonts
    https://www.nerdfonts.com/
  18. nerd-fonts (repositář)
    https://github.com/ryanoasis/nerd-fonts
  19. Repositář projektu bat
    https://github.com/sharkdp/bat
  20. bat releases
    https://github.com/sharkdp/bat/re­leases
  21. Shell
    https://en.wikipedia.org/wi­ki/Shell_(computing)
  22. Minimalistická a rychlá příkazová řádka pro libovolný shell Starship
    https://www.root.cz/zpravic­ky/minimalisticka-a-rychla-prikazova-radka-pro-libovolny-shell-starship/
  23. Finally, a command line shell for the 90s
    http://fishshell.com/
  24. Bourne shell
    https://en.wikipedia.org/wi­ki/Bourne_shell
  25. Korn shell
    http://www.kornshell.org/
  26. Prompt Expansion
    http://zsh.sourceforge.net/Doc/Re­lease/Prompt-Expansion.html#Prompt-Expansion
  27. PS1 prompt explained for Linux/Unix
    https://www.linuxnix.com/linuxunix-shell-ps1-prompt-explained-in-detail/
  28. Bash $PS1 Generator2.0
    https://www.kirsle.net/wi­zards/ps1.html
  29. BASH Git Prompt
    https://github.com/magicmonty/bash-git-prompt
  30. Seznam vybraných Unicode fontů
    https://en.wikipedia.org/wi­ki/Unicode_font#List_of_U­nicode_fonts
  31. Unix History
    https://www.levenez.com/unix/
  32. C shell
    https://en.wikipedia.org/wiki/C_shell
  33. tput(1) – Linux man page
    https://linux.die.net/man/1/tput
  34. fc-list(1) – Linux man page
    https://linux.die.net/man/1/fc-list
  35. fc-cache(1) – Linux man page
    https://linux.die.net/man/1/fc-cache
  36. fc-query(1) – Linux man page
    https://linux.die.net/man/1/fc-query
  37. Unicode character recognition
    http://shapecatcher.com/
  38. Pygments
    https://pygments.org/
  39. GNU Source-highlight 3.1.8
    https://www.gnu.org/software/src-highlite/