Come creare un file dal terminale ripetendo una serie di parole all'infinito?

Come creare un file dal terminale ripetendo una serie di parole all'infinito? Ne ho bisogno per creare un file enorme per scopi di analisi come 2-4 GB di dimensioni. Attualmente sto copiando manualmente le linee di incollaggio nello stesso file per aumentare le dimensioni.

C'è un modo semplice per ripetere una riga molte volte:

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

risulterà in out.txt contenente 10.000 righe che dicono "non abbiamo banane".

Per limitare l 'output a un numero esatto di byte, utilizzare l head' -copzione anziché -n. Ad esempio, questo genera esattamente 10 kB di testo:

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

Non posso raccomandare di ripetere all'infinito il testo, ma potresti creare un file ~ 2GB di testo ripetuto con Python in questo modo ...

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

Che stamperà "ciao mondo" 10 volte e farà una nuova riga, e lo ripeterà 20.000.000 di volte, scrivendo il risultato nel file bigfile. Se tutti i tuoi caratteri sono ASCII, ognuno è un byte, quindi calcola in modo appropriato a seconda di ciò che vuoi scrivere ...

La tua cpu potrebbe essere di proprietà. A corto di RAM se provo a fare più di 10.000.000 di righe ...

_{Sto facendo funzionare un tostapane}

Perl ha l' xoperatore elegante :

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

Quindi, come soluzione semplice, potresti semplicemente scrivere la riga qualche milione di volte. Ad esempio, questo comando ha creato un file 3G:

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

Se devi specificare una dimensione esatta (2 GiB in questo caso), puoi fare:

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

• Inserisci l'insieme di parole da ripetere in un file ad es source.txt. Ottieni la dimensione del source.txt, in byte, ad esempio:

   stat -c '%s' source.txt
  

• Decidi la dimensione del file di destinazione destination.txt, ad esempio 2 GB o 4 GB o altro. Converti la dimensione in byte.

• Dividi la dimensione del file di destinazione per la dimensione del file di origine. bashnon può eseguire l'aritmetica in virgola mobile, ma in questo caso non è necessaria.

• Utilizzare un forcostrutto per ripetere cat source.txtun'operazione il risultato della divisione volte. Questo sarebbe approssimativo più vicino alla dimensione del file di destinazione che è possibile ottenere ripetendo. L'output dell'operazione viene salvato in destination.txt.

Ad esempio, supponendo che source.txtsia di 30 byte e vogliamo creare un file da 2 GB, abbiamo bisogno di:

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

Qui sto impostando il limite superiore entro ((16777216/30))al momento dell'inizializzazione; puoi ottenere il risultato e metterlo anche qui.

L'operazione richiederebbe del tempo; più grande è source.txt, meno tempo sarà necessario.

Puoi anche usare un while-loop.

Esempio: contenuto di foo.txt(Questa è la tua fonte):

foo
bar
foobar

bar.txtè vuoto (questo è il tuo file di destinazione). È ora possibile eseguire il ciclo seguente per scrivere il contenuto foo.txtpiù volte in bar.txt:

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

Spiegazione:

• stat --format "%s" bar.txtvisualizza la dimensione bar.txtin byte.
• while [ $(stat --format "%s" bar.txt) -lt 150 ] le seguenti azioni verranno ripetute fino al raggiungimento della dimensione target (in questo caso 150 byte).
• cat foo.txt >> bar.txtaggiungere il contenuto di foo.txtabar.txt

prima di tutto il comando:

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

creerà un file sul percorso di dimensione bs * conta byte casuali, nel nostro caso 2048 * 10 = 20Kb. che può essere modificato secondo il requisito.

cat - > file.txt

Questo comando reindirizza STDIN su un file, quindi dovrai inserire due righe e quindi premere Ctrl + D. Quindi dovrai eseguire il comando seguente:

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

Dove n è un numero intero. Questo creerà un file con 2 ^ (n + 1) righe, duplicando le due righe originali. Quindi per creare un file con 16 righe devi fare:

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

Ecco alcuni altri numeri per iniziare:

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)

I FIFO sono probabilmente quello che stai cercando. Invece di chiamare il tuo programma con un determinato file, puoi legare il risultato di un comando shell ad esso tramite la sottotitolazione del processo e il programma vedrà il suo output come un file di testo semplice. Il vantaggio qui è che non sei più limitato dal tuo spazio su disco, quindi puoi raggiungere dimensioni di file altrimenti impossibili, a condizione che il tuo programma non debba prima bufferizzare l'intero file e semplicemente analizzarlo riga per riga. Ad esempio, usando la risposta di @hobbs per generare contenuto:

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

Questo mi dà un file di 95 gigabyte (secondo wc) senza alcun costo nello spazio dell'HDD e quasi nessuna RAM, quanto basta per bufferizzare ciò che il comando restituisce prima che venga letto. Questo è quasi "infinitamente" quanto si arriva.