Ce script préserve des interlignes dans un fichier texte

[musher0]

Bonjour !

Comme le titre l'indique.

(Extrait du script )

# Objectif : réduire le nombre de doubles interlignes dans un fichier texte.
#
## Usage : 1stLine-2ndLine.sh fichier.txt (Utiliser autant de fois que nécessaire.)
#
## Explication -- Je n'ai pas trouvé d'utilitaire ou de commande pour seulement
# « RÉDUIRE le nombre d'interlignes » dans un fichier texte. Mais il existe plein
# d'astuces pour toutes les éliminer. Alors voilà, ce script répond à un besoin.
#
# Si un fichier texte ne comporte aucune interligne, ou qu'il en comporte trop,
# le texte devient difficile à lire. Il vaut la peine de conserver quelques interlignes
# pour aider le lecteur à se concentrer sur le contenu.
##########

Chemin suggéré : ~/my-applications/bin/1stLine-2ndLine.sh

Quand je dis qu'on en trouve pas, c'est pas une blague. J'ai passé des heures et des
heures à me faire référencer par divers moteurs de recherche les même commandes et
astuces dans divers langages informatiques, même, pour tout éliminer le blanc d'un
texte.

Il faut dire que ces gens-là sont au départ des informaticiens, pas des réviseurs. On
dirait qu'ils ne sont jamais posé la question de « comment on lit. » Il faut du blanc, des
taquets, des interlignes, pour que le lecteur puisse bien distinguer le fond de la forme, et
ainsi moins se casser la tête quand il lit le texte. Et mieux le comprendre, et plus vite,
tiens donc.

Je crois avoir passé autant d'heures à tenter de conceptualiser le double interligne. On en
met autant comme autant des interlignes, on tape la touche « Entrer » à qui mieux mieux
quand on rédige.

Mais comment comprendre l'espace vertical, pour que ça marche dans un script ? Là
encore, peu d'aide sur le sujet, à part la suggestion de triturer le fameux « IFS » ("internal
field separator"). Normalement c'est l'espace -- horizontal -- entre les mots. Si vous le
changez pour un retour de chariot, tous les mots seront alignés à la verticale sur la
page !! C'est amusant, ça peut aller pour un texte court, et après on fait l'inverse, mais
cela ne résoud pas le problème.

Finalement j'ai trouvé je ne me souviens plus sur quel forum une remarque d'un type qui
avait trouvé moyen de charger deux lignes à la fois dans une boucle while. Et la
s'est allumée !!!

Le concept : on charge les lignes deux par deux. Si toutes les deux ont moins de deux
caractères, on n'en émet qu'une -- dans un fichier temporaire. Les lignes de plus de deux
caractères sont émises normalement, toujours dans ce fichier temporaire.

On lit le fichier tempo via l'utilitaire cat, ou encore dans less, par ex., et s'il contient
encore trop de blanc, on recommence le procédé. Si on fait ça 2, 3, 4 fois, on finit par
avoir une collection de fichiers *.txt.tmp.tmp.tmp, etc. Mais cela vaut mieux que
d'écraser toujours le même, des fois que le résultat agréable à l'oeil serait dans l'avant-
dernier fichier temporaire.

J'espère que ce script ne nuira pas trop à votre croissance personnelle !!!! Assez
grogné: on m'a fait sortir de ma caverne en plein hiver pour même pas une framboise,
dit l'ours.

Bonne fin de journée !

[Argolance]

Bonjour,
Merci musher0.
J'ai déjà eu en effet besoin d'un tel script.
La commande (trouvée sur le net dans "SCRIPTS D'UNE LIGNE UTILES POUR SED") m'a correctement rendu ce service... et bien d'autres encore:

Code: Select all

sed -i '$!N; /^\(.*\)\n\1$/!P; D' /mon/fihcier/texte

Je sais que tu es plutôt awk que sed, mais à toutes fins utiles, voici le contenu de cette page, converti en texte simple, dont je me sers très souvent:

-------------------------------------------------------------------------
SCRIPTS D'UNE LIGNE UTILES POUR SED (ÉDITEUR DÉFILANT UNIX) Dec. 29, 2005

ESPACEMENT DE FICHIER:

# espacer en double un fichier
sed G

