Comment convertir la nouvelle ligne DOS / Windows (CRLF) en nouvelle ligne Unix (LF) dans un script Bash?

Comment puis-je par programme (c'est-à-dire ne pas utiliser vi ) convertir des sauts de ligne DOS / Windows en Unix?

Les commandes dos2unixet unix2dosne sont pas disponibles sur certains systèmes. Comment puis-je les émuler avec des commandes comme sed/ awk/ tr?

Vous pouvez utiliser trpour convertir de DOS en Unix; toutefois, vous ne pouvez le faire en toute sécurité que si CR n'apparaît dans votre fichier que comme premier octet d'une paire d'octets CRLF. C'est généralement le cas. Vous utilisez ensuite:

tr -d '\015' <DOS-file >UNIX-file

Notez que le nom DOS-fileest différent du nom UNIX-file; si vous essayez d'utiliser le même nom deux fois, vous vous retrouverez sans données dans le fichier.

Vous ne pouvez pas faire l'inverse (avec le «tr» standard).

Si vous savez comment entrer le retour chariot dans un script ( control-V, control-Mpour entrer control-M), alors:

sed 's/^M$//'     # DOS to Unix
sed 's/$/^M/'     # Unix to DOS

où le «^ M» est le caractère de contrôle-M. Vous pouvez également utiliser le mécanisme de bash cotation ANSI-C pour spécifier le retour chariot:

sed $'s/\r$//'     # DOS to Unix
sed $'s/$/\r/'     # Unix to DOS

Cependant, si vous devez le faire très souvent (plus d'une fois, en gros), il est beaucoup plus judicieux d'installer les programmes de conversion (par exemple dos2unixet unix2dos, ou peut dtou- être et utod) et de les utiliser.

Si vous devez traiter des répertoires et sous-répertoires entiers, vous pouvez utiliser zip:

zip -r -ll zipfile.zip somedir/
unzip zipfile.zip

Cela va créer une archive zip avec des fins de ligne changées de CRLF en CR. unzipmettra ensuite les fichiers convertis en place (et vous demandera fichier par fichier - vous pouvez répondre: Oui à tous). Remerciements à @vmsnomad pour l'avoir signalé.

tr -d "\r" < file

jetez un oeil ici pour des exemples en utilisant sed:

# IN UNIX ENVIRONMENT: convert DOS newlines (CR/LF) to Unix format.
sed 's/.$//'               # assumes that all lines end with CR/LF
sed 's/^M$//'              # in bash/tcsh, press Ctrl-V then Ctrl-M
sed 's/\x0D$//'            # works on ssed, gsed 3.02.80 or higher

# IN UNIX ENVIRONMENT: convert Unix newlines (LF) to DOS format.
sed "s/$/`echo -e \\\r`/"            # command line under ksh
sed 's/$'"/`echo \\\r`/"             # command line under bash
sed "s/$/`echo \\\r`/"               # command line under zsh
sed 's/$/\r/'                        # gsed 3.02.80 or higher

Utilisez sed -ipour la conversion sur place, par exemple sed -i 's/..../' file.

Faire cela avec POSIX est délicat:

• POSIX Sed ne prend pas en charge \rou \15. Même si c'est le cas, l'option en place -in'est pas POSIX

• POSIX Awk ne prend pas en charge \ret \15, cependant, l' -i inplaceoption n'est pas POSIX

• d2u et dos2unix ne sont pas des utilitaires POSIX , mais ex est

• Ex Posix ne supporte pas \r, \15, \nou\12

Pour supprimer les retours chariot:

ex -bsc '%!awk "{sub(/\r/,\"\")}1"' -cx file

Pour ajouter des retours chariot:

ex -bsc '%!awk "{sub(/$/,\"\r\")}1"' -cx file

Vous pouvez utiliser vim par programme avec l'option -c {commande}:

Dos à Unix:

vim file.txt -c "set ff=unix" -c ":wq"

Unix à dos:

vim file.txt -c "set ff=dos" -c ":wq"

"set ff = unix / dos" signifie changer le format de fichier (ff) du fichier au format de fin de ligne Unix / DOS

": wq" signifie écrire un fichier sur le disque et quitter l'éditeur (permettant d'utiliser la commande en boucle)

En utilisant AWK, vous pouvez faire:

awk '{ sub("\r$", ""); print }' dos.txt > unix.txt

En utilisant Perl, vous pouvez faire:

perl -pe 's/\r$//' < dos.txt > unix.txt

Pour convertir un fichier sur place, utilisez

dos2unix <filename>

Pour sortir du texte converti dans un autre fichier, utilisez

dos2unix -n <input-file> <output-file>

Vous pouvez l'installer sur Ubuntu ou Debian avec

sudo apt install dos2unix

ou sur macOS en utilisant homebrew

brew install dos2unix

Ce problème peut être résolu avec des outils standard, mais il y a suffisamment de pièges pour les imprudents que je vous recommande d'installer la flipcommande, qui a été écrite il y a plus de 20 ans par Rahul Dhesi, l'auteur de zoo. Il fait un excellent travail de conversion des formats de fichiers tout en évitant, par exemple, la destruction par inadvertance de fichiers binaires, ce qui est un peu trop facile si vous vous contentez de modifier chaque CRLF que vous voyez ...

Les solutions publiées jusqu'à présent ne traitent qu'une partie du problème, convertissant le CRLF de DOS / Windows en LF d'Unix; la partie qui leur manque est que DOS utilise CRLF comme séparateur de ligne , tandis qu'Unix utilise LF comme terminateur de ligne . La différence est qu'un fichier DOS (généralement) n'aura rien après la dernière ligne du fichier, contrairement à Unix. Pour effectuer la conversion correctement, vous devez ajouter ce LF final (sauf si le fichier est de longueur nulle, c'est-à-dire qu'il ne contient aucune ligne). Mon incantation préférée pour cela (avec un peu de logique supplémentaire pour gérer les fichiers séparés par CR de style Mac, et non les fichiers molesters qui sont déjà au format Unix) est un peu de perl:

perl -pe 'if ( s/\r\n?/\n/g ) { $f=1 }; if ( $f || ! $m ) { s/([^\n])\z/$1\n/ }; $m=1' PCfile.txt

Notez que cela envoie la version Unixified du fichier à stdout. Si vous souhaitez remplacer le fichier par une version Unixified, ajoutez l' -iindicateur perl .

Si vous n'avez pas accès à dos2unix , mais pouvez lire cette page, vous pouvez copier / coller dos2unix.py à partir d'ici.

#!/usr/bin/env python
"""\
convert dos linefeeds (crlf) to unix (lf)
usage: dos2unix.py <input> <output>
"""
import sys

if len(sys.argv[1:]) != 2:
  sys.exit(__doc__)

content = ''
outsize = 0
with open(sys.argv[1], 'rb') as infile:
  content = infile.read()
with open(sys.argv[2], 'wb') as output:
  for line in content.splitlines():
    outsize += len(line) + 1
    output.write(line + '\n')

print("Done. Saved %s bytes." % (len(content)-outsize))

Post-cross du superutilisateur .

Super duper facile avec PCRE;

En tant que script, ou remplacez $@par vos fichiers.

#!/usr/bin/env bash
perl -pi -e 's/\r\n/\n/g' -- $@

Cela écrasera vos fichiers en place!

Je recommande de ne le faire qu'avec une sauvegarde (contrôle de version ou autre)

Une solution awk encore plus simple sans programme:

awk -v ORS='\r\n' '1' unix.txt > dos.txt

Techniquement, «1» est votre programme, b / c awk en nécessite un lorsque l'option est donnée.

MISE À JOUR : Après avoir revu cette page pour la première fois depuis longtemps, je me suis rendu compte que personne n'avait encore posté de solution interne, alors en voici une:

while IFS= read -r line;
do printf '%s\n' "${line%$'\r'}";
done < dos.txt > unix.txt

Je venais de réfléchir à cette même question (côté Windows, mais également applicable à Linux.) Étonnamment, personne n'a mentionné une manière très automatisée de faire la conversion CRLF <-> LF pour les fichiers texte en utilisant un bon vieux zip -ll option (Info-ZIP):

zip -ll textfiles-lf.zip files-with-crlf-eol.*
unzip textfiles-lf.zip 

REMARQUE: cela créerait un fichier zip préservant les noms de fichiers d'origine mais convertissant les fins de ligne en LF. Ensuite unzip, les fichiers seraient extraits au format zip, c'est-à-dire avec leurs noms d'origine (mais avec les terminaisons LF), ce qui inviterait à remplacer les fichiers d'origine locaux, le cas échéant.

Extrait pertinent de zip --help:

zip --help
...
-l   convert LF to CR LF (-ll CR LF to LF)

fait intéressant dans mon git-bash sur windows sed ""a déjà fait l'affaire:

$ echo -e "abc\r" >tst.txt
$ file tst.txt
tst.txt: ASCII text, with CRLF line terminators
$ sed -i "" tst.txt
$ file tst.txt
tst.txt: ASCII text

Ma conjecture est que sed les ignore lors de la lecture des lignes de l'entrée et écrit toujours les fins de ligne Unix sur la sortie.

Cela a fonctionné pour moi

tr "\r" "\n" < sampledata.csv > sampledata2.csv 

Pour Mac osx si vous avez installé homebrew [ http://brew.sh/

brew install dos2unix

for csv in *.csv; do dos2unix -c mac ${csv}; done;

Assurez-vous d'avoir fait des copies des fichiers, car cette commande modifiera les fichiers en place. L'option -c mac rend le commutateur compatible avec osx.

TIMTOWTDI!

perl -pe 's/\r\n/\n/; s/([^\n])\z/$1\n/ if eof' PCfile.txt

Basé sur @GordonDavisson

Il faut considérer la possibilité de [noeol]...

Vous pouvez utiliser awk. Définissez le séparateur d'enregistrement ( RS) sur une expression rationnelle qui correspond à tous les caractères de nouvelle ligne ou aux caractères possibles. Et définissez le séparateur d'enregistrement de sortie ( ORS) sur le caractère de nouvelle ligne de style Unix.

awk 'BEGIN{RS="\r|\n|\r\n|\n\r";ORS="\n"}{print}' windows_or_macos.txt > unix.txt

Sous Linux, il est facile de convertir ^ M (ctrl-M) en * nix newlines (^ J) avec sed.

Ce sera quelque chose comme ça sur la CLI, il y aura en fait un saut de ligne dans le texte. Cependant, le \ passe ce ^ J à sed:

sed 's/^M/\
/g' < ffmpeg.log > new.log

Vous obtenez cela en utilisant ^ V (ctrl-V), ^ M (ctrl-M) et \ (barre oblique inverse) pendant que vous tapez:

sed 's/^V^M/\^V^J/g' < ffmpeg.log > new.log

sed --expression='s/\r\n/\n/g'

Étant donné que la question mentionne sed, c'est la façon la plus simple d'utiliser sed pour y parvenir. Ce que dit l'expression, c'est remplacer tous les retours chariot et sauts de ligne par seulement des sauts de ligne uniquement. C'est ce dont vous avez besoin lorsque vous passez de Windows à Unix. J'ai vérifié que cela fonctionne.

En tant qu'extension de la solution Unix vers DOS de Jonathan Leffler, pour convertir en toute sécurité en DOS lorsque vous n'êtes pas sûr des fins de ligne actuelles du fichier:

sed '/^M$/! s/$/^M/'

Cela vérifie que la ligne ne se termine pas déjà dans CRLF avant la conversion en CRLF.

J'ai créé un script basé sur la réponse acceptée afin que vous puissiez le convertir directement sans avoir besoin d'un fichier supplémentaire à la fin et le supprimer et le renommer ensuite.

convert-crlf-to-lf() {
    file="$1"
    tr -d '\015' <"$file" >"$file"2
    rm -rf "$file"
    mv "$file"2 "$file"
}

assurez-vous simplement que si vous avez un fichier comme "file1.txt" que "file1.txt2" n'existe pas déjà ou qu'il sera écrasé, je l'utilise comme un emplacement temporaire pour stocker le fichier.

Avec bash 4.2 et plus récent, vous pouvez utiliser quelque chose comme ceci pour supprimer le CR de fin, qui utilise uniquement les fonctions intégrées bash:

if [[ "${str: -1}" == $'\r' ]]; then
    str="${str:: -1}"
fi

J'ai essayé le fichier.txt de sed / ^ M $ // 'sur OSX ainsi que plusieurs autres méthodes ( http://www.thingy-ma-jig.co.uk/blog/25-11-2010/fixing- dos-line-endings ou http://hintsforums.macworld.com/archive/index.php/t-125.html ). Aucun n'a fonctionné, le fichier est resté inchangé (entre Ctrl-v Enter était nécessaire pour reproduire ^ M). Au final, j'ai utilisé TextWrangler. Ce n'est pas strictement une ligne de commande mais cela fonctionne et il ne se plaint pas.