{"id":8012,"date":"2021-07-26T18:37:17","date_gmt":"2021-07-26T18:37:17","guid":{"rendered":"https:\/\/profi-tutorials.de\/linux\/?p=8012"},"modified":"2021-08-25T10:07:10","modified_gmt":"2021-08-25T10:07:10","slug":"befehl-split","status":"publish","type":"post","link":"https:\/\/profi-tutorials.de\/linux\/grundlagen\/befehl-split\/","title":{"rendered":"Der Befehl split"},"content":{"rendered":"

Der Befehl split wird unter Linux \/ UNIX dazu verwendet, um Dateien beliebig in kleinere Dateien aufzuteilen. Eingesetzt wird der Befehl etwa, wenn die Verarbeitung von Zeilen einer Textdatei in mehrere gleich große “Blöcke” – beispielsweise je 250 Zeilen – aufgeteilt werden soll. Weiterhin kann der Befehl auch bei der Datensicherung oder Verteilung sehr großer Dateien verwendet werden. Wenn gewünscht, lassen sich die Einzeldateien zu einem späteren Zeitpunkt auch wieder zusammenfügen – da es sich nicht um ein proprietäres Format handelt, ist dies zudem auf beliebigen Plattformen möglich.<\/p>\n

Im Folgenden wird zunächst die allgemeine Syntax<\/a> des Befehls vorgestellt. Im Anschluss folgen einige der wichtigsten Optionen mitsamt Beispielanwendungen zu Veranschaulichung der Funktionsweise.<\/p>\n

Allgemeine Syntax<\/h2>\n

Die allgemeine Syntax des Befehls split <\/strong>lautet folgendermaßen:<\/p>\n

split [Optionen] [Datei [Präfix]]<\/pre>\n
Standardmäßig teilt split <\/strong>die übergebene Datei in kleinere Dateien mit der Benennung “[Präfix]aa”<\/strong>, “[Präfix]ab”<\/strong>, “[Präfix]ac”<\/strong> etc. auf. Die Buchstaben, die den zweistelligen Suffix ausmachen, werden so verwendet, als handele es sich um ein Stellenwertsystem zur Basis 26. So ist es möglich, mit der Standard-Suffix-Länge von zwei Buchstaben bis zu 676 Teildateien zu erhalten. Wird kein Präfix spezifiziert, so ist “x”<\/strong> der Standartwert. Weiterhin ist standardmäßig die Anzahl Zeilen pro Teildatei auf 1000 begrenzt – entsprechend würde eine Datei mit 5000 Zeilen in 5 kleinere Dateien aufgeteilt werden.<\/p>\n
Wichtige Optionen<\/h2>\n
In diesem Abschnitt lernen Sie nun einige der wichtigsten Optionen des Befehls split <\/strong>kennen.<\/p>\n
-a – Suffix-Länge<\/h3>\n
Mit der Option -a<\/strong> können Sie die Länge des Suffix, welcher standardmäßig zweistellig ist, einstellen:<\/p>\n
split -a [Länge] [Datei [Präfix]]<\/pre>\n
Beispiel: Option -a<\/h5>\n
In diesem Beispiel wird die Länge des Suffix auf <\/span>“1” festgelegt und anschließend eine Datei <\/span>“befehl-cat.txt” aufgeteilt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
split -a 1 befehl-cat.txt<\/p>\n
Nach Ausführung:<\/h6>\n
Der Befehl erzeugt entsprechend der Länge der Eingabedatei Ausgabedateien mit der folgenden Benennung:<\/p>\n
xa<\/p>\n
xb<\/p>\n
…<\/p>\n
–additional-suffix – Zusätzlicher Suffix<\/h3>\n
Die Option –additional-suffix<\/strong> kann verwendet werden, um einen zusätzlichen Suffix, wie beispielsweise eine Dateiendung, hinten an den Zähl-Suffix anzuhängen:<\/p>\n
split --additional-suffix [Suffix] [Datei [Präfix]]<\/pre>\n
Beispiel: Option –additional-suffix<\/h5>\n
Hier wird ein zusätzlicher Suffix spezifiziert und dann eine Datei <\/span>“befehl-cat.txt” aufgeteilt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
split –additional-suffix “.txt” befehl-sudo.txt<\/p>\n
Nach Ausführung:<\/h6>\n
Der Befehl erzeugt entsprechend der Länge der Eingabedatei Ausgabedateien mit der folgenden Benennung:<\/p>\n
xaa.txt<\/p>\n
xab.txt<\/p>\n
…<\/p>\n
-b – Bytes pro Ausgabedatei<\/h3>\n
Mithilfe der Option -b<\/strong> kann die Anzahl Bytes, die pro Ausgabedatei geschrieben wird, festgelegt werden:<\/p>\n
split -b [Größe] [Datei [Präfix]]<\/pre>\n
Die [Größe]<\/strong> stellt dabei einen Integer dar, welcher optional von einem multiplikativen Suffix “b”<\/strong> (Blöcke), “KB”<\/strong> (Kilobytes), “K”<\/strong> (Kibibytes), “MB”<\/strong> (Megabytes), “M”<\/strong> (Mibibytes), “GB”<\/strong> (Gigabytes) “G”<\/strong> (Gibibytes) etc. gefolgt wird.<\/p>\n
-C – Bytes Datensätze pro Ausgabedatei<\/h3>\n
Bei Verwendung der Option -C<\/strong> werden so viele vollständige Datensätze wie möglich in jede Ausgabedatei geschrieben, ohne dabei [Größe]<\/strong> Bytes pro Ausgabedatei zu überschreiten. Einzelne Datensätze, die länger als die angegebene Größe sind, werden in mehrere Dateien aufgeteilt:<\/p>\n
split -C [Größe] [Datei [Präfix]]<\/pre>\n
[Größe]<\/strong> hat dasselbe Format, wie auch bei der Option -b<\/strong>.<\/p>\n
–d – numerische Suffixe verwenden<\/h3>\n
Wird die Option -d<\/strong> angegeben, so werden numerische Ziffern<\/strong> anstelle von Buchstaben zur Nummerierung der Ausgabedateien verwendet:<\/p>\n
split -d [Datei [Präfix]]<\/pre>\n
Optional kann ein Startwert für das Zählen angegeben werden – hierzu wird dann jedoch die Option  –numeric-suffixes<\/strong> benötigt:<\/p>\n
split --numeric-suffixes=[Startwert] [Datei [Präfix]]<\/pre>\n
Der Standard-Startwert ist 0.<\/p>\n
Beispiel: Option –numeric-suffixes<\/h5>\n
In diesem Beispiel sollen numerische Suffixe verwendet werden, wobei die Zählung mit der 1 beginnen soll.<\/span><\/h6>\n
Eingabe:<\/h6>\n
split –numeric-suffixes=1 befehl-sudo.txt<\/p>\n
Nach Ausführung:<\/h6>\n
Die Ausgabedateien werden wie folgt benannt:<\/p>\n
x01<\/p>\n
x02<\/p>\n
…<\/p>\n
-l – Anzahl Datensätze pro Ausgabedatei<\/h3>\n
Mit der Option -l<\/strong> kann die Anzahl Datensätze spezifiziert werden, die pro Ausgabedatei geschrieben werden sollen:<\/p>\n
split -l [Anzahl] [Datei [Präfix]]<\/pre>\n
Beispiel: Option -l<\/h5>\n
Die Anzahl Datensätze (Zeilen) pro Ausgabedatei soll in diesem Beispiel auf 250 gesetzt, werden. Im Beispiel wird so etwa eine Datei <\/span>“benutzer.txt” mit 1000 Benutzernamen in 4 Teildateien aufgeteilt, die dann jeweils 250 Zeilen der Eingabe beinhalten.<\/span><\/h6>\n
Eingabe:<\/h6>\n
split -l 250 befehl-sudo.txt<\/p>\n
Nach Ausführung:<\/h6>\n
xaa<\/p>\n
xab<\/p>\n
xac<\/p>\n
xad<\/p>\n
-t – Trennzeichen für Datensätze<\/h3>\n
Mithilfe der Option -t<\/strong> können Sie ein Trennzeichen<\/a> festlegen, welches anstelle des standardmäßigen Zeilenumbruchs (ASCII LF) verwendet werden soll, um Datensätze zu trennen:<\/p>\n
split -t [Trennzeichen] [Datei [Präfix]]<\/pre>\n
Soll das NUL-Zeichen als Trennzeichen verwendet werden, so wird der Option die Zeichenkette<\/a> “”<\/strong> übergeben:<\/p>\n
split -t '' [Datei [Präfix]]<\/pre>\n
-n – TEILE Ausgabedateien erstellen<\/h3>\n
Die Option -n<\/strong> wird verwendet, um die Eingabe in [Teile]<\/strong> Ausgabedateien zu teilen:<\/p>\n
split -n [Teile] [Datei [Präfix]]<\/pre>\n
[Teile]<\/strong> hat hierbei eines der folgenden Formate:<\/p>\n\n\n\n\n\n\n\n\n\n\n
Format<\/strong><\/th>\nFunktion<\/th>\n<\/tr>\n<\/thead>\n
N<\/td>\nErzeuge N Ausgabedateien basierend auf der Größe der derzeitigen Eingabe<\/td>\n<\/tr>\n
K\/N<\/td>\nNur K-te von N in den Standard-Output stdout ausgeben<\/td>\n<\/tr>\n
l\/N<\/td>\nErzeuge N Ausgabedateien ohne Zeilen oder Datensätze zu teilen<\/td>\n<\/tr>\n
l\/K\/N<\/td>\nWie “l\/N”, aber nur K-te von N in den Standard-Output stdout ausgeben<\/td>\n<\/tr>\n
r\/N<\/td>\nWie “rN” aber Round-Robin-Verfahren verwenden<\/td>\n<\/tr>\n
r\/K\/N<\/td>\nWie “r\/N”, aber nur K-te von N in den Standard-Output stdout ausgeben<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Jegliche übrige Bytes nach Teilen der Eingabe in N<\/strong> Teile werden dem letzten Teil angefügt. Weiterhin werden übrige Bytes, die nach der initialen Berechnung auftauchen, ignoriert – außer es wird der “r”<\/strong>-Modus verwendet.<\/p>\n
Alle N<\/strong> Ausgabedateien werden erzeugt, auch wenn weniger als N<\/strong> Zeilen vorhanden sind, oder die Eingabe abgeschnitten wird.<\/p>\n
Bei dem “l”<\/strong>-Modus haben die Teile ungefähr die Größe der Eingabe dividiert durch N<\/strong>. Die Eingabe wird in N<\/strong> gleich große Teile partitioniert, wobei der letzten Partition jeglicher Überschuss zugewiesen wird. Wenn eine Zeile innerhalb einer Partition anfängt, wird sie vollständig in die entsprechende Datei geschrieben. Da Zeilen oder Datensätze nicht aufgeteilt werden, auch wenn sie eine Partition überlappen, können die geschriebenen Dateien größer oder kleiner als die Partitionsgröße sein, und sogar leer, wenn eine Zeile \/ ein Datensatz so lang ist, dass er die Partition vollständig überlappt.<\/p>\n
Für den “r”<\/strong>-Modus ist die Größe der Eingabe irrelevant, sodass es sich auch um etwa eine Pipe handeln kann.<\/p>\n
–verbose – Meldung pro Ausgabedatei<\/h3>\n
Erzeugt eine Meldung vor dem Öffnen jeder Ausgabedatei:<\/p>\n
split --verbose [Datei [Präfix]]<\/pre>\n
Abonniere JETZT unseren Newsletter!<\/p>\n
Verpasse nie wieder neue<\/strong> Beiträge und exklusive Insider-Only-Inhalte!<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
Der Befehl split wird unter Linux \/ UNIX dazu verwendet, um Dateien beliebig in kleinere Dateien aufzuteilen. Eingesetzt wird der Befehl etwa, wenn die Verarbeitung von Zeilen einer Textdatei in mehrere gleich gro\u00dfe “Bl\u00f6cke” – beispielsweise je 250 Zeilen – aufgeteilt werden soll. Weiterhin kann der Befehl auch bei der Datensicherung oder Verteilung sehr gro\u00dfer […]<\/p>\n","protected":false},"author":2,"featured_media":9494,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","tve_updated_post":"
\t
Der Befehl split wird unter Linux \/ UNIX dazu verwendet, um Dateien beliebig in kleinere Dateien aufzuteilen. Eingesetzt wird der Befehl etwa, wenn die Verarbeitung von Zeilen einer Textdatei in mehrere gleich gro\u00dfe \"Bl\u00f6cke\" - beispielsweise je 250 Zeilen - aufgeteilt werden soll. Weiterhin kann der Befehl auch bei der Datensicherung oder Verteilung sehr gro\u00dfer Dateien verwendet werden. Wenn gew\u00fcnscht, lassen sich die Einzeldateien zu einem sp\u00e4teren Zeitpunkt auch wieder zusammenf\u00fcgen - da es sich nicht um ein propriet\u00e4res Format handelt, ist dies zudem auf beliebigen Plattformen m\u00f6glich.<\/p>
Im Folgenden wird zun\u00e4chst die allgemeine Syntax des Befehls vorgestellt. Im Anschluss folgen einige der wichtigsten Optionen mitsamt Beispielanwendungen zu Veranschaulichung der Funktionsweise.<\/p><\/div>
\n\t
\n\t\tInhaltsverzeichnis<\/span>\n\t\t
Allgemeine Syntax<\/a><\/div><\/div>
Wichtige Optionen<\/a><\/div>
-a - Suffix-L\u00e4nge<\/a><\/div>
--additional-suffix - Zus\u00e4tzlicher Suffix<\/a><\/div>
-b - Bytes pro Ausgabedatei<\/a><\/div>
-C - Bytes Datens\u00e4tze pro Ausgabedatei<\/a><\/div>
--d - numerische Suffixe verwenden<\/a><\/div>
-l - Anzahl Datens\u00e4tze pro Ausgabedatei<\/a><\/div>
-t - Trennzeichen f\u00fcr Datens\u00e4tze<\/a><\/div>
-n - TEILE Ausgabedateien erstellen<\/a><\/div>
--verbose - Meldung pro Ausgabedatei<\/a><\/div><\/div><\/div>\n\t<\/div>\n<\/div>
Allgemeine Syntax<\/h2>
Die allgemeine Syntax des Befehls split <\/strong>lautet folgenderma\u00dfen:<\/p>
[code]split [Optionen] [Datei [Pr\u00e4fix]][\/code]<\/p>
Standardm\u00e4\u00dfig teilt split <\/strong>die \u00fcbergebene Datei in kleinere Dateien mit der Benennung \"[Pr\u00e4fix]aa\"<\/strong>, \"[Pr\u00e4fix]ab\"<\/strong>, \"[Pr\u00e4fix]ac\"<\/strong> etc. auf. Die Buchstaben, die den zweistelligen Suffix ausmachen, werden so verwendet, als handele es sich um ein Stellenwertsystem zur Basis 26. So ist es m\u00f6glich, mit der Standard-Suffix-L\u00e4nge von zwei Buchstaben bis zu 676 Teildateien zu erhalten. Wird kein Pr\u00e4fix spezifiziert, so ist \"x\"<\/strong> der Standartwert. Weiterhin ist standardm\u00e4\u00dfig die Anzahl Zeilen pro Teildatei auf 1000 begrenzt - entsprechend w\u00fcrde eine Datei mit 5000 Zeilen in 5 kleinere Dateien aufgeteilt werden.<\/p>
Wichtige Optionen<\/h2>
In diesem Abschnitt lernen Sie nun einige der wichtigsten Optionen des Befehls split <\/strong>kennen.<\/p>
-a - Suffix-L\u00e4nge<\/h3>
Mit der Option -a<\/strong> k\u00f6nnen Sie die L\u00e4nge des Suffix, welcher standardm\u00e4\u00dfig zweistellig ist, einstellen:<\/p>
[code]split -a [L\u00e4nge] [Datei [Pr\u00e4fix]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Option -a<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel wird die L\u00e4nge des Suffix auf <\/span>\"1\" festgelegt und anschlie\u00dfend eine Datei <\/span>\"befehl-cat.txt\" aufgeteilt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
split -a 1 befehl-cat.txt<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6>
Der Befehl erzeugt entsprechend der L\u00e4nge der Eingabedatei Ausgabedateien mit der folgenden Benennung:<\/p><\/div>
xa<\/p>
xb<\/p>
...<\/p><\/div><\/div>\n<\/div>
--additional-suffix - Zus\u00e4tzlicher Suffix<\/h3>
Die Option --additional-suffix<\/strong> kann verwendet werden, um einen zus\u00e4tzlichen Suffix, wie beispielsweise eine Dateiendung, hinten an den Z\u00e4hl-Suffix anzuh\u00e4ngen:<\/p>
[code]split --additional-suffix [Suffix] [Datei [Pr\u00e4fix]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Option --additional-suffix<\/h5><\/div>
\n\t
\n<\/div>
Hier wird ein zus\u00e4tzlicher Suffix spezifiziert und dann eine Datei <\/span>\"befehl-cat.txt\" aufgeteilt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
split --additional-suffix \".txt\" befehl-sudo.txt<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6>
Der Befehl erzeugt entsprechend der L\u00e4nge der Eingabedatei Ausgabedateien mit der folgenden Benennung:<\/p><\/div>
xaa.txt<\/p>
xab.txt<\/p>
...<\/p><\/div><\/div>\n<\/div>
-b - Bytes pro Ausgabedatei<\/h3>
Mithilfe der Option -b<\/strong> kann die Anzahl Bytes, die pro Ausgabedatei geschrieben wird, festgelegt werden:<\/p>
[code]split -b [Gr\u00f6\u00dfe] [Datei [Pr\u00e4fix]][\/code]<\/p>
Die [Gr\u00f6\u00dfe]<\/strong> stellt dabei einen Integer dar, welcher optional von einem multiplikativen Suffix \"b\"<\/strong> (Bl\u00f6cke), \"KB\"<\/strong> (Kilobytes), \"K\"<\/strong> (Kibibytes), \"MB\"<\/strong> (Megabytes), \"M\"<\/strong> (Mibibytes), \"GB\"<\/strong> (Gigabytes) \"G\"<\/strong> (Gibibytes) etc. gefolgt wird.<\/p>
-C - Bytes Datens\u00e4tze pro Ausgabedatei<\/h3>
Bei Verwendung der Option -C<\/strong> werden so viele vollst\u00e4ndige Datens\u00e4tze wie m\u00f6glich in jede Ausgabedatei geschrieben, ohne dabei [Gr\u00f6\u00dfe]<\/strong> Bytes pro Ausgabedatei zu \u00fcberschreiten. Einzelne Datens\u00e4tze, die l\u00e4nger als die angegebene Gr\u00f6\u00dfe sind, werden in mehrere Dateien aufgeteilt:<\/p>
[code]split -C [Gr\u00f6\u00dfe] [Datei [Pr\u00e4fix]][\/code]<\/p>
[Gr\u00f6\u00dfe]<\/strong> hat dasselbe Format, wie auch bei der Option -b<\/strong>.<\/p>
--d - numerische Suffixe verwenden<\/h3>
Wird die Option -d<\/strong> angegeben, so werden numerische Ziffern<\/strong> anstelle von Buchstaben zur Nummerierung der Ausgabedateien verwendet:<\/p>
[code]split -d [Datei [Pr\u00e4fix]][\/code]<\/p>
Optional kann ein Startwert f\u00fcr das Z\u00e4hlen angegeben werden - hierzu wird dann jedoch die Option  --numeric-suffixes<\/strong> ben\u00f6tigt:<\/p>
[code]split --numeric-suffixes=[Startwert] [Datei [Pr\u00e4fix]][\/code]<\/p>
Der Standard-Startwert ist 0.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Option --numeric-suffixes<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel sollen numerische Suffixe verwendet werden, wobei die Z\u00e4hlung mit der 1 beginnen soll.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
split --numeric-suffixes=1 befehl-sudo.txt<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6>
Die Ausgabedateien werden wie folgt benannt:<\/p><\/div>
x01<\/p>
x02<\/p>
...<\/p><\/div><\/div>\n<\/div>
-l - Anzahl Datens\u00e4tze pro Ausgabedatei<\/h3>
Mit der Option -l<\/strong> kann die Anzahl Datens\u00e4tze spezifiziert werden, die pro Ausgabedatei geschrieben werden sollen:<\/p>
[code]split -l [Anzahl] [Datei [Pr\u00e4fix]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Option -l<\/h5><\/div>
\n\t
\n<\/div>
Die Anzahl Datens\u00e4tze (Zeilen) pro Ausgabedatei soll in diesem Beispiel auf 250 gesetzt, werden. Im Beispiel wird so etwa eine Datei <\/span>\"benutzer.txt\" mit 1000 Benutzernamen in 4 Teildateien aufgeteilt, die dann jeweils 250 Zeilen der Eingabe beinhalten.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
split -l 250 befehl-sudo.txt<\/p><\/div>
Nach Ausf\u00fchrung:<\/h6><\/div>
xaa<\/p>
xab<\/p>
xac<\/p>
xad<\/p><\/div><\/div>\n<\/div>
-t - Trennzeichen f\u00fcr Datens\u00e4tze<\/h3>
Mithilfe der Option -t<\/strong> k\u00f6nnen Sie ein Trennzeichen festlegen, welches anstelle des standardm\u00e4\u00dfigen Zeilenumbruchs (ASCII LF) verwendet werden soll, um Datens\u00e4tze zu trennen:<\/p>
[code]split -t [Trennzeichen] [Datei [Pr\u00e4fix]][\/code]<\/p>
Soll das NUL-Zeichen als Trennzeichen verwendet werden, so wird der Option die Zeichenkette \"\\0\"<\/strong> \u00fcbergeben:<\/p>
[code]split -t '\\0' [Datei [Pr\u00e4fix]][\/code]<\/p>
-n - TEILE Ausgabedateien erstellen<\/h3>
Die Option -n<\/strong> wird verwendet, um die Eingabe in [Teile]<\/strong> Ausgabedateien zu teilen:<\/p>
[code]split -n [Teile] [Datei [Pr\u00e4fix]][\/code]<\/p>
[Teile]<\/strong> hat hierbei eines der folgenden Formate:<\/p><\/div>
Format<\/strong><\/p><\/div><\/th>
Funktion<\/p><\/div><\/th><\/tr><\/thead>
N<\/p><\/div><\/td>
Erzeuge N Ausgabedateien basierend auf der Gr\u00f6\u00dfe der derzeitigen Eingabe<\/p><\/div><\/td><\/tr>
K\/N<\/p><\/div><\/td>
Nur K-te von N in den Standard-Output stdout ausgeben<\/p><\/div><\/td><\/tr>
l\/N<\/p><\/div><\/td>
Erzeuge N Ausgabedateien ohne Zeilen oder Datens\u00e4tze zu teilen<\/p><\/div><\/td><\/tr>
l\/K\/N<\/p><\/div><\/td>
Wie \"l\/N\", aber nur K-te von N in den Standard-Output stdout ausgeben<\/p><\/div><\/td><\/tr>
\t
r\/N<\/p><\/div><\/td>
\t
Wie \"r\\N\" aber Round-Robin-Verfahren verwenden<\/p><\/div><\/td><\/tr>
\t
r\/K\/N<\/p><\/div><\/td>
\t
Wie \"r\/N\", aber nur K-te von N in den Standard-Output stdout ausgeben<\/p><\/div><\/td><\/tr><\/tbody><\/table><\/div>
Jegliche \u00fcbrige Bytes nach Teilen der Eingabe in N<\/strong> Teile werden dem letzten Teil angef\u00fcgt. Weiterhin werden \u00fcbrige Bytes, die nach der initialen Berechnung auftauchen, ignoriert - au\u00dfer es wird der \"r\"<\/strong>-Modus verwendet.<\/p>
Alle N<\/strong> Ausgabedateien werden erzeugt, auch wenn weniger als N<\/strong> Zeilen vorhanden sind, oder die Eingabe abgeschnitten wird.<\/p>
Bei dem \"l\"<\/strong>-Modus haben die Teile ungef\u00e4hr die Gr\u00f6\u00dfe der Eingabe dividiert durch N<\/strong>. Die Eingabe wird in N<\/strong> gleich gro\u00dfe Teile partitioniert, wobei der letzten Partition jeglicher \u00dcberschuss zugewiesen wird. Wenn eine Zeile innerhalb einer Partition anf\u00e4ngt, wird sie vollst\u00e4ndig in die entsprechende Datei geschrieben. Da Zeilen oder Datens\u00e4tze nicht aufgeteilt werden, auch wenn sie eine Partition \u00fcberlappen, k\u00f6nnen die geschriebenen Dateien gr\u00f6\u00dfer oder kleiner als die Partitionsgr\u00f6\u00dfe sein, und sogar leer, wenn eine Zeile \/ ein Datensatz so lang ist, dass er die Partition vollst\u00e4ndig \u00fcberlappt.<\/p>
F\u00fcr den \"r\"<\/strong>-Modus ist die Gr\u00f6\u00dfe der Eingabe irrelevant, sodass es sich auch um etwa eine Pipe handeln kann.<\/p>
--verbose - Meldung pro Ausgabedatei<\/h3>
Erzeugt eine Meldung vor dem \u00d6ffnen jeder Ausgabedatei:<\/p>
[code]split --verbose [Datei [Pr\u00e4fix]][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Abonniere JETZT unseren Newsletter!<\/p><\/div>
\n\t
\n<\/div>
Verpasse nie wieder neue<\/strong> Beitr\u00e4ge und exklusive Insider-Only-Inhalte!<\/strong><\/p><\/div>
\n\t
<\/div>
<\/div>