Como converter uma nova linha do DOS / Windows (CRLF) em Nova linha do Unix (LF) em um script Bash?

Como programaticamente (ou seja, não estou usando vi) converter novas linhas de DOS / Windows para Unix?

Os comandos dos2unixe unix2dosnão estão disponíveis em determinados sistemas. Como posso emular estes com comandos como sed/ awk/ tr?

Você pode usar trpara converter do DOS para o Unix; no entanto, você só poderá fazer isso com segurança se o CR aparecer no seu arquivo apenas como o primeiro byte de um par de bytes CRLF. Este é geralmente o caso. Você então usa:

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

Observe que o nome DOS-fileé diferente do nome UNIX-file; se você tentar usar o mesmo nome duas vezes, acabará sem dados no arquivo.

Você não pode fazer o contrário (com o padrão 'tr').

Se você souber inserir retorno de carro em um script ( control-V, control-Mpara inserir control-M), então:

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

onde o '^ M' é o caractere control-M. Você também pode usar o mecanismo de bash cotação ANSI-C para especificar o retorno de carro:

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

No entanto, se você precisar fazer isso com muita frequência (mais de uma vez, grosso modo), é muito mais sensato instalar os programas de conversão (por exemplo , dos2unixe unix2dos, ou talvez dtoue utod) e usá-los.

Se você precisar processar diretórios e subdiretórios inteiros, poderá usar zip:

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

Isso criará um arquivo zip com as terminações de linha alteradas de CRLF para CR. unzipEm seguida, os arquivos convertidos serão restaurados (e você solicitará arquivo por arquivo - você poderá responder: Sim para todos). Créditos para @vmsnomad por apontar isso.

tr -d "\r" < file

veja aqui exemplos usando 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

Use sed -ipara conversão no local, por exemplo sed -i 's/..../' file.

Fazer isso com o POSIX é complicado:

• O POSIX Sed não suporta \rou \15. Mesmo se tiver, a opção no local -inão é POSIX

• O POSIX Awk suporta \re \15, no entanto, a -i inplaceopção não é POSIX

• O d2u e o dos2unix não são utilitários POSIX , mas ex é

• POSIX ex não suporta \r, \15, \nou\12

Para remover retornos de carro:

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

Para adicionar retornos de carro:

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

Você pode usar o vim programaticamente com a opção -c {command}:

Dos para Unix:

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

Unix para dos:

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

"definir ff = unix / dos" significa alterar o formato do arquivo (ff) do arquivo para o formato final de linha do Unix / DOS

": wq" significa gravar o arquivo no disco e sair do editor (permitindo usar o comando em um loop)

Usando o AWK, você pode:

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

Usando Perl você pode fazer:

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

Para converter um arquivo no local, use

dos2unix <filename>

Para gerar texto convertido para um arquivo diferente, use

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

Você pode instalá-lo no Ubuntu ou Debian com

sudo apt install dos2unix

ou no macOS usando homebrew

brew install dos2unix

Esse problema pode ser resolvido com ferramentas padrão, mas existem muitos traps para os incautos que eu recomendo que você instale o flipcomando, que foi escrito há mais de 20 anos por Rahul Dhesi, autor de zoo. Ele faz um excelente trabalho na conversão de formatos de arquivo e, por exemplo, evita a destruição inadvertida de arquivos binários, o que é um pouco fácil demais se você apenas alterar todos os CRLF que vê ...

As soluções postadas até agora tratam apenas de parte do problema, convertendo o CRLF do DOS / Windows no LF do Unix; a parte que falta é que o DOS use CRLF como separador de linhas , enquanto o Unix use LF como terminador de linhas . A diferença é que um arquivo DOS (geralmente) não terá nada após a última linha do arquivo, enquanto o Unix terá. Para fazer a conversão corretamente, você precisa adicionar o LF final (a menos que o arquivo tenha tamanho zero, ou seja, não possui linhas). Meu encantamento favorito para isso (com um pouco de lógica adicional para lidar com arquivos separados por CR no estilo Mac, e não molestar arquivos que já estão no formato unix) é um pouco de perl:

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

Observe que isso envia a versão Unixified do arquivo para stdout. Se você deseja substituir o arquivo por uma versão Unixified, adicione o -isinalizador do perl .

