Como criar um arquivo do terminal repetindo um conjunto de palavras infinitamente?

Como criar um arquivo do terminal repetindo um conjunto de palavras infinitamente? Preciso criar um arquivo enorme para fins de análise, como 2 a 4 GB de tamanho. Atualmente, estou copiando manualmente as linhas de colagem no mesmo arquivo para aumentar o tamanho.

Há uma maneira fácil de repetir uma linha várias vezes:

yes we have no bananas | head -n 10000 > out.txt

resultará em out.txt contendo 10.000 linhas, todas dizendo "não temos bananas".

Para limitar a saída a um número exato de bytes, use heada -copção em vez de -n. Por exemplo, isso gera exatamente 10 kB de texto:

yes we have no bananas | head -c 10000 > out.txt

Não recomendo a repetição infinita de texto, mas você pode criar um arquivo de ~ 2 GB de texto repetido com python assim ...

python3 -c 'with open("bigfile", "w") as f: f.write(("hello world "*10+"\n")*2*10**7)'

Isso imprimirá "olá mundo" 10 vezes e criará uma nova linha e repetirá 20.000.000 vezes, escrevendo o resultado no arquivo bigfile. Se todos os seus caracteres forem ASCII, cada um será um byte, portanto calcule adequadamente, dependendo do que você deseja escrever ...

Seu processador pode ser de propriedade. Fico sem memória RAM se tentar fazer mais de 10.000.000 de linhas ...

_{Estou usando uma torradeira}

Perl tem o xoperador bacana :

$ perl -e 'print "foo\n" x 5'
foo
foo
foo
foo
foo

Portanto, como uma solução simples, você pode escrever sua linha alguns milhões de vezes. Por exemplo, este comando criou um arquivo 3G:

perl -e 'print "This is my line\n" x 200000000' > file

Se você precisar especificar um tamanho exato (2 GiB neste caso), poderá:

perl -e 'use bytes; while(length($str)<2<<20){ $str.="This is my line\n"} print "$str\n"' > file

• Coloque o conjunto de palavras a serem repetidas em um arquivo, por exemplo source.txt. Obtenha o tamanho de source.txt, em bytes, por exemplo:

   stat -c '%s' source.txt
  

• Decida o tamanho do arquivo de destino destination.txt, por exemplo , 2 GB ou 4 GB ou qualquer outra coisa. Converta o tamanho em bytes.

• Divida o tamanho do arquivo de destino pelo tamanho do arquivo de origem. bashNão é possível fazer aritmética de ponto flutuante, mas não é necessário neste caso.

• Use uma forconstrução para repetir uma cat source.txtoperação vezes o resultado da divisão. Isso seria o mais próximo possível do tamanho do arquivo de destino que você pode obter por repetição. A saída da operação é salva em destination.txt.

Por exemplo, supondo que source.txtseja de 30 bytes e desejemos criar um arquivo de 2 GB, precisamos:

for ((i=0; i<=((16777216/30)); i++)); do cat source.txt; done >destination.txt

Aqui estou definindo o limite superior ((16777216/30))no momento da inicialização; você pode obter o resultado e colocá-lo aqui também.

A operação levaria algum tempo; quanto maior source.txt, menos tempo será necessário.

Você também pode usar um whileloop.

Exemplo: Conteúdo de foo.txt(Esta é a sua fonte):

foo
bar
foobar

bar.txtestá vazio (este é o seu arquivo de destino). Agora você pode executar o seguinte loop para gravar o conteúdo foo.txtvárias vezes bar.txt:

while [ $(stat --format "%s" bar.txt) -lt 150 ] 
do 
    cat foo.txt >> bar.txt
done

Explicação:

• stat --format "%s" bar.txtexibe o tamanho bar.txtem bytes.
• while [ $(stat --format "%s" bar.txt) -lt 150 ] as ações a seguir serão repetidas até que o tamanho do destino (neste caso, 150 bytes) seja atingido.
• cat foo.txt >> bar.txtanexar o conteúdo de foo.txtparabar.txt

primeiro de disparar o comando:

dd if=/dev/urandom of=file.txt bs=2048 count=10

criará um arquivo no caminho de tamanho bs * count bytes aleatórios, no nosso caso 2048 * 10 = 20Kb. isso pode ser alterado conforme o requisito.

cat - > file.txt

Esses comandos redirecionam STDIN para um arquivo, portanto, você precisará inserir duas linhas e pressionar Ctrl + D. Então você precisará executar o seguinte comando:

for i in {1..n}; do cat file.txt file.txt > file2.txt && mv file2.txt file.txt; done

Onde n é um número inteiro. Isso criará um arquivo com 2 ^ (n + 1) linhas, duplicando as duas linhas originais. Então, para criar um arquivo com 16 linhas, você faria:

for i in {1..3}; do cat file.txt file.txt > file2.txt && mv file2.txt file.txt; done

Aqui estão mais alguns números para você começar:

n=15 will give you 65536 lines (if the original two lines were 'hello' and 'world' the file will be 384Kb)
n=20 will give you 2097152 lines (12Mb file with 'hello' and 'world' as the two starting lines)
n=25 will give you 67108864 lines (384Mb file with 'hello' and 'world' as the two starting lines)

Provavelmente, os FIFOs são o que você está procurando. Em vez de chamar seu programa com um determinado arquivo, você pode vincular o resultado de um comando do shell a ele via subtítulo do processo e o programa verá sua saída como um arquivo de texto sem formatação. A vantagem aqui é que você não está mais limitado pelo espaço em disco, para poder atingir tamanhos de arquivo que seriam impossíveis, caso contrário, desde que o seu programa não precise armazenar o arquivo inteiro em primeiro lugar e apenas possa analisá-lo linha a linha. Por exemplo, usando a resposta de @hobbs para gerar conteúdo:

wc -c <(yes we have no bananas | head -n 5000000000)

Isso me empresta um arquivo de 95 gigabytes (de acordo com o wc) sem nenhum custo no espaço do disco rígido e quase nenhuma RAM, apenas o suficiente para armazenar em buffer o que o comando retorna antes de ser lido. Isso é o mais próximo possível do "infinito".