Podczas wykonywania skryptów powłoki dane zwykle znajdują się w plikach rekordów jednowierszowych, takich jak csv. Obsługa tych danych za pomocą grepi jest naprawdę prosta sed. Ale często mam do czynienia z XML, więc naprawdę chciałbym mieć dostęp do skryptów do tych danych XML za pośrednictwem wiersza poleceń. Jakie są najlepsze narzędzia?

Zauważyłem, że xmlstarlet jest całkiem niezły w tego typu sprawach.

http://xmlstar.sourceforge.net/

Powinien być również dostępny w większości repozytoriów dystrybucji. Wprowadzający poradnik jest tutaj:

http://www.ibm.com/developerworks/library/x-starlet.html

Kilka obiecujących narzędzi:

• nokogiri : parsowanie HTML / XML DOM w Rubim przy użyciu selektorów XPath i CSS

• hpricot : przestarzałe

• fxgrep : używa własnej składni podobnej do XPath do wykonywania zapytań dotyczących dokumentów. Napisany w SML, więc instalacja może być trudna.

• LT XML : XML Toolkit pochodzące z narzędzi SGML, w tym sggrep, sgsort, xmlnormi innych. Używa własnej składni zapytania. Dokumentacja jest bardzo formalna. Napisany w C. LT XML 2 twierdzi, że obsługuje XPath, XInclude i inne standardy W3C.

• xmlgrep2 : proste i wydajne wyszukiwanie za pomocą XPath. Napisane w Perlu przy użyciu XML :: LibXML i libxml2.

• XQSharp : obsługuje XQuery, rozszerzenie XPath. Napisany dla .NET Framework.

• xml-coreutils : zestaw narzędzi Lairda Breyera będący odpowiednikiem GNU coreutils. Omówiono w interesującym eseju na temat tego, co powinien zawierać idealny zestaw narzędzi.

• xmldiff : Proste narzędzie do porównywania dwóch plików xml.

• xmltk : nie wydaje się mieć pakietu w debianie, ubuntu, fedorze lub macports, nie ma wydania od 2007 roku i używa nieprzenośnej automatyzacji kompilacji.

xml-coreutils wydaje się najlepiej udokumentowanym i najbardziej zorientowanym na UNIX.

Do znakomitej listy Josepha Holstena dodaję skrypt wiersza poleceń xpath, który jest dostarczany z biblioteką Perla XML :: XPath. Świetny sposób na wyodrębnienie informacji z plików XML:

 xpath -q -e '/entry[@xml:lang="fr"]' *xml

Jest też xml2i 2xmlpara. Pozwoli to zwykłym narzędziom do edycji ciągów na przetwarzanie XML.

Przykład. q.xml:

<?xml version="1.0"?>
<foo>
    text
    more text
    <textnode>ddd</textnode><textnode a="bv">dsss</textnode>
    <![CDATA[ asfdasdsa <foo> sdfsdfdsf <bar> ]]>
</foo>

xml2 < q.xml

/foo=
/foo=   text
/foo=   more text
/foo=   
/foo/textnode=ddd
/foo/textnode
/foo/textnode/@a=bv
/foo/textnode=dsss
/foo=
/foo=    asfdasdsa <foo> sdfsdfdsf <bar> 
/foo=

xml2 < q.xml | grep textnode | sed 's!/foo!/bar/baz!' | 2xml

<bar><baz><textnode>ddd</textnode><textnode a="bv">dsss</textnode></baz></bar>

PS Są też html2/ 2html.

Możesz użyć xmllint:

xmllint --xpath //title books.xml

Powinien być dołączony do większości dystrybucji, a także w pakiecie z Cygwin.

$ xmllint --version
xmllint: using libxml version 20900

Widzieć:

$ xmllint
Usage : xmllint [options] XMLfiles ...
        Parse the XML files and output the result of the parsing
        --version : display the version of the XML library used
        --debug : dump a debug tree of the in-memory document
        ...
        --schematron schema : do validation against a schematron
        --sax1: use the old SAX1 interfaces for processing
        --sax: do not build a tree but work just at the SAX level
        --oldxml10: use XML-1.0 parsing rules before the 5th edition
        --xpath expr: evaluate the XPath expression, inply --noout

Jeśli szukasz rozwiązania w systemie Windows, Powershell ma wbudowaną funkcję odczytu i zapisu XML.

test.xml:

<root>
  <one>I like applesauce</one>
  <two>You sure bet I do!</two>
</root>

Skrypt PowerShell:

# load XML file into local variable and cast as XML type.
$doc = [xml](Get-Content ./test.xml)

