So speichern Sie große Dateien auf Fat32

Ich wollte eine große Videodatei auf einem FAT32-Laufwerk (~ 18 GB) speichern, stellte jedoch fest, dass dies aufgrund von Einschränkungen des Dateisystems nicht einfach möglich ist.

Gibt es ein einfaches Tool, mit dem Sie die Datei in kleinere Teile aufteilen können, die gespeichert werden können, und diese dann wieder zusammensetzen können, wenn ich die archivierte Datei abrufen möchte?

Oder gibt es eine bessere Möglichkeit, große Dateien auf FAT32 zu speichern?

Bei den meisten Dateiarchivierern wie 7-Zip , WinZip und WinRAR können Sie ein Archiv auf mehrere Dateien aufteilen. Wenn Geschwindigkeit wichtig ist, können Sie versuchen, den Komprimierungsteil des Programms zu deaktivieren.

Auf GNU / Linux-Systemen können Sie die Split- und Cat- Programme aus dem Coreutils-Paket verwenden (z. B. split -b 4294967295 FOO /media/FATDISK/BARum FOO in BARaa, BARab usw. aufzuteilen und cat /media/FATDISK/BAR?? > FOOwieder zusammenzusetzen). Das Befehlszeilenprogramm von Mac OS X splitfunktioniert auf die gleiche Weise.

Am Ende habe ich ein kleines Python 2-Skript geschrieben, um dies zu erreichen.

# Author: Alex Finkel 
# Email: [email protected]

# This program splits a large binary file into smaller pieces, and can also 
# reassemble them into the original file.

# To split a file, it takes the name of the file, the name of an output 
# directory, and a number representing the number of desired pieces.

# To unsplit a file, it takes the name of a directory, and the name of an 
# output file.

from sys import exit, argv
from os import path, listdir

def split(file_to_split, output_directory, number_of_chunks):
    f = open(file_to_split, 'rb')
    assert path.isdir(output_directory)
    bytes_per_file = path.getsize(file_to_split)/int(number_of_chunks) + 1
    for i in range(1, int(number_of_chunks)+1):
        next_file = open(path.join(output_directory, str(i)), 'wb')
        next_file.write(f.read(bytes_per_file))
        next_file.close()
    f.close()

def unsplit(directory_name, output_name):
    assert path.isdir(directory_name)
    files = map(lambda x: str(x), sorted(map(lambda x: int(x), listdir(directory_name))))
    out = open(output_name, 'wb')
    for file in files:
        f = open(path.join(directory_name, file), 'rb')
        out.write(f.read())
        f.close()
    out.close()


if len(argv) == 4:
    split(argv[1], argv[2], argv[3])
elif len(argv) == 3:
    unsplit(argv[1], argv[2])
else:
    print "python split_large_file.py file_to_split output_directory number_of_chunks"
    print "python split_large_file.py directory name_of_output_file"
    exit()

Eine weitere Option: Verwenden Sie den splitBefehl von GNU Coreutils:

split --bytes=4G infile /media/FAT32drive/outprefix

um die Datei in 4-GB-Blöcke aufzuteilen und die Blöcke auf dem Ausgabelaufwerk zu speichern.

Die Originaldatei kann durch Verketten der Chunks (mit alphabetisch sortierten Dateinamen) wiederhergestellt werden.

Informationen zur Verwendung finden Sie im splitHandbuch .

Coreutils, einschließlich split, sollten standardmäßig unter Linux und Mac OS X installiert werden. Unter Windows ist es von GnuWin32 oder von Cygwin erhältlich.

Ich hatte genau dieses Problem und löste es mithilfe der bereits veröffentlichten Antworten, aber keiner von ihnen beschrieb die Methode genau.

ich benutzte

split --bytes=3G infile /media/FAT32drive/outprefix

die infile in mehreren Dateien mit den Namen outprefixaa, outprefixab, outprefixac usw. mit einer maximalen Größe von 3 GB speichern - als ich versuchte, 4 GB auf Fat 32 zu verwenden, schlug dies fehl.

um die von mir verwendeten Dateien neu zu kombinieren

cat /media/FAT32drive/outprefix?? > infile

Um genauere Details zu geben, habe ich dies in Windows gemacht, aber mit einem Cygwin-Fenster. Der Dateipfad in meinem Fall für die externe FAT32-Festplatte war also/cydrive/e/