Comment créer un fichier (par exemple, en utilisant la commande touch
ou une autre méthode similaire), mais avec une taille spécifique (par exemple, 14 Mo)?
Le cas d'utilisation est de tester FTP avec différentes tailles de fichiers. Si nous pouvons créer un fichier avec une taille spécifique, il sera utile de vérifier le transfert FTP, etc.
Utilisez truncate
:
truncate -s 14M filename
De man truncate
:
DESCRIPTION
Shrink or extend the size of each FILE to the specified size
[...]
-s, --size=SIZE
set or adjust the file size by SIZE
Remarque: Il est possible que truncate
ne soit pas disponible sur votre système, par exemple. sous Mac OS X, il n'est pas installé par défaut (mais vous pouvez facilement l'installer, en utilisant macports par exemple). Dans ces cas, vous devrez peut-être utiliser dd
ou head
à la place.
EDIT: La manière la plus simple est probablement la truncate
de answer de Ashutosh Vishwa Bandhu, mais comme indiqué par @ offby1 qui crée fichiers clairsemés qui peuvent ne pas être ce que vous vouloir. Les solutions ci-dessous créent des fichiers normaux et complets.
Les commandes suivantes créent un fichier de 14 Mo appelé foo
:
fallocate
(merci à @Breakthrough qui l’a suggéré dans les commentaires et votez pour le answer ci-dessous d’Ahmed Masud qui le mentionne également.)
fallocate -l 14000000 foo
Cette commande est particulièrement impressionnante car elle est aussi rapide que truncate
(instantanée) quelle que soit la taille de fichier souhaitée (contrairement aux autres solutions qui seront lentes pour les fichiers volumineux) et crée pourtant des fichiers normaux et non fragmentés:
$ truncate -s 14MB foo1.txt
$ fallocate -l 14000000 foo2.txt
$ ls -ls foo?.txt
0 -rw-r--r-- 1 terdon terdon 14000000 Jun 21 03:54 foo1.txt
13672 -rw-r--r-- 1 terdon terdon 14000000 Jun 21 03:55 foo2.txt
Créer un fichier rempli de données aléatoires
dd if=/dev/urandom of=foo bs=14MB count=1
ou
head -c 14MB /dev/urandom > foo
Créez un fichier rempli avec \0
s:
dd if=/dev/zero of=foo.txt bs=14MB count=1
ou
head -c 14MB /dev/zero > foo
Créez un fichier contenant les 14 premiers Mo de données d’un autre fichier:
head -c 14MB bar.txt > foo
Créez un fichier contenant les 14 derniers Mo de données d’un autre fichier:
tail -c 14MB bar.txt > foo
Dans tous les exemples ci-dessus, le fichier sera 14*1000*1000
si vous voulez 14*1024*1024
, remplacez MB
par M
. Par exemple:
dd if=/dev/urandom of=foo bs=14M count=1
head -c 14M /dev/zero > foo
fallocate
traite uniquement en octets, il vous faudra donc le faire (14 * 1024 * 1024 = 14680064)
fallocate -l 14680064 foo
dd bs=1MB count=14 if=/dev/zero of=<yourfilename>
WARNINGdd
écrasera silencieusement rien vous avez le droit d'écrire, si vous le spécifiez de plein gré ou par accident. Assurez-vous de comprendre dd
, par exemple. avec dd --help
, vous ne risquez rien de perdre vos lignes de commande dd, sinon vous pouvez facilement créer une perte de données irréversible - même total .
Pour commencer, if=
est le fichier d'entrée et of=
est le fichier de sortie . Toujours vérifiez que vous avez bien compris la situation avant d’exécuter la commande. :)
Utilisez magic dd
;) page de manuel
$ dd if=/dev/zero of=output.dat bs=1024 count=14336
cause 14MB * 1024 = 14336KB, ou:
$ dd if=/dev/zero of=output.dat bs=1MB count=14
Et vous obtiendrez un fichier output.dat de 14mb, rempli de zéros: D
Cela devrait être le moyen le plus rapide de le faire:
SEEK=$SIZE-1
dd if=/dev/zero of=outfile bs=1 seek=$SEEK count=1
Sinon, écrivez simplement un programme C ou Perl rapide et sale qui cherche la position exacte et écrit un seul octet. C'est BEAUCOUP plus rapide que de déposer des données sur les blocs.
Si vous voulez éviter les fichiers fragmentés, vous pouvez utiliser fallocate -l <length>
à partir de util-linux
sous Linux (et éventuellement d’autres systèmes).
Si ce n'est pas disponible et que vous avez un système compatible POSIX, vous pouvez écrire un programme rapide et sale en utilisant l'appel de la bibliothèque posix_fallocate (). posix_fallocate garantit l'allocation de la plage spécifiée, de sorte que vous n'obtiendrez pas de disque plein lors de l'utilisation ultérieure de la plage si cette dernière est renvoyée avec succès
Alors que dd
est le moyen portable de le faire, les commandes mkfile
et xfs_mkfile
sont écrites spécifiquement à cet effet et sont plus rapides:
mkfile size[b|k|m|g] filename
xfs_mkfile size[b|k|m|g] filename
Le problème est qu'aucune de ces commandes n'est universellement disponible. Elles ne sont donc pas adaptées à l'écriture de scripts portables. Cependant, si je le fais de manière interactive via la ligne de commande, ce sont les commandes que j'utilise.
Par défaut, ils créent des fichiers remplis de zéros et non des fichiers - clairsemés (ou "troués") . Ils utilisent tous les deux l'option -n
pour créer des fichiers fragmentés à la place.
Il y a une autre option avec Perl:
Perl -e 'print "a" x 1024' > file.txt
Cela créera un fichier de 1 Ko. Remplacez 1024 par le nombre de votre choix.