$doc.root.one                                   #echoes "I like applesauce"
$doc.root.one = "Who doesn't like applesauce?"  #replace inner text of <one> node

# create new node...
$newNode = $doc.CreateElement("three")
$newNode.set_InnerText("And don't you forget it!")

# ...and position it in the hierarchy
$doc.root.AppendChild($newNode)

# write results to disk
$doc.save("./testNew.xml")

testNew.xml:

<root>
  <one>Who likes applesauce?</one>
  <two>You sure bet I do!</two>
  <three>And don't you forget it!</three>
</root>

Źródło: /server/26976/update-xml-from-the-command-line-windows

Istnieją również xmlsed i xmlgrep z NetBSD xmltools!

http://blog.huoc.org/xmltools-not-dead.html

Zależy dokładnie od tego, co chcesz zrobić.

XSLT może być drogą do zrobienia, ale jest krzywa uczenia się. Wypróbuj xsltproc i pamiętaj, że możesz podać parametry.

Jest również saxon-lintz wiersza poleceń z możliwością korzystania z XPath 3.0 / XQuery 3.0. (Inne narzędzia wiersza polecenia używają XPath 1.0).

PRZYKŁADY:

http / html:

$ saxon-lint --html --xpath 'count(//a)' http://stackoverflow.com/q/91791
328

xml:

$ saxon-lint --xpath '//a[@class="x"]' file.xml

D. Bohdan utrzymuje repozytorium GitHub o otwartym kodzie źródłowym, które przechowuje listę narzędzi wiersza poleceń dla narzędzi tekstu strukturalnego, jest tam sekcja dotycząca narzędzi XML / HTML:

https://github.com/dbohdan/structured-text-tools#xml-html

XQuery może być dobrym rozwiązaniem. Jest (stosunkowo) łatwy do nauczenia i jest standardem W3C.

Polecam XQSharp dla procesora wiersza komend.

Najpierw użyłem xmlstarlet i nadal go używam. Gdy kwerenda pobiera trudne, muszę XML xpath2 i xquery funkcji wsparcia zwracam się do xidel http://www.videlibri.de/xidel.html

Odpowiednik Grepa

Możesz zdefiniować funkcję bash, powiedz „xp” („xpath”), która otacza kod Pythona3. Aby z niego skorzystać, musisz zainstalować python3 i python-lxml. Korzyści:

1. dopasowanie wyrażeń regularnych, którego brakuje np. xmllint.
2. Użyj jako filtru (w potoku) w linii poleceń

Jest to łatwe i wydajne w użyciu w następujący sposób:

xmldoc=$(cat <<EOF
<?xml version="1.0" encoding="utf-8"?>
<job xmlns="http://www.sample.com/">programming</job>
EOF
)
selection='//*[namespace-uri()="http://www.sample.com/" and local-name()="job" and re:test(.,"^pro.*ing$")]/text()'
echo "$xmldoc" | xp "$selection"
# prints programming

xp () wygląda mniej więcej tak:

xp()
{ 
local selection="$1";
local xmldoc;
if ! [[ -t 0 ]]; then
    read -rd '' xmldoc;
else
    xmldoc="$2";
fi;
python3 <(printf '%b' "from lxml.html import tostring\nfrom lxml import etree\nfrom sys import stdin\nregexpNS = \"http://exslt.org/regular-expressions\"\ntree = etree.parse(stdin)\nfor e in tree.xpath('""$selection""', namespaces={'re':regexpNS}):\n  if isinstance(e, str):\n    print(e)\n  else:\n    print(tostring(e).decode('UTF-8'))") <<< "$xmldoc"
}

Sed Equivalent

Rozważ użycie xq, które daje ci pełną moc "języka programowania" jq. Jeśli masz zainstalowany python-pip, możesz zainstalować xq za pomocą pip install yq , a następnie w poniższym przykładzie zamieniamy „Keep Accounts” na „Keep Accounts 2”:

xmldoc=$(cat <<'EOF'
<resources>
    <string name="app_name">Keep Accounts</string>
    <string name="login">"login"</string>
    <string name="login_password">"password："</string>
    <string name="login_account_hint">input to login</string>
    <string name="login_password_hint">input your password</string>
    <string name="login_fail">login failed</string>
</resources>
EOF
)
echo "$xmldoc" | xq '.resources.string = ([.resources.string[]|select(."#text" == "Keep Accounts") ."#text" = "Keep Accounts 2"])' -x

JEdit posiada wtyczkę o nazwie „XQuery”, która zapewnia funkcjonalność zapytań o dokumenty XML.

Niezupełnie wiersz poleceń, ale działa!