Comment créer un fichier depuis un terminal en répétant un ensemble de mots à l'infini?

Comment créer un fichier depuis un terminal en répétant un ensemble de mots à l'infini? J'en ai besoin pour créer un énorme fichier à des fins d'analyse comme une taille de 2 à 4 Go. Actuellement, je copie manuellement les lignes de collage dans le même fichier pour augmenter la taille.

Il existe un moyen simple de répéter une ligne plusieurs fois:

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

se traduira par out.txt contenant 10 000 lignes disant toutes "nous n'avons pas de bananes".

Pour limiter la sortie à un nombre exact d'octets, utilisez headl' -coption de au lieu de -n. Par exemple, cela génère exactement 10 Ko de texte:

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

Je ne peux pas recommander de répéter du texte à l' infini , mais vous pouvez créer un fichier ~ 2 Go de texte répété avec python comme ça ...

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

Cela imprimera "bonjour le monde" 10 fois et fera une nouvelle ligne, et répétera cela 20 000 000 fois, en écrivant le résultat dans le fichier bigfile. Si tous vos caractères sont ASCII, alors chacun est un octet, alors calculez correctement en fonction de ce que vous voulez écrire ...

Votre processeur peut appartenir. Je manque de RAM si j'essaie de faire plus de 10 000 000 de lignes ...

_{Je lance un grille-pain cependant}

Perl a l' xopérateur astucieux :

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

Donc, comme solution simple, vous pourriez simplement écrire votre ligne quelques millions de fois. Par exemple, cette commande a créé un fichier 3G:

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

Si vous devez spécifier une taille exacte (2 Gio dans ce cas), vous pouvez faire:

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

• Mettez l'ensemble de mots à répéter dans un fichier par exemple source.txt. Obtenez la taille du source.txt, en octets par exemple par:

   stat -c '%s' source.txt
  

• Décidez de la taille du fichier de destination, par exemple destination.txt, 2 Go ou 4 Go ou autre. Convertissez la taille en octets.

• Divisez la taille du fichier de destination par la taille du fichier source. bashne peut pas faire d'arithmétique en virgule flottante, mais ce n'est pas nécessaire dans ce cas.

• Utilisez une forconstruction pour répéter une cat source.txtopération les temps de résultat de division. Ce serait approximativement le plus proche de la taille du fichier de destination que vous pouvez obtenir par répétition. La sortie de l'opération est enregistrée dans destination.txt.

Par exemple, en supposant que le source.txtest de 30 octets et que nous voulons créer un fichier de 2 Go, nous avons besoin de:

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

Ici, je fixe la limite supérieure ((16777216/30))au moment de l'initialisation; vous pouvez obtenir le résultat et le mettre ici aussi.

L'opération prendrait un certain temps; plus la taille est grande source.txt, moins il faudra de temps.

Vous pouvez également utiliser une whileboucle.

Exemple: Contenu de foo.txt(Ceci est votre source):

foo
bar
foobar

bar.txtest vide (il s'agit de votre fichier cible). Vous pouvez maintenant exécuter la boucle suivante pour écrire le contenu de foo.txtplusieurs fois dans bar.txt:

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

Explication:

• stat --format "%s" bar.txtaffiche la taille bar.txten octets.
• while [ $(stat --format "%s" bar.txt) -lt 150 ] les actions suivantes seront répétées jusqu'à ce que la taille cible (dans ce cas 150 octets) soit atteinte.
• cat foo.txt >> bar.txtajouter le contenu de foo.txtàbar.txt

d'abord tirer la commande:

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

va créer un fichier sur le chemin de taille bs * compter les octets aléatoires, dans notre cas 2048 * 10 = 20Kb. qui peut être changé selon l'exigence.

cat - > file.txt

Cette commande redirige STDIN vers un fichier, vous devrez donc entrer deux lignes, puis appuyez sur Ctrl + D. Ensuite, vous devrez exécuter la commande suivante:

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

Où n est un entier. Cela créera un fichier contenant 2 ^ (n + 1) lignes, en dupliquant vos deux lignes d'origine. Donc, pour créer un fichier avec 16 lignes, vous feriez:

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

Voici quelques chiffres supplémentaires pour vous aider à démarrer:

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)

Les FIFO sont probablement ce que vous recherchez. Au lieu d'appeler votre programme avec un fichier donné, vous pouvez lui lier le résultat d'une commande shell via la sous- substitution de processus et le programme verra sa sortie sous forme de fichier en clair. L'avantage ici est que vous n'êtes plus limité par votre espace disque, vous pouvez donc atteindre des tailles de fichiers qui seraient impossibles autrement, tant que votre programme n'a pas besoin de tamponner tout le fichier en premier et qu'il peut simplement l'analyser ligne par ligne. Par exemple, en utilisant la réponse de @hobbs pour générer du contenu:

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

Cela me donne un fichier de 95 gigaoctets (selon wc) sans frais dans l'espace disque dur et à peine n'importe quelle RAM, juste assez pour tamponner ce que la commande retourne avant qu'elle ne soit lue. C'est à peu près aussi "infiniment" que vous allez en avoir.