# espacer en double un fichier qui a déjà des lignes vides.
# Le fichier de sortie n'aura jamais plus qu'une ligne vide
# entre les lignes de texte.
sed 'G;G'

# défaire le double-espacement (assumons les lignes paires comme
# étant toujours vides)
sed 'n;d'

# espacer en triple un fichier
sed 'G;G'

# insérer une ligne vide au-dessus de chaque ligne qui contient "regex"
sed '/regex/{x;p;x;}'

# insérer une ligne vide sous chaque ligne qui contient l'expression
# régulière "regex"
sed '/regex/G'

# insérer une ligne vide au-dessus et au-dessous de chaque ligne qui
# contient "regex"
sed '/regex/{x;p;x;G;}'

NUMÉROTATION:

# numéroter chaque ligne du fichier (appuyé simplement à gauche).
# L'utilisation d'une tabulation (voir la note sur '\t' à la fin
# de ce texte) au lieu d'un espace préservera les marges.
sed = nomdefichier | sed 'N;s/\n/\t/'

# numéroter chaque ligne d'un fichier (numéro à gauche, appuyé à droite)
sed = nomdefichier | sed 'N; s/^/ /; s/ *\(.\{6,\}\)\n/\1 /'

# numéroter chaque ligne d'un fichier, mais afficher le numéro de ligne
# seulement si la ligne n'est pas vide.
sed '/./=' nomdefichier | sed '/./N; s/\n/ /'

# compter les lignes (émulation de "wc -l")
sed -n '$='

CONVERSION de TEXTE et SUBSTITUTION:

# ENVIRONEMENT UNIX: conversion des retour de chariot (CR/LF) au format Unix.
sed 's/.$//' # assume que toutes les lignes se terminent avec CR/LF
sed 's/^M$//' # sous bash/tcsh, enfoncer Ctrl-V puis Ctrl-M
sed 's/\x0D$//' # fonctionne sous ssed, gsed 3.02.80 ou plus récent

# ENVIRONEMENT UNIX: conversion des retour de chariot UNIX (LF) au format DOS.
sed "s/$/`echo -e \\\r`/" # ligne de commande sous ksh
sed 's/$'"/`echo \\\r`/" # ligne de commande sous bash
sed "s/$/`echo \\\r`/" # ligne de commande sous zsh
sed 's/$/\r/' # gsed 3.02.80 ou plus haut

# ENVIRONMENT DOS: convertir les retour de chariot Unix (LF) au format DOS.
sed "s/$//" # méthode 1
sed -n p # méthode 2

# ENVIRONMENT DOS: convertir les retour de chariot DOS (CR/LF) au format Unix.
# Peut seulement être utilisé avec UnxUtils sed, version 4.0.7 ou plus récente.
# La version UnxUtils peut être utilisée avec le modificateur "--text"
# qui apparaît lorsque vous utiliser le modificateur "--help". Sinon,
# la conversion des retours de chariot DOS vers la version UNIX ne peut
# se faire avec SED dans un environnement DOS. Utiliser 'tr' au lieu.
sed "s/\r//" infile >outfile # UnxUtils sed v4.0.7 ou plus récent
tr -d \r <infile >outfile # GNU tr version 1.22 ou plus récent


# éliminer tout espace blanc (espaces, tabulations) à la gauche
# de chaque ligne, et appuyer le résultat à la marge gauche
sed 's/^[ \t]*//' # voir note au sujet de '\t' à la fin de ce fichier

# éliminer tout espace blanc (espaces, tabulations) à la fin de chaque ligne
sed 's/[ \t]*$//' # voir note au sujet de '\t' à la fin de ce fichier

# éliminer tout espace blanc des deux bouts de chaque ligne
sed 's/^[ \t]*//;s/[ \t]*$//'

# insérer 5 espaces au début de chaque ligne (décalage de page vers la droite)
sed 's/^/ /'

# aligner tout le texte à la droite sur la 79e colonne
sed -e :a -e 's/^.\{1,78\}$/ &/;ta' # mettre à 78 plus un espace

