Jak przekonwertować DOS / Windows newline (CRLF) na Unix newline (LF) w skrypcie Bash?

Jak mogę programowo (tj. Nie używać vi) konwertować nowe wiersze DOS / Windows na Unix?

dos2unixI unix2dospolecenia nie są dostępne w niektórych systemach. Jak mogę je emulować za pomocą poleceń takich jak sed/ awk/ tr?

Możesz użyć trdo konwersji z DOS-a na Uniksa; można to jednak zrobić bezpiecznie tylko wtedy, gdy CR pojawia się w pliku tylko jako pierwszy bajt pary bajtów CRLF. Zazwyczaj tak jest. Następnie używasz:

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

Zauważ, że nazwa DOS-filejest inna niż nazwa UNIX-file; jeśli spróbujesz użyć tej samej nazwy dwa razy, skończysz bez danych w pliku.

Nie możesz tego zrobić na odwrót (ze standardowym „tr”).

Jeśli wiesz, jak wprowadzić znak powrotu karetki do skryptu ( control-V, control-Maby wpisać control-M), to:

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

gdzie „^ M” jest znakiem kontrolnym M. Możesz także użyć mechanizmu bash cytowania ANSI-C , aby określić zwrot karetki:

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

Jeśli jednak będziesz musiał to robić bardzo często (mniej więcej raz, z grubsza mówiąc), rozsądniej jest zainstalować programy do konwersji (np. dos2unixI unix2dos, a może dtoui utod) i używać ich.

Jeśli chcesz przetwarzać całe katalogi i podkatalogi, możesz użyć zip:

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

Spowoduje to utworzenie archiwum zip ze zmienionymi zakończeniami linii z CRLF na CR. unzipnastępnie umieści przekonwertowane pliki z powrotem na swoim miejscu (i poprosi o plik po pliku - możesz odpowiedzieć: Tak-dla-wszystkich). Podziękowania dla @vmsnomad za zwrócenie na to uwagi.

tr -d "\r" < file

spójrz tutaj na przykłady, używając 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

Użyj sed -ido konwersji w miejscu, np sed -i 's/..../' file.

Robienie tego z POSIX jest trudne:

• POSIX Sed nie obsługuje \rlub \15. Nawet jeśli tak, opcja na miejscu -inie jest POSIX

• POSIX awk robi wsparcie \ri \15, jednak -i inplaceopcja ta nie jest POSIX

• d2u i dos2unix nie są narzędziami POSIX , ale ex jest

• POSIX ex nie obsługuje \r, \15, \nlub\12

Aby usunąć zwroty karetki:

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

Aby dodać zwrot karetki:

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

Możesz używać vima programowo z opcją -c {polecenie}:

Dos dla Uniksa:

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

Uniks do dos:

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

„set ff = unix / dos” oznacza zmianę formatu pliku (ff) pliku na format końca wiersza Unix / DOS

„: wq” oznacza zapisanie pliku na dysk i zamknięcie edytora (pozwalając na użycie polecenia w pętli)

Korzystając z AWK możesz:

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

Używając Perla możesz:

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

Aby przekonwertować plik na miejscu, użyj

dos2unix <filename>

Aby wyprowadzić przekonwertowany tekst na inny plik, użyj

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

Możesz zainstalować go na Ubuntu lub Debianie za pomocą

sudo apt install dos2unix

lub w systemie macOS za pomocą homebrew

brew install dos2unix

Ten problem można rozwiązać za pomocą standardowych narzędzi, ale istnieje wystarczająco wiele pułapek dla nieostrożnych, że zalecam zainstalowanie flippolecenia, które zostało napisane ponad 20 lat temu przez autora Rahula Dhesi zoo. Doskonale radzi sobie z konwersją formatów plików, na przykład unikając przypadkowego zniszczenia plików binarnych, co jest nieco zbyt łatwe, jeśli po prostu ścigasz się zmieniając każdy CRLF, który widzisz ...

Dotychczasowe rozwiązania dotyczą tylko części problemu, przekształcając CRLF DOS / Windows w LF Unixa; brakuje im tylko tego, że DOS używa CRLF jako separatora linii , podczas gdy Unix używa LF jako terminatora linii . Różnica polega na tym, że plik DOS (zwykle) nie będzie miał nic po ostatniej linii pliku, podczas gdy Unix będzie. Aby poprawnie wykonać konwersję, musisz dodać ten końcowy LF (chyba że plik ma zerową długość, tj. Nie ma w nim żadnych linii). Moje ulubione zaklęcie do tego (z nieco dodaną logiką do obsługi plików rozdzielonych CR w stylu Mac, a nie molestujących plików, które są już w formacie unixowym) to trochę perl:

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

Zauważ, że wysyła to Unixified wersję pliku na standardowe wyjście. Jeśli chcesz zastąpić plik wersją Unixified, dodaj -iflagę perla .