Se você não tem acesso ao dos2unix , mas pode ler esta página, pode copiar / colar o dos2unix.py daqui.

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

Postada cruzada do superusuário .

Super fácil com PCRE;

Como um script ou substitua $@pelos seus arquivos.

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

Isso substituirá seus arquivos no lugar!

Eu recomendo fazer isso apenas com um backup (controle de versão ou não)

Uma solução awk ainda mais simples sem um programa:

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

Tecnicamente '1' é o seu programa, o b / c awk requer um quando é dada a opção.

ATUALIZAÇÃO : Depois de revisitar esta página pela primeira vez em muito tempo, percebi que ninguém ainda havia publicado uma solução interna, então aqui está uma:

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

Curiosamente no meu git-bash no Windows sed ""já fiz o truque:

$ 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

Meu palpite é que o sed os ignora ao ler as linhas da entrada e sempre escreve finais de linha unix na saída.

Isso funcionou para mim

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

Só tive que refletir sobre a mesma pergunta (no lado do Windows, mas igualmente aplicável ao Linux.) Surpreendentemente, ninguém mencionou uma maneira muito automatizada de fazer a conversão CRLF <-> LF para arquivos de texto usando a boa e velha zip -llopção (Info-ZIP):

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

NOTA: isso criaria um arquivo zip preservando os nomes originais, mas convertendo as terminações de linha em LF. Em seguida unzip, extrairia os arquivos como zipados, ou seja, com seus nomes originais (mas com terminações LF), solicitando a substituição dos arquivos originais locais, se houver.

Trecho relevante de zip --help:

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

Para o Mac osx, se você tiver o homebrew instalado [ http://brew.sh/{/1]

brew install dos2unix

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

Verifique se você fez cópias dos arquivos, pois este comando modificará os arquivos no local. A opção -c mac torna o switch compatível com osx.

TIMTOWTDI!

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

Baseado em @GordonDavisson

É preciso considerar a possibilidade de [noeol]...

Você pode usar o awk. Defina o separador de registro ( RS) como uma expressão regular que corresponda a todos os caracteres ou caracteres de nova linha possíveis. E defina o separador de registro de saída ( ORS) como o caractere de nova linha no estilo unix.

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

No Linux, é fácil converter ^ M (ctrl-M) em * nix novas linhas (^ J) com sed.

Será algo assim na CLI, haverá realmente uma quebra de linha no texto. No entanto, o \ passa esse ^ J para sed:

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

Você obtém isso usando ^ V (ctrl-V), ^ M (ctrl-M) e \ (barra invertida) enquanto digita:

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

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

Como a pergunta menciona o sed, esta é a maneira mais direta de usar o sed para conseguir isso. O que a expressão diz é substituir todo retorno de carro e avanço de linha por apenas apenas avanço de linha. É disso que você precisa quando passa do Windows para o Unix. Eu verifiquei que funciona.

Como uma extensão da solução Unix para DOS de Jonathan Leffler, para converter com segurança para o DOS quando você não tiver certeza das terminações de linha atuais do arquivo:

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

Isso verifica se a linha ainda não termina em CRLF antes de converter em CRLF.

Eu criei um script com base na resposta aceita para que você possa convertê-lo diretamente sem precisar de um arquivo adicional no final e remover e renomear posteriormente.

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

apenas verifique se você possui um arquivo como "file1.txt" que "file1.txt2" ainda não exista ou será substituído, use-o como um local temporário para armazenar o arquivo.

Com o bash 4.2 e mais recente, você pode usar algo parecido com isto para remover o CR à direita, que usa apenas os built-ins do bash:

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

Tentei sed / ^ M $ // 'file.txt no OSX, bem como vários outros métodos ( http://www.thingy-ma-jig.co.uk/blog/25-11-2010/fixing- finais de linha dos ou http://hintsforums.macworld.com/archive/index.php/t-125.html ). Nenhum funcionou, o arquivo permaneceu inalterado (entre Ctrl-v Enter era necessário para reproduzir ^ M). No final, eu usei o TextWrangler. Não é estritamente linha de comando, mas funciona e não se queixa.