# centrer tout le texte sur le centre de la 79e colonne. Dans la première
# méthode, tout espace au début de la ligne est significatif, et
# des espaces sont ajoutés à la fin de la ligne. Dans la deuxième
# méthode, les espaces précédant les lignes sont ignorés pendant
# le processus de centrage, et aucun espace n'est ajouté à la fin des lignes.
sed -e :a -e 's/^.\{1,77\}$/ & /;ta' # méthode 1
sed -e :a -e 's/^.\{1,77\}$/ &/;ta' -e 's/\( *\)\1/\1/' # méthode 2

# substituer (trouver et remplacer) "foo" avec "bar" sur chaque ligne
sed 's/foo/bar/' # replacer seulement la première instance de la ligne
sed 's/foo/bar/4' # replacer seulement la quatrième instance de la ligne
sed 's/foo/bar/g' # replacer toutes les instances de la ligne
sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' # replacer l'avant-dernier cas
sed 's/\(.*\)foo/\1bar/' # replacer seulement le dernier cas

# substituer "foo" par "bar" SEULEMENT pour les lignes contenant "baz"
sed '/baz/s/foo/bar/g'

# substituer "foo" par "bar" A L'EXCEPTION des lignes contenant "baz"
sed '/baz/!s/foo/bar/g'

# substituer "scarlet" ou "ruby" ou "puce" par "red"
sed 's/scarlet/red/g;s/ruby/red/g;s/puce/red/g' # la plupart des seds
gsed 's/scarlet\|ruby\|puce/red/g' # GNU sed seulement

# reverser l'ordre des lignes (émulation de "tac")
# bug/boni dans HHsed v1.5 cause l'élimination des lignes vides
sed '1!G;h;$!d' # méthode 1
sed -n '1!G;h;$p' # méthode 2

# renverse l'ordre de chaque caractère sur une ligne (émulation de "rev")
sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'

# joindre des paires de lignes ensemble côte-à-côte (émulation de "paste")
sed '$!N;s/\n/ /'

# si une ligne se termine par une barre oblique inversée,
# joindre la ligne suivante à la présente
sed -e :a -e '/\\$/N; s/\\\n//; ta'

# si une ligne débute par le symbole égalité, l'ajouter à la précédente
# et remplacer le symbole "=" par un espace simple
sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'

# insérer des virgules aux chaînes numériques, changeant "1234567" en
# "1,234,567"
gsed ':a;s/\B[0-9]\{3\}\>/,&/;ta' # GNU sed
sed -e :a -e 's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta' # autres seds

# décimaux et signes négatifs (GNU sed)
gsed -r ':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'

# ajouter une ligne blanche toutes les cinq lignes (après lignes 5, 10, 15, 20, etc.)
gsed '0~5G' # GNU sed seulement
sed 'n;n;n;n;G;' # autres seds

IMPRIMER D'UNE FAÇON SÉLECTIVE CERTAINES LIGNES:

# imprimer les dix premières lignes d'un fichier (émulation de "head")
sed 10q

# imprimer la première ligne d'un fichier (émulation "head -1")
sed q

# imprimer les dernières dix lignes d'un fichier (émulation "tail")
sed -e :a -e '$q;N;11,$D;ba'

# imprimer les dernières deux lignes d'un fichier (émulation "tail -2")
sed '$!N;$!D'

# imprimer la dernière ligne d'un fichier (émulation "tail -1")
sed '$!d' # méthode 1
sed -n '$p' # méthode 2

# imprimer l'avant-dernière ligne d'un fichier
sed -e '$!{h;d;}' -e x # pour fichiers d'une ligne , imprimer une ligne vide
sed -e '1{$q;}' -e '$!{h;d;}' -e x # pour fichiers d'une ligne , imprimer la ligne
sed -e '1{$d;}' -e '$!{h;d;}' -e x # pour fichiers d'une ligne , ne rien imprimer

# imprimer seulement les lignes coïncidant avec l'expression régulière regexp
# (émulation "grep")
sed -n '/regexp/p' # méthode 1
sed '/regexp/!d' # méthode 2

# imprimer seulement les lignes NE coïncidant PAS avec l'expression régulière regexp
# (émulation "grep -v")
sed -n '/regexp/!p' # méthode 1, corresponds avec méthode ci-haut
sed '/regexp/d' # méthode 2, syntaxe plus simple

