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

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 tutte che dicono "non abbiamo banane".

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

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

Non posso raccomandare infinitamente testo ripetuto, ma potresti creare un file ~ 2GB di testo ripetuto con python come ...

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

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

La tua cpu potrebbe essere di proprietà. Ho esaurito la RAM se provo a fare più di 10.000.000 di righe ...

_{Sto facendo funzionare un tostapane però}

Perl ha l'operatore nifty x :

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

Quindi, come soluzione semplice, potresti scrivere la tua linea poche milioni 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. %codice%. Ottieni la dimensione di source.txt , in byte, ad es. da:

   stat -c '%s' source.txt
  

• Decidi la dimensione del file di destinazione, ad es. source.txt , 2 GB o 4 GB o qualsiasi altra cosa. Converti le dimensioni in byte.

• Dividere le dimensioni del file di destinazione in base alla dimensione del file di origine. destination.txt non può fare aritmetica in virgola mobile, ma in questo caso non è necessaria.

• Utilizza un costrutto bash per ripetere un'operazione di for i tempi dei risultati di divisione. Questo sarebbe il più vicino approssimativo della dimensione del file di destinazione che è possibile ottenere con la ripetizione. L'output dell'operazione viene salvato in cat source.txt .

Ad esempio, supponendo che destination.txt sia 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 di source.txt al momento dell'inizializzazione; puoi ottenere il risultato e metterlo anche qui.

L'operazione richiederebbe un po 'di tempo; maggiore è il ((16777216/30)) , minore sarà il tempo necessario.

Puoi anche utilizzare while -loop.

Esempio: Contenuto di foo.txt (questa è la tua fonte):

foo
bar
foobar

bar.txt è vuoto (Questo è il tuo file di destinazione). Ora puoi rn il seguente ciclo per scrivere il contenuto di foo.txt più volte in bar.txt :

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

Spiegazione:

• stat --format "%s" bar.txt mostra la dimensione di bar.txt in byte.
• while [ $(stat --format "%s" bar.txt) -lt 150 ] le seguenti azioni verranno ripetute fino a raggiungere la dimensione di destinazione (in questo caso 150 byte).
• cat foo.txt >> bar.txt aggiunge il contenuto di foo.txt a bar.txt

prima di attivare il comando:

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

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

cat - > file.txt

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

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) linee, duplicando le due linee originali. Quindi, per creare un file con 16 righe, dovresti 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 ciò che stai cercando. Invece di chiamare il tuo programma con un dato file, puoi legare il risultato di un comando di shell ad esso tramite processare la sottotitolazione e il programma vedrà il suo output come un file di testo in chiaro. Il vantaggio qui è che non si è più limitati dallo spazio su disco, quindi è possibile raggiungere file che altrimenti sarebbero impossibili, purché il programma non abbia bisogno di bufferizzare per intero l'intero file e può solo analizzarlo riga per riga. Ad esempio, utilizzando la risposta di @hobbs per generare contenuti:

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

Questo mi presta un file di 95 gigabyte (secondo wc) a costo zero nello spazio dell'hard disk e a malapena in qualsiasi RAM, quanto basta per bufferizzare ciò che il comando restituisce prima che venga letto. Questo è il più vicino a "infinitamente" come si otterrà.