Jeśli nie masz dostępu do dos2unix , ale możesz przeczytać tę stronę, możesz skopiować / wkleić dos2unix.py z tego miejsca.

#!/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))

Przeniesiony z superużytkownika .

Łatwe kopiowanie z PCRE;

Jako skrypt lub zamień na $@swoje pliki.

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

Spowoduje to zastąpienie plików na miejscu!

Zalecam robienie tego tylko z kopią zapasową (kontrola wersji lub w inny sposób)

Jeszcze prostsze rozwiązanie awk bez programu:

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

Technicznie „1” to twój program, b / c awk wymaga jednego, gdy podano opcję.

AKTUALIZACJA : Po ponownym odwiedzeniu tej strony od dłuższego czasu zdałem sobie sprawę, że nikt jeszcze nie opublikował wewnętrznego rozwiązania, więc oto jedno:

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

Musiałem tylko zastanowić się nad tym samym pytaniem (po stronie Windows, ale równie dobrze dotyczy Linuksa). Zaskakująco nikt nie wspomniał o bardzo zautomatyzowanym sposobie wykonywania konwersji CRLF <-> LF dla plików tekstowych przy użyciu starej dobrej zip -llopcji (Info-ZIP):

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

UWAGA: spowoduje to utworzenie pliku zip z zachowaniem oryginalnych nazw plików, ale konwersją zakończeń linii do LF. Następnieunzip rozpakowałbym pliki jako skompresowane, czyli z ich oryginalnymi nazwami (ale z końcówkami LF), prosząc w ten sposób o zastąpienie lokalnych oryginalnych plików, jeśli takie istnieją.

Odpowiedni fragment z zip --help :

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

co ciekawe w mojej git-bash na Windowsie sed ""zrobiłem już lewę:

$ 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

Domyślam się, że sed ignoruje je podczas odczytu linii z wejścia i zawsze zapisuje na wyjściu zakończenia linii unixowych.

To zadziałało dla mnie

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

W przypadku systemu Mac OSX, jeśli masz zainstalowany program Homebrew [ http://brew.sh/][1]

brew install dos2unix

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

Upewnij się, że wykonałeś kopie plików, ponieważ to polecenie zmodyfikuje pliki na miejscu. Opcja -c mac sprawia, że ​​przełącznik jest zgodny z systemem osx.

TIMTOWTDI!

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

Na podstawie @GordonDavisson

Należy wziąć pod uwagę możliwość [noeol]...

Możesz użyć awk. Ustaw separator rekordów ( RS) na wyrażenie regularne, które pasuje do wszystkich możliwych znaków nowej linii lub znaków. I ustaw separator rekordów wyjściowych ( ORS) na znak nowej linii w stylu uniksowym.

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

W Linuksie łatwo jest przekonwertować ^ M (ctrl-M) na * nix nowe linie (^ J) za pomocą sed.

Będzie to coś takiego w interfejsie CLI, tak naprawdę nastąpi przerwanie linii w tekście. Jednak \ przekazuje to ^ J do sed:

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

Możesz to zrobić, używając ^ V (ctrl-V), ^ M (ctrl-M) i \ (ukośnik odwrotny) podczas pisania:

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

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

Ponieważ w pytaniu mowa jest o sed, jest to najprostszy sposób użycia sed, aby to osiągnąć. To, co mówi to wyrażenie, zastępuje wszystkie znaki powrotu karetki i znak wiersza tylko wierszami. Właśnie tego potrzebujesz, kiedy przechodzisz z Windowsa na Unixa. Sprawdziłem, czy to działa.

Jako rozszerzenie rozwiązania Jonathan Leffler Unix na DOS, aby bezpiecznie przekonwertować na DOS, gdy nie masz pewności co do bieżących zakończeń linii pliku:

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

To sprawdza, czy linia nie kończy się na CRLF przed konwersją do CRLF.

Stworzyłem skrypt w oparciu o zaakceptowaną odpowiedź, więc możesz go przekonwertować bezpośrednio, bez potrzeby dodatkowego pliku na końcu, a następnie usunąć i zmienić jego nazwę.

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

tylko upewnij się, że jeśli masz plik taki jak „plik1.txt”, że „plik1.txt2” jeszcze nie istnieje lub zostanie zastąpiony, używam go jako tymczasowego miejsca do przechowywania pliku.

W wersji bash 4.2 i nowszych możesz użyć czegoś takiego do usunięcia końcowego CR, który wykorzystuje tylko wbudowane bash:

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

Próbowałem sed 's / ^ M $ //' file.txt na OSX, a także kilka innych metod ( http://www.thingy-ma-jig.co.uk/blog/25-11-2010/fixing- dos-line-endings lub http://hintsforums.macworld.com/archive/index.php/t-125.html ). Żaden nie działał, plik pozostał niezmieniony (do odtworzenia ^ M potrzebny był Ctrl-v Enter). W końcu użyłem TextWrangler. Nie jest to ściśle wiersz poleceń, ale działa i nie narzeka.