Lorsque vous effectuez des scripts shell, les données se trouvent généralement dans des fichiers d'enregistrements sur une seule ligne tels que csv. C'est vraiment simple de gérer ces données avec grepet sed. Mais je dois souvent m'occuper de XML, donc j'aimerais vraiment avoir un moyen d'accéder par script à ces données XML via la ligne de commande. Quels sont les meilleurs outils?

J'ai trouvé que xmlstarlet était assez bon dans ce genre de choses.

http://xmlstar.sourceforge.net/

Devrait également être disponible dans la plupart des référentiels de distribution. Un tutoriel d'introduction est ici:

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

Quelques outils prometteurs:

• nokogiri : analyse des DOM HTML / XML dans ruby ​​à l'aide des sélecteurs XPath et CSS

• hpricot : obsolète

• fxgrep : utilise sa propre syntaxe de type XPath pour interroger des documents. Écrit en SML, l'installation peut donc être difficile.

• LT XML : boîte à outils XML dérivé d'outils de SGML, y compris sggrep, sgsort, xmlnormet d' autres. Utilise sa propre syntaxe de requête. La documentation est très formelle. Écrit en C. LT XML 2 revendique la prise en charge de XPath, XInclude et d'autres normes W3C.

• xmlgrep2 : recherche simple et puissante avec XPath. Écrit en Perl en utilisant XML :: LibXML et libxml2.

• XQSharp : prend en charge XQuery, l'extension de XPath. Rédigé pour le .NET Framework.

• xml-coreutils : boîte à outils de Laird Breyer équivalente à GNU coreutils. Discuté dans un essai intéressant sur ce que la boîte à outils idéale devrait inclure.

• xmldiff : outil simple pour comparer deux fichiers xml.

• xmltk : ne semble pas avoir de paquet dans debian, ubuntu, fedora ou macports, n'a pas eu de version depuis 2007 et utilise une automatisation de construction non portable.

xml-coreutils semble le mieux documenté et le plus orienté UNIX.

À l'excellente liste de Joseph Holsten, j'ajoute le script de ligne de commande xpath fourni avec la bibliothèque Perl XML :: XPath. Un excellent moyen d'extraire des informations à partir de fichiers XML:

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

Il y a aussi xml2et 2xmlpaire. Cela permettra aux outils d'édition de chaînes habituels de traiter XML.

Exemple. 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 Il y a aussi html2/ 2html.

Vous pouvez utiliser xmllint:

xmllint --xpath //title books.xml

Doit être fourni avec la plupart des distributions et est également fourni avec Cygwin.

$ xmllint --version
xmllint: using libxml version 20900

Voir:

$ 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

Si vous recherchez une solution sous Windows, Powershell dispose d'une fonctionnalité intégrée pour lire et écrire du XML.

test.xml:

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

Script 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>

Source: /server/26976/update-xml-from-the-command-line-windows

Il y a aussi xmlsed et xmlgrep des xmltools NetBSD!

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

Cela dépend exactement de ce que vous voulez faire.

XSLT est peut-être la voie à suivre, mais il y a une courbe d'apprentissage. Essayez xsltproc et notez que vous pouvez transmettre des paramètres.

Il existe également une saxon-lintligne de commande avec la possibilité d'utiliser XPath 3.0 / XQuery 3.0. (D'autres outils de ligne de commande utilisent XPath 1.0).

EXEMPLES :

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 maintient un référentiel GitHub open source qui conserve une liste d'outils de ligne de commande pour les outils de texte structuré, il y a une section pour les outils XML / HTML:

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

XQuery pourrait être une bonne solution. C'est (relativement) facile à apprendre et c'est une norme du W3C.

Je recommanderais XQSharp pour un processeur de ligne de commande.

J'ai d'abord utilisé xmlstarlet et je l'utilise toujours. Lorsque la requête devient difficile, j'ai besoin de la prise en charge des fonctionnalités xpath2 et xquery de XML.Je me tourne vers xidel http://www.videlibri.de/xidel.html

Equivalent Grep

Vous pouvez définir une fonction bash, par exemple "xp" ("xpath") qui encapsule du code python3. Pour l'utiliser, vous devez installer python3 et python-lxml. Avantages:

1. regex correspondant qui vous manque par exemple xmllint.
2. Utiliser comme filtre (dans un tube) sur la ligne de commande

C'est facile et puissant à utiliser comme ceci:

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 () ressemble à ceci:

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"
}

Équivalent Sed

Pensez à utiliser xq qui vous donne toute la puissance du "langage de programmation" jq. Si vous avez installé python-pip, vous pouvez installer xq avec pip install yq , puis dans l'exemple ci-dessous, nous remplaçons "Keep Accounts" par "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 a un plugin appelé "XQuery" qui fournit des fonctionnalités d'interrogation pour les documents XML.

Pas tout à fait la ligne de commande, mais ça marche!