# imprimer la ligne précédant celle qui coïncide avec regexp,
# mais pas la ligne coïncidant avec regexp
sed -n '/regexp/{g;1!p;};h'


# imprime la ligne suivant celle qui coïncide avec regexp,
# mais pas la ligne coïncidant avec regexp
sed -n '/regexp/{n;p;}'

# imprime une ligne de contexte avant et après regexp, avec numérotation
# de lignes indiquant l'endroit de coïncidence avec regexp (similaire
# à "grep -A1 -B1")
sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h

# grep pour AAA et BBB et CCC (peu importe l'ordre)
sed '/AAA/!d; /BBB/!d; /CCC/!d'

# grep pour AAA et BBB et CCC (dans cet ordre)
sed '/AAA.*BBB.*CCC/!d'

# grep pour AAA ou BBB ou CCC (émulation "egrep")
sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d # la plupart des seds
gsed '/AAA\|BBB\|CCC/!d' # GNU sed seulement

# imprime paragraphe si il contient AAA (paragraphes séparés par des lignes vides)
# HHsed v1.5 veuillez insérer un 'G;' après 'x;' dans les trois commandes ci-bas
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'

# imprime le paragraphe s'il contient AAA et BBB et CCC (peu importe l'ordre)
sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;/BBB/!d;/CCC/!d'

# imprime le paragraphe s'il contient AAA ou BBB ou CCC
sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
gsed '/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d' # GNU sed seulement

# imprime seulement les lignes longues de 65 caractères ou plus
sed -n '/^.\{65\}/p'

# imprime seulement les lignes longues de moins de 65 caractères
sed -n '/^.\{65\}/!p' # méthode 1, correspond à ci-haut
sed '/^.\{65\}/d' # méthode 2, syntaxe plus simple

# imprime la partie du fichier depuis la coïncidence à l'expression
# régulière, jusqu'à la fin du fichier
sed -n '/regexp/,$p'

# imprime la partie du fichier incluse par le numéros de ligne 8-12 inclusivement
sed -n '8,12p' # méthode 1
sed '8,12!d' # méthode 2

# imprime la ligne numéro 52
sed -n '52p' # méthode 1
sed '52!d' # méthode 2
sed '52q;d' # méthode 3, très efficace sur de gros fichiers

# commençant avec la troisième ligne, imprimer chaque septième ligne
gsed -n '3~7p' # GNU sed seulement
sed -n '3,${p;n;n;n;n;n;n;}' # autres seds

# imprime la partie du fichier contenue entre deux expression régulières
# incluant celles contenant les expressions régulières
sed -n '/Iowa/,/Montana/p' # respecte les hauts de casse

ÉCRASEMENT SÉLECTIF DE CERTAINES LIGNES:

# imprime tout le fichier SAUF la section coïncidant avec deux
# expressions régulières
sed '/Iowa/,/Montana/d'

# élimine les lignes consécutives identiques d'un fichier (émulation "uniq").
# La première ligne d'un ensemble de lignes identiques consécutives
# est retenue, les autres éliminées
sed '$!N; /^\(.*\)\n\1$/!P; D'

# élimine les lignes en duplicata, non-consécutives, d'un fichier.
# Prenez garde de ne pas déborder les limites de la mémoire tampon
# sinon veuillez utiliser le GNU sed.
sed -n 'G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P'

# éliminer toutes les linges sauf celles en duplicata (émulation "uniq -d").
sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'

# éliminer les dix première lignes d'un fichier
sed '1,10d'

# écraser la dernière ligne d'un fichier
sed '$d'

# écraser les deux dernières lignes d'un fichier
sed 'N;$!P;$!D;$d'

# écraser les dix dernières lignes d'un fichier
sed -e :a -e '$d;N;2,10ba' -e 'P;D' # méthode 1
sed -n -e :a -e '1,10!{P;N;D;};N;ba' # méthode 2

# écraser chaque huitième ligne
gsed '0~8d' # GNU sed seulement
sed 'n;n;n;n;n;n;n;d;' # autres seds

# écraser les lignes coïncidant avec un patron
sed '/patron/d'

# écraser TOUTES les lignes vides d'un fichier (émulation "grep '.' ")
sed '/^$/d' # méthode 1
sed '/./!d' # méthode 2

