Dvacátá část seriálu o programovacím jazyku Clojure i o knihovnách, které jsou pro tento jazyk dostupné, se od předchozích částí odlišuje, protože se nebudeme zabývat popisem nových knihoven, ale vrátíme se na samotné začátky programování v Clojure. Zmíníme se totiž o některých tipech a tricích při práci s řetězci.
1. Programovací jazyk Clojure – triky při práci s řetězci
2. Funkce pro práci s řetězci ve jmenném prostoru clojure.string
3. Metody třídy java.lang.String
4. Konstrukce řetězce z několika částí
5. Test, zda je řetězec prázdný
6. Převody mezi verzálkami a minuskami
7. Funkce clojure.string/escape
8. Funkce clojure.string/replace
9. Funkce pro spojování a rozdělování řetězců
10. Řetězce chápané jako sekvence znaků
11. Odkazy na předchozí části tohoto seriálu
Již v perexu tohoto článku bylo napsáno, že se v dnešní části seriálu o programovacím jazyce Clojure i o knihovnách, které pro tento jazyk existují, budeme zabývat popisem některých tipů a triků využitelných při práci s řetězci. Je tomu tak ze dvou důvodů – řetězce a jejich zpracování jsou nedílnou součástí většiny nenumerických algoritmů a navíc jsem z dotazů zjistil, že i ti vývojáři, kteří v jazyku Clojure začali programovat, mnohdy nevyužívají všech možností nabízených zejména funkcemi ve jmenném prostoru clojure.string a zbytečně pak musí volat metody třídy java.lang.String (tedy využívat tzv. java interop), což ovšem není totéž (už jen z toho důvodu, že většina funkcí pro práci s řetězci bez problému „přežije“ předání hodnoty nil, zatímco v případě javovských metod tomu tak pochopitelně není).
Důležité je si ihned na začátku práce s řetězci uvědomit, že řetězce jsou – ostatně podobně jako je tomu i v Javě – konstantní a tudíž i neměnné (immutable), což sice v některých případech může vést k tvorbě neefektivních operací, kterým se však lze v Clojure většinou zcela vyhnout. To, že jsou řetězce neměnné, však zjednodušuje tvorbu bezpečných vícevláknových aplikací, řetězce lze efektivně využívat jako klíče do asociativních polí atd. atd., takže přednosti většinou převažují nad zápory. Pokud by tomu tak nebylo a některý algoritmus by skutečně vyžadoval modifikovatelné řetězce, je možné využít možností knihoven java.lang.StringBuffer a java.lang.StringBuilder [1] [2].
Většina užitečných funkcí pro práci s řetězci se nachází ve jmenném prostoru clojure.string. Jedná se o následující funkce:
| # | Funkce | Kapitola |
|---|---|---|
| 1 | blank? | 5 |
| 2 | capitalize | 6 |
| 3 | escape | 7 |
| 4 | join | 9 |
| 5 | lower-case | 6 |
| 6 | re-quote-replacement | |
| 7 | replace | 8 |
| 8 | replace-first | 8 |
| 9 | reverse | |
| 10 | split | 9 |
| 11 | split-lines | 9 |
| 12 | trim | |
| 13 | trim-newline | |
| 14 | triml | |
| 15 | trimr | |
| 16 | upper-case | 6 |
V následujících kapitolách budu předpokládat, že prvním příkazem skriptu bude načtení jmenného prostoru clojure.string s aliasem str:
user=> (require '[clojure.string :as str]) nil
Poznámka: nepoužívejte příkaz use namísto require, protože by došlo ke smíchání symbolů z načítaného modulu se symboly vaší aplikace, což znesnadňuje ladění (aneb „use considered harmful“.
Kromě výše zmíněných funkcí dostupných ze jmenného prostoru clojure.string lze v programovacím jazyce Clojure díky existenci tzv. Java interop volat i metody třídy java.lang.String. Platí přitom, že řetězec vytvořený v Clojure či řetězcový literál je současně i javovským řetězcem se všemi z toho vyplývajícími vlastnostmi a omezeními (kódování UTF-16 atd.):
user=> (type "Hello World") java.lang.String
Připomeňme si, že volání metod nějakého javovského objektu vypadá následovně:
(.názevMetody objekt parametry)
Takže lze například použít formu:
user=> (.length "Hello world!") 12 user=> (.getClass "Hello world!") java.lang.String user=> (.substring "Hello world!" 5 8) " wo" user=> (.hashCode "Hello world!") -52966915 user=> (.charAt "Hello world!" 11) \!
Popis všech metod třídy java.lang.String lze nalézt na adrese http://docs.oracle.com/javase/7/docs/api/java/lang/String.html.
Poměrně často se setkáme s nutností zkonstruovat řetězec z několika částí popř. převést jiný objekt (přesněji řečeno jinou hodnotu) na řetězec. Zde je řešení snadné, protože je možné použít víceúčelovou funkci nazvanou str. Tato funkce akceptuje libovolný počet parametrů libovolných typů, dokonce se ani nemusíte bát ji zavolat s hodnotou nil (ostatně předávání této hodnoty do mnoha funkcí bez kontroly je pro jazyk Clojure idiomatické, na rozdíl od Javy):
user=> (str nil) "" user=> (str 1 2 3) "123" user=> (str [1 2 3]) "[1 2 3]" user=> (str "first" "second" "third") "firstsecondthird" user=> (str "first" "second") "firstsecond"
Zastavme se u chvíli u posledního příkladu. V mnoha aplikacích potřebujeme vypsat na standardní výstup nějaké hodnoty, což (samozřejmě) zajistí funkce println:
user=> (println "first" "second") first second nil
Pokud z nějakého důvodu nevyhovuje oddělení hodnot mezerou, pomůže právě funkce str:
user=> (println (str "first" "second")) firstsecond nil
Pro test, zda je řetězec prázdný, je možné použít buď metodu .isEmpty třídy java.lang.String, funkci empty? nebo funkci clojure.string/blank? (povšimněte si otazníku na konci názvu této funkce). Čím se tyto možnosti od sebe odlišují? Hlavním rozdílem je, že clojure.string/blank? bez problémů akceptuje hodnotu nil (považovanou za prázdný řetězec), což je v mnoha aplikacích preferováno. Další rozdíl spočívá v tom, že clojure.string/blank? vrací pravdivostní hodnotu true i pro řetězce obsahující pouze bílé znaky, na rozdíl od empty?:
user=> (empty? nil) true user=> (empty? "") true user=> (empty? " ") false user=> (empty? "Hello world!") false
user=> (str/blank? nil) true user=> (str/blank? "") true user=> (str/blank? " ") true user=> (str/blank? "Hello world!") false
user=> (.isEmpty nil) NullPointerException clojure.lang.Reflector.invokeNoArgInstanceMember (Reflector.java:301) user=> (.isEmpty "") true user=> (.isEmpty " ") false user=> (.isEmpty "Hello world!") false
V některých aplikacích je nutné převádět minusky na verzálky a naopak. Opět je možné si vybrat mezi metodami třídy java.lang.String a funkcemi jmenného prostoru clojure.string. Podívejme se ihned na příklady, z nichž je použití těchto funkcí pravděpodobně zřejmé:
user=> (.toLowerCase "Hello world!") "hello world!" user=> (str/upper-case "Hello world!") "HELLO WORLD!" user=> (str/lower-case "Hello world!") "hello world!" user=> (str/capitalize "Hello world!") "Hello world!" user=> (str/capitalize "HeLLo wOrld!") "Hello world!
A jak jsme na tom s nabodeníčky? Docela dobře, však jsme v 21. století:
user=> (str/upper-case "Příliš žluťoučký kůň úpěl ďábelské ódy") "PŘÍLIŠ ŽLUŤOUČKÝ KŮŇ ÚPĚL ĎÁBELSKÉ ÓDY" user=> (str/lower-case "Příliš žluťoučký kůň úpěl ďábelské ódy") "příliš žluťoučký kůň úpěl ďábelské ódy" user=> (str/capitalize "Příliš žluťoučký kůň úpěl ďábelské ódy") "Příliš žluťoučký kůň úpěl ďábelské ódy"
Konečně se dostáváme k zajímavějším funkcím. Poměrně užitečnou funkcí je funkce nazvaná clojure.string/escape, které lze předat převodní tabulku (znak na znak, znak na řetězec atd.); jedná se vlastně o určitou obdobu funkce tr. Zmíněná převodní tabulka má podobu mapy:
user=> (str/escape "Hello world!" {\l "*"})
"He**o wor*d!"
user=> (str/escape "Hello world!" {\l "*" \o \-})
"He**- w-r*d!"
Podívejme se na použití této funkce ve skutečné aplikaci, konkrétně na místě, kde je zapotřebí nahrazovat trojici znaků, které mají speciální význam v XML či HTML:
(defn escape-xml-chars
[string]
(clojure.string/escape string
{\< "<", \> ">", \& "&"}))
(escape-xml-chars "Hello <world>")
"Hello <world>
Jedna z nejužitečnějších funkcí při práci s řetězci je funkce clojure.string/replace. V nejjednodušší podobě se této funkci předává řetězec, nahrazovaná sekvence znaků a řetězec, který se použije namísto nahrazované sekvence znaků:
user=> (str/replace "Hello world!" " " "_") "Hello_world!" user=> (str/replace "Hello world!" "o" "0") "Hell0 w0rld!" user=> (str/replace "Hello world!" " " "___") "Hello___world!" user=> (str/replace "Hello world!" "world" "Clojure") "Hello Clojure!"
V alternativní podobě je možné namísto nahrazovaného řetězce použít regulární výraz. Připomeňme si, že pro regulární výrazy v Clojure existuje speciální zápis se znakem #. Díky tomu není nutné mnoho znaků ve výrazu quotovat tak, jako je tomu v mnoha dalších programovacích jazycích:
user=> (str/replace "Hello world!" #"[a-z]" ".") "H.... .....!" user=> (str/replace "Hello world!" #"[A-Za-z]+" "[word]") "[word] [word]!" user=> (str/replace "Hello world!" #"\w+" "[word]") "[word] [word]!" user=> (str/replace "Hello world!" #"\s" "_") "Hello_world!"
Nejzajímavější je ovšem třetí podoba, kde se namísto nahrazovacího řetězce použije funkce, typicky funkce anonymní. V této funkci je možné použít speciální jména parametrů %1 atd., do nichž se uloží hodnoty zachycené do příslušného registru. V následujícím příkladu se *slovo* zvýrazní jako slovo, podobně jako je tomu v AsciiDocu (povšimněte si použití zpětného lomítka před znakem hvězdičky):
user=> (str/replace "Hello world!" #"\*(\w+)\*" #(str "<strong>" (second %1) "</strong>")) "Hello world!" user=> (str/replace "Hello *world*!" #"\*(\w+)\*" #(str "<strong>" (second %1) "</strong>")) "Hello <strong>world</strong>!" user=> (str/replace "*Hello* *world*!" #"\*(\w+)\*" #(str "<strong>" (second %1) "</strong>")) "<strong>Hello</strong> <strong>world</strong>!"
Kdo se ještě neztratil, může si vyzkoušet následující regulární výraz, který bude posléze využitý:
(def http-regexp
#"https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)")
user=> (re-find http-regexp "xyzzy")
nil
user=> (re-find http-regexp "Podivejte se na http://www.root.cz!")
["http://www.root.cz" "www." ""]
user=> (re-find http-regexp "Na http://www.google.com jsem to nenasel.")
["http://www.google.com" "www." ""]
Nyní regulární výraz navázaný na symbol http-regexp využijeme ve funkci, která v řetězci najde URL a nahradí je příslušnou HTML značkou:
(defn create-links
[string]
(let [href (re-find http-regexp string)]
(if href
(str/replace string http-regexp (str "<a href='" (first href) "'>" (first href) "</a>"))
string)))
user=> (create-links "Podivejte se na http://www.root.cz!")
"Podivejte se na <a href='http://www.root.cz'>http://www.root.cz</a>!"
user=> (create-links "Na http://www.google.com jsem to nenasel.")
"Na <a href='http://www.google.com'>http://www.google.com</a> jsem to nenasel."
Pro spojení řetězců se používá funkce clojure.string/join, které je možné v prvním parametru předat znak (či řetězec), který se vloží mezi spojované části. Použití této funkce je snadné:
user=> (str/join (range 1 10)) "123456789" user=> (str/join "," (range 1 10)) "1,2,3,4,5,6,7,8,9"
Pro rozdělení řetězce na části lze použít funkci clojure.string/split. V mnoha případech je však snadnější použít clojure.string/split-lines, která řetězec rozdělí na znacích pro nový řádek. To je velmi výhodné, například při načítání konfiguračních či databázových souborů:
user=> (str/split-lines "Hello\nworld") ["Hello" "world"]
Podívejme se na praktický příklad:
(slurp "/etc/passwd")
(str/split-lines (slurp "/etc/passwd"))
(for [line (str/split-lines (slurp "/etc/passwd"))]
(first (str/split line #":")))
Výsledek (jména uživatelů) lze setřídit:
(sort
(for [line (str/split-lines (slurp "/etc/passwd"))]
(first (str/split line #":"))))
Řetězce lze funkcí seq rozdělit na sekvenci znaků a použít tak všechny funkce, které Clojure pro práci se sekvencemi nabízí (třeba i funkci frequencies):
user=> (seq "hello world!")
(\h \e \l \l \o \space \w \o \r \l \d \!)
user=> (-> (concat (range 1 12) (range 3 10) [6]) frequencies)
{7 2, 1 1, 4 2, 6 3, 3 2, 2 1, 11 1, 9 2, 5 2, 10 1, 8 2}
user=> (frequencies (seq "hello world!"))
{\space 1, \! 1, \d 1, \e 1, \h 1, \l 3, \o 2, \r 1, \w 1}
Stalo se již zvykem uvést odkazy na všechny předchozí části tohoto seriálu. Tento zvyk samozřejmě dodržíme i dnes:
Root.cz (www.root.cz)
Informace nejen ze světa Linuxu. ISSN 1212-8309
Copyright © 1998 – 2018 Internet Info, s.r.o. Všechna práva vyhrazena. Powered by Linux.
