Sed peut-il remplacer les caractères de nouvelle ligne?

Y at-il un problème avec sed et new line character?
J'ai un fichier test.txt avec le contenu suivant

aaaaa  
bbbbb  
ccccc  
ddddd  

Ce qui suit ne fonctionne pas:
sed -r -i 's/\n/,/g' test.txt

Je sais que je peux utiliser trpour cela, mais ma question est de savoir pourquoi cela ne semble pas possible avec sed.

S'il s'agit d'un effet secondaire du traitement du fichier ligne par ligne, je voudrais savoir pourquoi cela se produit. Je pense grepsupprime de nouvelles lignes. Est-ce que Sed fait la même chose?

Avec GNU sedet fourniPOSIXLY_CORRECT n’est pas dans l’environnement (pour une entrée sur une seule ligne):

sed -i ':a;N;$!ba;s/\n/,/g' test.txt

De https://stackoverflow.com/questions/1251999/sed-how-can-i-replace-a-newline-n :

1. créer une étiquette via :a
2. ajoute la ligne courante et la suivante à l’espace du motif via N
3. si nous sommes avant la dernière ligne, branchez sur l’étiquette créée $!ba($! signifie ne pas le faire sur la dernière ligne (car il devrait y avoir une nouvelle ligne finale)).
4. enfin, la substitution remplace chaque nouvelle ligne par une virgule dans l'espace de répétition (qui est le fichier entier).

Cela fonctionne avec GNU sed:

sed -z 's/\n/,/g' 

-z est inclus depuis 4.2.2

NB -zchange le délimiteur en caractères nuls ( \0). Si votre entrée ne contient aucun caractère NULL, toute l'entrée est traitée comme une seule ligne. Cela peut venir avec ses limites .

Pour éviter de remplacer la nouvelle ligne de la dernière ligne, vous pouvez la rétablir:

sed -z 's/\n/,/g;s/,$/\n/'

(Ce qui est sedencore une fois la syntaxe GNU , mais cela n'a pas d'importance car tout est uniquement GNU)

Sur le site Web d'Oracle:

L'utilitaire sed fonctionne en lisant séquentiellement un fichier, ligne par ligne, dans la mémoire. Il exécute ensuite toutes les actions spécifiées pour la ligne et la remet en mémoire pour être transféré vers le terminal avec les modifications demandées. Une fois que toutes les actions ont été effectuées sur cette seule ligne, la ligne suivante du fichier est lue et le processus est répété jusqu'à ce que le fichier soit terminé.

En gros, cela signifie que, parce que sed lit ligne par ligne, le caractère de nouvelle ligne ne correspond pas.

La solution de https://stackoverflow.com/questions/1251999/sed-how-can-i-replace-a-newline-n est la suivante:

sed ':a;N;$!ba;s/\n/,/g'

ou, dans une version portable (sans ;enchaîner après les étiquettes de saut)

sed -e ':a' -e 'N;$!ba' -e 's/\n/,/g'

Une explication de la façon dont cela fonctionne est fournie sur cette page.

sedsupprime toujours la fin de ligne \newline juste avant de remplir l’espace de modèle, puis en ajoute un avant d’écrire les résultats de son script. Une \newline peut être créée dans l'espace des motifs de différentes manières - mais jamais si elle ne résulte pas d'une modification. Ceci est important - les \nespaces dans sedl'espace de modèle de s reflètent toujours un changement et ne se produisent jamais dans le flux d'entrée. \nles lignes sont le seul délimiteur ased peut compter avec une entrée inconnue.

Si vous souhaitez remplacer toutes les \nlignes par des virgules et que votre fichier n'est pas très volumineux, vous pouvez procéder comme suit:

sed 'H;1h;$!d;x;y/\n/,/'

Cela ajoute chaque ligne d’entrée à l’ hancien espace - à l’exception de la première, qui remplace l’ hancien espace - à la suite d’un \ncaractère ewline. Il dsupprime ensuite chaque ligne, pas la $!dernière de la sortie. Sur la dernière ligne H, les espaces et les espaces de modèle sont xmodifiés et tous les \ncaractères ewline sont convertis y///en virgules.

Pour les fichiers volumineux, ce type de problème est inévitablement source de problèmes - sedla mémoire tampon de la ligne de démarcation peut être facilement surchargée d'actions de ce type.

Alternativement, vous pouvez utiliser une syntaxe légèrement plus simple:

sed ':a;N;s/\n/,/g;ba'

... juste changer l'ordre de la séquence.

Il y a une très belle magie sed ici. Et quelques bons points soulevés au sujet du débordement d’espace-modèle J'adore utiliser sed, même si ce n'est pas la méthode la plus simple, car elle est si compacte et puissante. Cependant, il a ses limites et pour de grandes quantités de données, l'espace de modèle devrait être mahoosif.

GNU dit ceci:

Pour ceux qui souhaitent écrire des scripts sed portables, sachez que certaines implémentations sont connues pour limiter la longueur des lignes (pour le motif et les espaces de maintien) à un maximum de 4000 octets. La norme posix spécifie que les implémentations sed conformes doivent prendre en charge une longueur de ligne d'au moins 8192 octets. GNU sed n’a pas de limite intégrée sur la longueur de la ligne; tant que vous pouvez utiliser malloc () plus de mémoire (virtuelle), vous pouvez alimenter ou construire des lignes aussi longtemps que vous le souhaitez.
Cependant, la récursivité est utilisée pour gérer les sous-modèles et la répétition indéfinie. Cela signifie que l'espace de pile disponible peut limiter la taille de la mémoire tampon pouvant être traitée par certains modèles.

Je n'ai pas grand chose à ajouter, mais je voudrais vous indiquer mon guide de référence pour sed . C'est excellent. http://www.grymoire.com/Unix/Sed.html

et voici ma solution:

for i in $(cat test.txt); do echo -n $i','; done; echo '' >> somewhere

bien ça marche

Disons que vous voulez remplacer les nouvelles lignes par \n. Je voulais faire ça, alors voici ce que j'ai fait:

(echo foo; echo bar; echo baz) | sed -r '$!s/$/\\n/' | tr -d '\n' 
# Output: foo\nbar\nbaz

Voici ce que cela fait: pour toutes les lignes sauf la dernière , ajouter \n. Ensuite, supprimez les nouvelles lignes avec tr.