# écraser toutes les lignes vides consécutives (sauf la première);
# aussi écrase toutes les lignes vides du début et de la fin d'un
# fichier (émulation "cat -s")
sed '/./,/^$/!d' # méthode 1, retient 0 ligne vide au début, 1 à la fin
sed '/^$/N;/\n$/D' # méthode 2, permet 1 ligne vide au début, 0 à la fin

# écraser toutes lignes vides CONSÉCUTIVES d'un fichier, sauf les deux premières:
sed '/^$/N;/\n$/N;//D'

# écraser toutes les lignes vides au début d'un fichier
sed '/./,$!d'

# écraser toutes les lignes vides de la fin d'un fichier
sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' # fonctionne sur tous les seds
sed -e :a -e '/^\n*$/N;/\n$/ba' # ibid, sauf pour gsed 3.02.*

# écrase la dernière ligne de chaque paragraphe
sed -n '/^$/{p;h;};/./{x;/./p;}'

APPLICATIONS SPÉCIALES:

# éliminer les sur-frappes nerf (char, retour) des pages man. La commande
# 'echo' peut nécessiter le modificateur -e si vous utilisez Unix System V
# ou du shell bash.
sed "s/.`echo \\\b`//g" # double guillemets requis dans l'environnement Unix
sed 's/.^H//g' # sous bash/tcsh, enfoncer Ctrl-V et ensuite Ctrl-H
sed 's/.\x08//g' # expression hexadécimale pour sed 1.5, GNU sed, ssed

# obtenir l'entête des messages Usenet/courriel
sed '/^$/q' # élimine tout ce qui suit la première ligne vide

# obtenir le corps des messages Usenet/courriel
sed '1,/^$/d' # élimine tout ce qui précède la première ligne vide

# obtenir l'entête Sujet, mais élimine la portion initiale "Subject: "
sed '/^Suject: */!d; s///;q'

# obtenir l'adresse de retour dans l'entête
sed '/^Reply-To:/q; /^From:/h; /./d;g;q'

# parcourir et isoler l'adresse proprement dite. Extirpe l'adresse courriel
# par elle-même, du script précédent
sed 's/ *(.*)//; s/>.*//; s/.*[:<] *//'

# ajouter un crochet et espace à chaque ligne (citer un message)
sed 's/^/> /'

# écraser le crochet et espace précédant chaque ligne (enlever la citation du message)
sed 's/^> //'

# écraser la plupart des étiquettes HTML (s'accommode des étiquettes multi-lignes)
sed -e :a -e 's/<[^>]*>//g;/</N;//ba'

# extrait les parties uuencodées binaires, éliminant les entêtes
# superflues, de façon à garder seulement la partie uuencodée. Les
# fichiers doivent être passé à sed dans le bon ordre. La version 1
# peut être passée depuis la ligne de commande; la version 2 peut
# faire partie d'un script de shell Unix. (Modifiée par un script
# originaire de Rahul Dhesi.)

sed '/^end/,/^begin/d' file1 file2 ... fileX | uudecode # vers. 1
sed '/^end/,/^begin/d' "$@" | uudecode # vers. 2

# triage des paragraphes d'un fichier par ordre alphabétique. Les paragraphes
# sont séparés pour des lignes vides. GNU sed utilise \v comme tabulation
# verticale, ou n'importe lequel caractère unique peut servir.
sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed '1s/={NL}=//;s/={NL}=/\n/g'
gsed '/./{H;d};x;y/\n/\v/' file | sort | sed '1s/\v//;y/\v/\n/'

# compresser en zip chaque fichier .TXT individuellement, écrasant
# le fichier source et assignant le nom du fichier compressé .ZIP
# au nom de base du fichier source .TXT (sous DOS: le modificateur
# "dir /b" retourne les noms de base des fichiers tout en majuscules)
echo @echo off >zipup.bat
dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1 \1.TXT/" >>zipup.bat

