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

Question

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

    

Answer 1

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 a opção head -c em vez de -n . Por exemplo, isso gera exatamente 10 kB de texto:

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

    

Answer 2

Eu não posso recomendar infinitamente repetição de texto, mas você pode fazer um arquivo ~ 2GB 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á "hello world" 10 vezes e criará uma nova linha, e repetirá isso 20.000.000 vezes, gravando o resultado no arquivo bigfile . Se todos os seus caracteres são ASCII, então cada um é um byte, então calcule apropriadamente dependendo do que você quer escrever ...

Seu cpu pode ser de propriedade. Eu fico sem RAM se eu tentar fazer mais de 10.000.000 linhas ...

_{Eu estou executando uma torradeira embora}

    

Answer 3

Perl tem o operador x bacana:

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

Então, como uma solução simples, você poderia 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), você pode fazer:

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

    

Answer 4

• Coloque o conjunto de palavras para ser repetido em um arquivo, por exemplo %código%. Obtenha o tamanho do source.txt , em bytes, por ex. por:

   stat -c '%s' source.txt
  

• Decida o tamanho do arquivo de destino, por exemplo source.txt , 2 GB ou 4 GB ou o que for. Converta o tamanho em bytes.

• Divida o tamanho do arquivo de destino pelo tamanho do arquivo de origem. destination.txt não pode fazer aritmética de ponto flutuante, mas não é necessário neste caso.

• Use uma construção bash para repetir uma operação for nos tempos de resultado da divisão. Isso seria o mais aproximado do tamanho do arquivo de destino que você pode obter por repetição. A saída da operação é salva em cat source.txt .

Por exemplo, supondo que destination.txt seja de 30 bytes e queiramos criar um arquivo de 2 GB, precisamos:

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

Aqui estou configurando o limite superior em source.txt no momento da inicialização; você pode obter o resultado e colocá-lo aqui também.

A operação levaria algum tempo; quanto maior for o ((16777216/30)) , menos tempo será necessário.

    

Answer 5

Você também pode usar um while -loop.

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

foo
bar
foobar

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

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

Explicação:

• stat --format "%s" bar.txt exibe o tamanho de bar.txt em bytes.
• while [ $(stat --format "%s" bar.txt) -lt 150 ] as seguintes ações serão repetidas até que o tamanho do alvo (neste caso 150 bytes) seja atingido.
• cat foo.txt >> bar.txt acrescenta o conteúdo de foo.txt a bar.txt

Answer 6

primeiro de acionar o comando:

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

irá criar um arquivo no caminho do tamanho bs * count bytes aleatórios, no nosso caso 2048 * 10 = 20Kb. que pode ser alterado conforme a exigência.

cat - > file.txt

Este comando redireciona STDIN para um arquivo, então 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 inteiro. Isto criará um arquivo com 2 ^ (n + 1) linhas, duplicando suas 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)

    

Answer 7

FIFOs são provavelmente o que você está procurando. Em vez de chamar seu programa com um determinado arquivo, você pode vincular o resultado de um comando shell a ele por meio de processo de legalização e o programa verá sua saída como um arquivo de texto simples. A vantagem aqui é que você não está mais limitado pelo seu espaço em disco, então você pode acessar arquivos que seriam impossíveis de outra forma, desde que seu programa não precise armazenar em buffer todo o arquivo primeiro e possa apenas analisá-lo linha por linha. Por exemplo, usando a resposta do @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 HDD 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 de "infinitamente" que você vai conseguir.