Concaténation de chaine pour Superkaramba. - Page 1

je ferais
A=`kde-config --version | grep KDE | sed -e 's/.*: //'` && B=`kde-config --version | grep Qt | sed -e 's/.*: //'` && echo "$A / $B"

aucune idée si ça marche

ça va faire sur chaque ligne, parce que chaque ligne sortie par sed finit par un \n

Pourquoi pas tout simplement le suivant?
echo `kde-config --version | grep KDE | sed -e 's/.*: //;s/-.*//'` / `kde-config --version | grep Qt | sed -e 's/.*: //'`
Chez moi ça donne l'effet voulu. (J'ai aussi rajouté la substitution pour virer le "-5.fc8 Fedora" dans la version de KDE.)

oui c'est vrai c'est mieux

Je n'en ai pas, j'ai testé directement dans le shell.

$(command) c'est mieux que `command` (même si c'est probablement pas posix)

bah non, c'est un caractère de plus, ça prête à confusion à cause du "$" qui est utilisé déjà partout en shell, et ça n'a aucun intérêt sauf quand on en imbrique plusieurs (cad rarement)

Bah le truc c'est que si tu veux réutiliser un bout de code qui contient des `` à l'intérieur d'une autre paire de ``, bah tu peux pas, alors autant prévoir à l'avance

prévoir à l'avance ? tu t'y prends à plusieurs reprises quand t'écris une commande entre `` toi ?

non mais genre quand t'as un bout de script qui traine, et tu veux le réutiliser dans un script plus compliqué, c'est mieux si t'as pas 50 modifications à faire dessus. (ou même tout simplement si tu réorganises du code à l'intérieur d'un script).

#dualmoo#

Heu t'as aucune modif à faire dessus si tu le réutilises dans un script compliqué... (et généralement un pauvre `` de quelques caractères, on ne le "réorganise" pas tous les jours). C'est quand même incroyable que même pour quelque chose d'aussi important qu'un choix entre $() et ``, on arrive à faire plus de deux posts et qu'on en arrive à raconter vraiment n'importe quoi...

Si tu réutilises un `` à l'intérieur d'un ``, justement, tu dois le modifier

En plus, l'autre avantage de la notation $(), c'est qu'on voit bien la parenthèse ouvrante et la parenthèse fermante (ce qui est pratique dans des longues lignes surchargées de symboles)

bah non, tu mets un $() la deuxième fois, aucune raison de le faire la première en revanche.

précisément non, cette notation utilise le $ qui est utilisé pour les variables, le calcul d'expressions numériques et les substitution ; c'est tout sauf lisible d'introduire une quatrième notation qui utilise ce symbole.

Zephyr (./10) :
bah non, c'est un caractère de plus, ça prête à confusion à cause du "$" qui est utilisé déjà partout en shell, et ça n'a aucun intérêt sauf quand on en imbrique plusieurs (cad rarement)

Ben le problème d'un truc qui se base sur les escapes plutôt que sur une balise fermante c'est pas seulement que tu peux pas imbriquer plusieurs `` facilement (c'est pas grave, au pire tu peux les échapper), c'est surtout que t'es obligé de rééchapper tous les caractères spéciaux, donc si t'avais $ échappé en \$ tu dois t'amuser à le rééchapper en \\$ (et si il avait déjà dû être rééchappé avant ça devient vite le bordel )

en même temps, à l'intérieur de $() t'es aussi obligé de doubler les \ : on peut vouloir mettre une ")" littérale à l'intérieur, donc il faut l'échapper, donc \ devient un caractère spécial, donc tous les \ doivent être échappés eux aussi.

Ben non t'as pas besoin de l'échapper plus que normalement, puisque la parenthèse et l'antislash sont déjà des caractères réservés du shell :
echo \Prix \(50 \$CAN\))))) vs echo $(echo $(echo $(echo \Prix \(50 \$CAN\`\`` vs echo `echo \`echo \\`echo \\\\\Prix \(50 \\\\$CAN\)\\
(les règles d'échappement sont vraiment immondes, tu peux écrire n'importe quel nombre d'antislash et il va essayer de l'interpréter tant bien que mal en évitant de faire une erreur )

Ah oui, je n'avais pas compris ta contrainte comme ça. On en revient à l'imbrication de `` l'un dans l'autre, d'une part ça ne sert jamais, d'une autre il suffit de faire ce que j'ai précisé à la première ligne du ./17. L'affirmation du ./9 telle quelle est stupide.

Non non non, même sans imbrication y a pas besoin d'échappement avec $() alors que `` en a besoin... L'avantage de `` par contre c'est justement que comme ça échappe pas automatiquement tu peux substituer des trucs avant l'exécution de la commande, mais ça sert rarement en pratique.

quelles substitutions ? quand j'utilise ``, la majorité du temps c'est pour faire un `grep $pattern file` ou autre expression particulièrement complexe, et la substitution de "$pattern" se fait bien après l'évaluation (ou alors on ne parle pas le même vocabulaire et je n'ai pas compris ta remarque)

ah oui tiens, bon ben cette saloperie d'escape sert à rien en pratique en plus (à part à permettre les `` imbriqués)

Accessoirement ça fait plusieurs posts qu'on ne parle pas de la même chose : ce n'est pas tant à cause d'un problème d'échappement que je trouvais $() pas lisible, c'est tout simplement que $ est déjà over-utilisé, et que différencier "$(echo)" de "${echo}" ou de "$((echo))" dans un gros code source, c'est que du bonheur. La syntaxe `` présente au moins l'avantage d'être unique (à ma connaissance).

Oui, mais `` a d'autres problèmes qui rendent le code moins lisible... Et si tu as la coloration syntaxique y a aucune confusion possible entre $(echo) et ${echo} (je sais pas si c'est le cas de tous les éditeurs, mais vim colorie ${echo} d'une seule couleur comme $echo, alors que le echo de $(echo) est colorié comme une commande normale)

Kate fait la même chose.