USAGE TYPIQUE: Sed accepte une ou plusieurs commandes et les applique
toutes, de façon séquentielle, à chacune des lignes d'entrée. Une fois
que toutes les commandes furent exécutées à la première ligne d'entrée,
cette ligne est envoyée vers la sortie, une deuxième ligne est lue
comme nouvelle entrée, et le cycle se répète. Les exemples précédents
assument que l'entrée provient de l'entrée standard (ex. la console,
normalement ce serait l'entrée dans un pipeline). Un ou plusieurs
noms de fichiers peuvent être ajoutés à la ligne de commande si l'entrée
ne provient pas de l'entrée standard. La sortie est passée à la
sortie standard (stdout ou l'écran-témoin). Donc:

cat nomdefichier | sed '10q' # utilise entrée pipeline
sed '10q' nomdefichier # même chose, en moins du cat inutile
sed '10q' nomdefichier > nouveaufichier # re dirige la sortie vers le disque

Pour des renseignements additionnels sur la syntaxe, incluant
comment fournir les instructions sed à partir d'un fichier au lieu
de la ligne de commande, veuillez consulter le livre "SED &
AWK, 2nd Edition," par Dale Dougherty et Arnold Robbins (O'Reilly,
1997; http://www.ora.com), "UNIX Text Processing," par Dale Dougherty
and Tim O'Reilly (Hayden Books, 1987) ou les tutoriels par Mike Arst
distribués dans U-SEDIT2.ZIP (plusieurs sites). Afin d'exploiter la
pleine puissance de sed, l'usager doit comprendre les 'expressions
régulières'. A cette fin, consultez "Mastering Regular Expressions"
par Jeffrey Friedl (O'Reilly, 1997). Le manuel UNIX ("man") contient
des pages qui pourraient être utiles ("man sed", "man regexp", ou la
sous-section sur les expressions régulières ("man ed"), quoique les
pages man sont notoires pour leur difficultés. Elles ne furent pas
rédigées pour enseigner l'usage de sed ou des expressions régulières,
mais comme texte de référence pour ceux qui connaissent déjà
ces outils.

SYNTAXE DE CITATION: Les exemples précédents utilisent les
guillemets simples ('...') au lieu des guillemets doubles ("...")
pour encadrer ou citer les commandes d'édition, puisque sed est
typiquement utilisé sur les systèmes d'exploitation UNIX. Les guillemets
simples préviennent le shell UNIX d'interpréter les symbole dollar ($)
ainsi que les guillemets renversés (`...`) qui seraient interprétés
par le shell s'ils seraient encadrés ou cités par les guillemets doubles.
Les usagers du shell "csh" et dérivés doivent aussi citer le
point d'exclamation avec l'oblique arrière (\!) si l'on veut que
les exemples ci-haut fonctionnent, même avec à l'intérieur de
guillemets simples. Les versions de sed écrites pour DOS
invariablement requièrent des guillemets doubles ("...") au
lieu des guillemets simples utilisés pour citer les commandes
d'édition sed.

L'USAGE DE '\t' DANS LES SCRIPTS SED:

Afin de clarifier la documentation, nous avons utilisé l'expression
'\t' pour indiquer le caractère de tabulation (0x09) dans les scripts.
Cependant, la plupart des versions de sed ne reconnaissent pas
l'abréviation '\t', donc, lorsque vous écrirez ces directives
à l'invite de commande, vous devrez enfoncer la clef TAB au lieu de
l'abréviation. '\t' est supporté comme métacharactère d'expression
régulière dans awk, perl, et HHsed, sedmod, et GNU sed v3.02.80.

VERSIONS DE SED: Les version de sed diffèrent entre elles, et de
légers écarts de syntaxe se présentent. En particulier, la plupart
ne reconnaissent pas l'usage d'étiquettes (:nom) ou ne permettent
pas les instructions de branchement (b,t) à l'intérieur des commandes
d'édition, sauf à la fin de ces commandes. Nous avons donc utilisé
une syntaxe qui serait portable à la majorité des usagers de divers
sed, bien que les versions les plus populaires du GNU sed permettent
une syntaxe plus élaborée. Lorsque les lecteurs verront une longue
chaîne de commande telle celle-ci:

sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d

ils seront réjouis de savoir que GNU sed leur permettra de réduire
le tout en ceci:

sed '/AAA/b;/BBB/b;/CCC/b;d' # ou bien encore en ceci:
sed '/AAA\|BBB\|CCC/b;d'

En plus, se rappeler que bien que certaines versions de sed acceptent
une commande telle "/one/ s/RE1/RE2/", d'autres ne permettent pas ceci:
"/one/! s/RE1/RE2/", qui contient un espace avant le 's'. Éviter d'enter
l'espace lorsque vous entrez la commande.

OPTIMISATION POUR VITESSE D'EXÉCUTION:
Lorsque vous avez besoin de vitesse pour l'exécution de vos scripts
(si vos fichiers d'entrée sont volumineux, ou un processeur lent
ou un disque dur lent) la substitution sera plus rapide si vous
faites un recherche pour la chaîne à être changée avant de faire
la substitution "s/.../.../". Voir:

sed 's/foo/bar/g' nomdefichier # commande normale de substitution
sed '/foo/ s/foo/bar/g' nomdefichier # exécution plus rapide
sed '/foo/ s//bar/g' nomdefichier # raccourci de syntaxe

Si vous devez altérer ou écraser seulement une section d'un fichier
et que vous voulez seulement une sortie pour une première partie
d'un fichier quelconque, la commande "quit" (q) dans le script
réduira considérablement le temps d'exécution pour de gros fichiers.
Donc:

sed -n '45,50p' nomdefichier # imprimez les lignes nos. 45-50 d'un fichier
sed -n '51q;45,50p' nomdefichier # ibid, mais bien plus vite

-------------------------------------------------------------------------

Cordialement.

[musher0]

Bonjour Argolance.

Disons que comme pollution de fil, c'est réussi. Une simple adresse Internet aurait suffi.

Tu aurais pu te limiter au passage, s'il existe, où sed remplace une interligne sur deux
dans un fichier texte. Mais, voilà, même sed est incapable de faire cela.

Ensuite, comme insulte à mon esprit de recherche. c'est pas mal non plus. Je ne vais
pas «dé»-créer mon script pour tes beaux yeux parce que tu ne sais pas que sed est
incapable de faire un tel remplacement d'interligne.

Comme tous les autres bouts de boudin du genre, il peut enlever toutes les interlignes.
Point. À ce que je sais de sed, il travaille sur le flux, mais il n'en compare pas le contenu.

Salut.

[musher0]

Re-salut.

Tu m'engueules parce que je n'ai pas utilisé sed; du côté anglophone
MochiMoppei me dit que < cat -s fichier > fait ce que je recherche.

Tous les deux vous êtes dans le champ de patates.

J'ai enligné des illustrations au bas de ce message concernant
le type d'interlignes et leur traitement.

On peut lire mon explication aussi, ça nuira pas.

Bon samedi.

[Argolance]

Re-bonjour,

Disons que comme pollution de fil, c'est réussi. Une simple adresse Internet aurait suffi.
Tu aurais pu te limiter au passage, s'il existe, où sed remplace une interligne sur deux dans un fichier texte. Mais, voilà, même sed est incapable de faire cela.

Je n'ai plus qu'un fichier texte dans ma boite à outils et n'ai même pas cherché à me souvenir de la page où j'ai trouvé ces données.
J'ai cru opportun (et beaucoup plus simple!) d'en copier/coller le contenu pour les puppyistes de passage, sans aucune volonté de te "couper l'herbe sous les pieds" ou polluer "ton" fil.
La commande que je donne semble faire le travail correctement. Note qu'elle est marquée en caractères gras dans le corps de la citation.

Ensuite, comme insulte à mon esprit de recherche. c'est pas mal non plus.

Eh bé, ton "esprit de recherche" n'a pas besoin de grand chose pour se sentir "insulté"!

Je ne vais pas «dé»-créer mon script pour tes beaux yeux parce que tu ne sais pas que sed est incapable de faire un tel remplacement d'interligne.

Mon message n'était pas une injonction à refaire ton script en tenant compte de cette proposition.
Elle est désintéressée, m'a parue justifiée et particulièrement utile (vu tout le "bien" que j'ai pu en tirer depuis longtemps déjà).
Point.
Tous les chemins mènent à Rome. Le tien en est un, le mien un autre. Celui-ci ne cherche pas à se substituer à celui-là.

Bon, bon, on va pas monter aux barricades pour ça.

Bah non, c'est plus de mon âge!

Mes plus plates excuses de m'être intéressé à ton fil et de t'avoir remercié pour ton script.

"On est pas là pour se faire engueuler, on est venu pour voir le défilé..." (Aldebert)!

À la revoyure.

Cordialement.

[musher0]

Salut Argolance.

Ta doc dit :
> # élimine les lignes consécutives identiques d'un fichier (émulation "uniq").
# La première ligne d'un ensemble de lignes identiques consécutives
# est retenue, les autres éliminées
sed '$!N; /^\(.*\)\n\1$/!P; D'

C'est exactement ce que fait < cat -s fichier.txt >. Et puis on dirait des hiéroglyphes,
cette commande. J'savais pas que l'auteur de sed était Sumérien !!! MDR

Mauvaise blague à part, quand on veut « réduire sélectivement », en d'autres mots
« enlever seulement la dernière interligne quand il y en a trois ou quatre », ni ton
sed, ni le cat de MochiMoppei n'en sont capables.

À+ quand même !

[musher0]

Bonjour à tous.

Voici une belle ressource du consortium W3C concernant la mise en forme de textes
au format txt : https://www.w3.org/TR/WCAG-TECHS/text.html

En résumé, dans un texte, on trouve des paragraphes, des listes et des rubriques
-- les paragraphes doivent être séparés entre eux par une interligne;
-- les éléments d'une liste devraient être en ordre numérique (chiffres arabes ou
romains), ou alphabétique;
-- les rubriques doivent être séparées du contenu qui précède par deux interlignes,
et de celui qui suit, par une interligne.

Sur papier, il y a des guides analogues :
Le guide de typographie de l'Imprimerie nationale de France
Le Ramat de la typographie.

Je ne sais trop s'ils sont en ligne.

Dans le Ramat, en plus de ce qui précède, on présente des types de paragraphe :
-- pleins ou
-- avec première ligtne introduite par un taquet, et
-- quelques autres styles mixtes. En voici un dont je me souviens d'emblée :
---- 1er et dernier paragraphe pleins (sans taquet); ceux entre les deux en ont un.

Aux sceptiques : j'avais fait ma recherche avant d'ouvrir ce fil et de suggérer un script.

À+

.

[musher0]

Autre possibilité :
http://jp.barralis.com/linux-man/man1/paste.1.php
Normalement, cet utilitaire place côte-à-côte deux ou plusieurs fichiers texte en
colonnes séparées par le délimiteur X. Si on ne « colle » qu'un fichier, le délimiteur
défini peut servir à remplacer la fin de ligne (« \n ») typique de Linux.

Exemple de texte de départ --

Les chaussettes
de l'archiduchesse

sont sèches,


archi-sèches.

Formule avec paste --

Code: Select all

paste -s -d%% archiduch.txt > archiduch.tmp3

Résultat --

Les chaussettes %de l'archiduchesse%%sont sèches,%%%archi-sèches.

Si on veut réduire les fins de ligne de trois à deux, on peut utiliser replaceit --

Code: Select all

replaceit --input=archiduch.tmp3 "%%%" "%%"

ou le faire dans un éditeur, tout simplement.
Résultat --

Les chaussettes %de l'archiduchesse%%sont sèches,%%archi-sèches.

On termine avec tr pour restaurer les fins de ligne --

Code: Select all

tr "%" "\n" < archiduch.tmp3 > archiduch.tmp3.txt

Résultat --

Les chaussettes
de l'archiduchesse

sont sèches,

archi-sèches.

On obtient ainsi uniformément deux interlignes entre les paragraphes.

À noter que :
-- le paramètre < -s > ("squeeze") n'a pas été utilisé avec tr.
-- Ni < cat -s >, d'ailleurs.
-- Comme délimiteur, se contenter d'un caractère ascii (0-127), car ni replaceit,
ni tr ne comprennent les caractères ansi (128-255).

Selon mon expérience; à tout le moins, ça compliquerait sérieusement la procédure.
J'ai essayé avec le caractère « ¤ » comme délimiteur, pensant bien faire, mais ce
caractère apparaît comme « Â » quand on fait défiler le texte avec cat. Au remplacement
suivant, ce « Â » n'est pas trouvé. Tandis qu'avec « % », cela fonctionne bien dans un
texte ordinaire; dans un texte de maths, il faudra en trouver un autre !

À+