Tutorial zur FOR-Schleife

Da hier im Forum immer wieder mal die Frage nach einem Tutorial für die FOR-Schleife in Batch-Skript auftaucht und die Suche bei Google auch keine wirklich befriedigenden Ergebnisse liefert, habe ich mich nun entschlossen, selbst ein solches Tutorial zu schreiben. Ich werde mich bemühen, auf alle Details dieses komplexen Befehls einzugehen. Da ich jedoch kein geübter Verfasser solcher Tutorials bin, sind konstruktive Kritik und Verbesserungsvorschläge willkommen.

Dieses Tutorial richtet sich vor allem an interessierte Neulinge in Sachen Batchprogrammierung, denen die Hilfe zum FOR-Befehl nur ungenügende Informationen liefert. Gerade die Variante FOR /F bietet viele Möglichkeiten, die jedoch sehr knapp bzw. verwirrend beschrieben werden. Wichtige Details fehlen ganz.

Bei den Erklärungen der einzelnen Varianten des FOR-Befehls werden, wie allgemein üblich, optionale Teile in eckigen Klammern eingeschlossen dargestellt.

Allgemeines zur FOR-Schleife

Die FOR-Schleife gibt es in mehreren Varianten.

• Die Urform und ihre Weiterentwicklungen

• Variante zur Erzeugung von Zahlenfolgen, funktioniert wie eine FOR-Schleife in normalen Programmiersprachen

• Mehrzweck-Variante

Bei allen Varianten wird eine Laufvariable benutzt, die entgegen der üblichen Regel für CMD-Umgebungsvariablen nur mit einem vorangestellten Prozentzeichen gekennzeichnet wird. Wird die FOR-Schleife in Batchfiles verwendet, muss dieses Prozentzeichen verdoppelt werden.

Als Variablennamen dürfen nur einzelne Zeichen verwendet werden. Zwar sind sehr viele der druckbaren ASCII-Zeichen als Variablennamen erlaubt, man sollte sich aber auf die Verwendung von Buchstaben (A-Z oder a-z) beschränken.

Bei den Variablennamen wird zwischen Groß- und Kleinschreibung unterschieden. Die Variable %I ist also etwas anderes als %i.

Möchte man mehr als einen Befehl in der FOR-Schleife ausführen lassen, kann man wie üblich die Befehle mit dem Operator & verketten oder (in Batchfiles) die Befehlszeile durch die Verwendung von Klammern auf mehrere Zeilen "verlängern":
Da diese Notation in Batchfiles verwendet wird, hier auch die Kennzeichnung der Laufvariablen durch zwei Prozentzeichen. Aber Achtung: Eine solche Konstruktion wird vom Befehlszeileninterpreter als eine Zeile betrachtet! Was bedeutet das für den Programmierer? Befehle, die mit Variablen arbeiten, die in dem geklammerten Block verändert werden, funktionieren nicht wie gewünscht. Das liegt an der Art und Weise, wie der Befehlsinterpreter Befehlszeilen auswertet, übersetzt und ausführt. Stichwort: Erweiterung von Variablen. Damit ist das Ersetzen einer Variable in einem Ausdruck durch ihren Wert gemeint.

Exkurs (verzögerte) Variablenerweiterung

Das Problem mit der Variablenerweiterung tritt auch bei anderen Ausdrücken auf, in denen eine Befehlszeile durch die Verwendung von Klammern verlängert wurde, also z.B. auch beim IF-Befehl. Hier ein Beispiel:
Durch Zeile 6 wird der Text "Geben Sie den Benutzernamen ein: " angezeigt und dann auf eine Eingabe gewartet, die mit ENTER abgeschlossen werden muss. Wenn z.B. "Paul" eingegeben wurde (und nicht nur ENTER gedrückt wurde), würde man erwarten, dass der Inhalt des Verzeichnisses C:\Users\Paul angezeigt wird. Stattdessen erscheint aber der Inhalt des Verzeichnisses, das bei Start des obigen Batchfiles das aktuelle Verzeichnis war.

Warum ist das so? Die Zeilen 8 bis 11 werden vom Befehlsinterpreter als eine Zeile betrachtet. Bevor die Befehle ausgeführt werden, werden alle Variablen durch ihren aktuellen Wert ersetzt (erweitert). Da op_dir zu diesem Zeitpunkt nicht definiert ist, wird Zeile 8 als
übersetzt, was einem einfachen DIR entspricht.

Um zum gewünschten Ergebnis zu kommen, muss die verzögerte Variablenerweiterung aktiviert und benutzt werden. Das Beispiel muss dann so lauten:
In Zeile 1 wird durch ENABLEDELAYEDEXPANSION die verzögerte Variablenerweiterung aktiviert. Dadurch, dass in Zeile 10 der Variablenname op_dir in Ausrufezeichen statt in Prozentzeichen eingeschlossen ist, wird dem Befehlsinterpreter mitgeteilt, diesen Variablennamen erst bei Ausführung des DIR-Befehls durch seinen Wert zu ersetzen, der durch den vorhergehenden SET-Befehl gesetzt wurde.

Werte von Parametern der FOR-Schleife durch Variablen angeben

Beim Verschachteln von FOR-Schleifen ist folgendes zu beachten:

Die Variante FOR /R hat einen Parameter Basisverzeichnis und die Variante FOR /F hat die Parameter SKIP=x, TOKENS=x, DELIMS=x und EOL=x. Die Werte all diese Parameter können nicht durch eine Laufvariable einer umgebenden FOR-Schleife oder durch eine verzögert erweiterte Variable (in Ausrufezeichen eingeschlossen) angegeben werden. Lediglich die Angabe als normale Umgebungsvariable (in Prozentzeichen eingeschlossen) ist möglich. Verschachtelte FOR-Schleifen werden, wie schon erwähnt, vom Kommandozeileninterpreter als eine Zeile aufgefasst. Wenn solch eine Zeile übersetzt wird, muss der Wert der Variablen, die als Wert einer der o.g. Parameter angegeben ist, schon feststehen und kann sich während der Abarbeitung der Schleifen auch nicht mehr ändern. Diese Voraussetzungen werden nur von normalen Umgebungsvariablen erfüllt.

Die Urform der FOR-Schleife

Den FOR-Befehl gab es schon zu DOS-Zeiten, allerdings nur in dieser Form:
Damit lassen sich Zeichenketten und Dateinamensmasken verarbeiten. Satz steht für eine durch Leerzeichen getrennte Folge von Zeichenketten. Enthält eine Zeichenkette selbst Leerzeichen, muss sie in Anführungszeichen eingeschlossen werden. Bei Ausführung der FOR-Schleife wird bei jedem Durchlauf eine der Zeichenketten (angefangen bei der ersten von links) an die Laufvariable zugewiesen. Ist eine Zeichenkette in Anführungszeichen eingeschlossen, werden diese auch an die Laufvariable zugewiesen. Enthält eine Zeichenkette Wildcardzeichen (? oder *), wird sie als Maske für Dateinamen aufgefasst und im angegebenen Verzeichnis oder, ohne Verzeichnisangabe, im aktuellen Verzeichnis nach Dateien gesucht, auf deren Name diese Maske passt. Danach wird pro Schleifendurchlauf in alphabetischer Reihenfolge einer dieser Dateinamen an die Laufvariable zugewiesen.

Beispiel 1 (für die Kommandozeile):
Wenn sich im aktuellen Verzeichnis die Dateien Test.txt und MeinText.txt befinden und im Verzeichnis E:\My Scripts die Dateien Backup.bat und RDir.bat, ist die Ausgabe folgende:
Wurde in Satz zusammen mit einer Dateimaske ein Pfad angegeben, wird er bei der Ausgabe auch angezeigt. Das ist auch der Vorteil gegenüber dem Befehl
Die Anführungszeichen um Dateimasken werden nicht ausgegeben. Zeichenketten und Dateimasken lassen sich gemischt angeben.

Beispiel 2:
Hier wird die FOR-Schleife benutzt, um zu prüfen, ob die Variable %Action% einen der zur Eingabe zugelassenen Buchstaben enthält. Durch den Parameter /i beim IF-Befehl sind auch die entsprechenden Kleinbuchstaben zugelassen. Je nach Inhalt von %Action% wird entweder eines der entsprechenden Labels angesprungen oder bei einer unzulässigen Eingabe die Abfrage wiederholt (GOTO :SelectAction). Die GOTO :EOF Befehle springen jeweils zum Programmende (EOF=End Of File), beenden also das Skript.

Der Parameter /D

Bei Angabe des Parameters /D wird bei einer Zeichenkette mit Wildcards nur nach Verzeichnissen gesucht, auf deren Name die angegebene Maske passt. Wird die Maske inkl. Pfad angegeben, wird den Namen der gefundenen Verzeichnisse der Pfad vorangestellt und der Laufvariablen zugewiesen.

Beispiel 3 (für die Kommandozeile):
Wenn sich im Verzeichnis E:\ die Verzeichnisse My Scripts und My Docs befinden, ist die Ausgabe folgende:

Der Parameter /R

Bei Angabe des Parameters /R wird die FOR-Schleife ausgehend vom Verzeichnis [Laufwerk:]Pfad rekursiv für jedes darunter liegende Verzeichnis ausgeführt. Wenn kein Basis-Verzeichnis angegeben wird, wird das aktuelle Verzeichnis verwendet. Für [Laufwerk:]Pfad kann keine Laufvariable einer anderen FOR-Schleife oder eine verzögert erweiterte Variable (in Anführungszeichen eingeschlossen) angegeben werden! Satz ist eine Folge von Zeichenketten, die, wenn sie Wildcards (* oder ?) enthalten, als Maske für Dateinamen interpretiert werden. Alle gefundenen Dateien aus den durchsuchten Verzeichnissen werden inkl. Pfad nacheinander an die Laufvariable zugewiesen. Enthält Satz zusätzlich eine Zeichenkette ohne Wildcards, werden die Pfade aller durchsuchten Verzeichnisse, ergänzt um \Zeichenkette, an die Laufvariable zugewiesen. Ist die Zeichenkette in Anführungszeichen eingeschlossen, wird \"Zeichenkette" ergänzt.

Beispiel 4 (für die Kommandozeile):
Wenn sich im Verzeichnis E:\Archiv die Dateien Test1.txt und Test2.txt und das Verzeichnis Audio mit den Dateien Test1.mp3, Test2.mp3, Track01.mp3 und Track02.mp3, befinden, ist die Ausgabe folgende:

Enthält Satz lediglich einen Punkt, erhält man unter Verwendung der Erweiterung von Laufvariablen einen Ersatz für
der auch das Basisverzeichnis liefert. Unter DOS/Windows gibt es nämlich in jedem Verzeichnis zwei Standard-Einträge, die immer vorhanden sind: . und .. Der Punkt (.) stellt einen Verweis auf das Verzeichnis selbst dar. Der zweifache Punkt (..) ist ein Verweis auf das Elternverzeichnis.

Beispiel 5 (für die Kommandozeile):
Auf die eben beschriebene Verzeichnisstruktur angewendet, liefert der Befehl
die folgende Ausgabe:

Die Parameter /D und /R können auch kombiniert werden.

Beispiel 6 (für die Kommandozeile):
Wenn auf die schon bekannte Verzeichnisstruktur der Befehl
angewendet wird, ist die Ausgabe folgende:
Das Ergebnis ist also gleichwertig zu

Die Variante zur Erzeugung von Zahlenfolgen, FOR /L

Um mit John Cleese zu sprechen: Kommen wir nun zu etwas völlig anderem. Denn diese Variante der FOR-Schleife verhält sich genauso wie in "richtigen" Programmiersprachen. Die Laufvariable ist eine numerische Größe, die beim Start der Schleife mit dem Wert von Start initialisiert und nach jedem Durchlauf um den Wert von Schritt erhöht wird (negative Schrittweiten sind auch möglich). Die Schleife wird nach dem Durchlauf beendet, in dem die Laufvariable den Wert von Ende erreicht hat.

Beispiel 7:
Das folgende Batchfile, auf die schon bekannte Verzeichnisstruktur E:\Archiv\Audio angewendet,
liefert folgende Ausgabe:
Hier wird die verzögerte Variablenerweiterung benutzt, da sich der Inhalt der Variablen %cntr% in der ersten FOR-Schleife bei jedem Durchlauf um 1 erhöhen soll. Je nach Anzahl der gefundenen Dateien werden die Variablen file1 bis fileN erzeugt, die in der zweiten FOR-Schleife mit SET ausgegeben werden.

Die Mehrzweck-Variante, FOR /F

So, kommen wir jetzt zu der Variante, wegen der sicherlich die meisten überhaupt ein Tutorial für die FOR-Schleife benötigen, denn FOR /F ist eine Eierlegende Wollmilchsau. Und wie das so ist mit Werkzeugen, die man für viele Zwecke einsetzen kann, sind sie nicht mal eben so mit links zu benutzen. Hinzu kommt, dass die Auswertung von Ausdruck etwas buggy ist und die Hilfe von FOR zu dieser Variante mehr Verwirrung stiftet als hilfreich zu sein und einige Details verschweigt.

Allgemeines zu FOR /F

FOR /F hat drei Untervarianten. Welche verwendet wird, hängt vom Aufbau von Ausdruck und dem Vorhandensein der Option USEBACKQ ab. Man kann

• eine Zeichenkette verarbeiten.
• den Inhalt von mehreren explizit angegebenen Dateien (keine Verwendung von Wildcards) zeilenweise verarbeiten.
• die Ausgabe eines Programms/Befehls zeilenweise verarbeiten.

Trennzeichen (Option DELIMS=)

Allen drei Untervarianten ist gemeinsam, dass sie die zu verarbeitenden Zeichenketten/(Datei-)Zeilen in sog. Tokens zerlegen. Ein Token ist ein Teilabschnitt des Gesamtstrings. Wo ein Token beginnt und endet wird durch Trennzeichen (Delimiter) bestimmt. Die Standard-Trennzeichen sind Leerzeichen und Tabzeichen. Man kann aber auch über die Option DELIMS= eigene Trennzeichen definieren oder die Verwendung von Trennzeichen komplett abschalten. Das Anführungszeichen " als Trennzeichen zu definieren ist nicht möglich. Gerüchteweise soll es unter fluchen möglich sein (Hallo @Biber!). Wer weiss, wie's geht, möge das bitte posten. [EDIT] @pieh-ejdsch hat inzwischen hier veröffentlicht, wie es geht. [/EDIT]

Zeilenendezeichen (Option EOL=)

Der Zeilenumbruch zählt natürlich auch als Trennzeichen zwischen Tokens und markiert das Zeilenende. Man kann aber über die Option EOL= auch ein eigenes Zeilenendezeichen definieren (EOL=End Of Line). Alle Zeichenketten/(Datei-)Zeilen, die mit dem so definierten Zeichen beginnen, werden komplett ignoriert. Wenn man ein Skript schreiben will, das Konfigurationsdateien auswertet, kann man über EOL=: z.B. den Doppelpunkt als Kommentarzeichen definieren. Zeilen, die damit beginnen, werden dann nicht ausgewertet. Standardmäßig ist das Semikolon (;) das EOL-Zeichen. [EDIT] @jeb-the-batcher stellt in diesem Kommentar noch einen Trick in Zusammenhang mit EOL= zur Verfügung. [/EDIT]

Zeilen überspringen (Option SKIP=)

Mit der Option SKIP= kann eine Anzahl Zeilen angegeben werden, die vom Anfang einer Datei/Befehlsausgabe übersprungen werden sollen. Diese Zeilen werden nicht verarbeitet. Die Angabe von SKIP=0 ist nicht möglich.

Tokens (Option TOKENS=)

Die durch die Zerlegung entstehenden Tokens werden der Laufvariablen zugewiesen. Standardmäßig wird immer nur das erste erhaltene Token zugewiesen. Dieses Verhalten kann jedoch über die Option TOKENS= verändert werden. Die Option erwartet eine durch Komma getrennte Aufzählung der zu verwendenden Token-Nummern, z.B. TOKENS=1,3,4,5. Die Angabe von Bereichen ist auch möglich, z.B. TOKENS=1,3-5. Die Angabe von TOKENS=0 ist nicht möglich. Die höchst mögliche Tokennummer ist 31.

Wenn auf diese Art festgelegt wurde, dass mehrere Tokens (Teilabschnitte) einer Zeichenkette/(Datei-)Zeile verarbeitet werden sollen, entsteht automatisch für jedes Token eine zusätzliche Laufvariable. Deren Namen hängen vom Namen der vom Programmierer festgelegten Laufvariablen ab, sie werden in aufsteigender Reihenfolge nach den im Alphabet folgenden Buchstaben benannt. Zur Verdeutlichung ein Beispiel:

Beispiel 8 (für die Kommandozeile):
Das ist die Untervariante zur Verarbeitung der Ausgabe von Programmen/Befehlen. Zunächst wird der DIR-Befehl in der Klammer ausgeführt, der durch die Option /a:-d keine Unterverzeichnisse listet. So ein Verzeichnislisting sieht z.B. so aus:
Die ersten 5 Zeilen dieser Ausgabe interessieren uns nicht, deshalb SKIP=5.

In den nun folgenden 3 Zeilen mit den Dateien ist das erste Token das Erstellungsdatum, denn nach dem Datum folgen Leerzeichen, die zu den Standardtrennzeichen gehören. Da in der Befehlszeile TOKENS=1,4 steht, wird der Laufvariablen %f (von mir festgelegt) das Dateidatum zugewiesen.

Das zweite Token ist die Uhrzeit der Dateierstellung, das dritte Token die Dateigröße. Diese beiden Tokens werden ignoriert.

Das vierte Token ist der Dateiname mit Erweiterung. Da dieses Token laut Befehlszeile verarbeitet werden soll, wird automatisch eine weitere Laufvariable %g (g folgt im Alphabet auf f) erzeugt und bekommt den Dateinamen zugewiesen.

Außer bei der Datei mit dem Namen "Mein Text.txt". Dieser Name enthält ein Leerzeichen, also ein Trennzeichen. Deshalb enthält %g nur "Mein". Wie kommt man an den Rest des Dateinamens? Der Code muss folgendermaßen geändert werden:

Beispiel 9 (für die Kommandozeile):
Endet die Liste der zu verwendenden Tokens mit einem Stern (*), wird automatisch eine weitere Laufvariable erzeugt, die alle Tokens inkl. Trennzeichen nach dem zuletzt genannten Token (hier dem 4.) enthält. Token 1 steht in %f (von mir festgelegt), Token 4 steht in %g (automatisch erzeugt). Der Rest der Ausgabezeile steht also in %h (auch automatisch erzeugt). Wenn %h nichts enthält, enthält der Dateiname kein Leerzeichen und es genügt, echo %g vom %f auszuführen. Wenn %h jedoch einen Inhalt hat, muss echo %g %h vom %f ausgeführt werden; zwischen %g und %h muss das als Trennzeichen "verschluckte" Leerzeichen von Hand wieder eingefügt werden.

Sinnvoll ist die Ausgabe des Beispielcodes aber dennoch nicht:
Die letzten beiden Zeilen sind Unsinn. Hier tritt eine Schwäche von FOR /F zu Tage: Es gibt zwar die Möglichkeit (mit SKIP=) eine bestimmte Anzahl Zeilen vom Anfang der zu verarbeitenden Datei/Befehlsausgabe zu überspringen, aber keine Möglichkeit, eine bestimmte Anzahl Zeilen am Ende zu ignorieren oder nur eine bestimmte Anzahl Zeilen zu verarbeiten. Für das in diesem Beispiel behandelte Problem existiert aber trotzdem eine Lösung, die ich im Abschnitt Erweiterung von Laufvariablen vorstellen werde.

Wenn man tatsächlich einmal in die Lage kommt, 31 Tokens verarbeiten zu müssen, stellt sich die Frage nach dem Namensraum der dann nötigen Laufvariablen. Meine Versuche haben ergeben, dass man in diesem Fall der selbst benannten Laufvariablen am besten den Namen %? gibt. Es entstehen dann die automatischen Laufvariablen %@, %A, ..., %Z, %[, %\ und %]. Das ergibt einen zusammenhängenden Namensraum von 31 Variablen, die sich ohne Probleme benutzen lassen. Problemkinder im 7Bit-ASCII-Codebereich sind z.B. %,<,> und ^. Ausserdem ist es ungeschickt, die Ziffern 0 bis 9 in den Namensraum aufzunehmen, da man dann die Möglichkeit verliert, auf die Variablen %0 ... %9, die die Parameter des Batchfiles/des Unterprogramms repräsentieren, Bezug zu nehmen. Im erweiterten 8Bit-ASCII-Codebereich jenseits von Zeichen 127 gibt es auch immer wieder einzelne Zeichen oder kleine Blöcke von Zeichen, die sich nicht als Variablennamen verwenden lassen.

Die Auswertung von Ausdruck beeinflussen (Option USEBACKQ)

Die Option USEBACKQ kann nur im Kontext der verschiedenen Untervarianten von FOR /F erklärt werden. Ich verweise deshalb auf die entsprechenden Abschnitte.

Verarbeiten einer Zeichenkette

Die Syntax zum Verarbeiten einer Zeichenkette ist:
oder bei Verwendung der Option USEBACKQ
Die Zeichenkette wird als eine Zeile einer Datei aufgefasst und entsprechend der Optionen DELIMS=, TOKENS= und EOL= zerlegt. Die Zeichenkette kann bei der Version ohne die Option USEBACKQ auch selbst Anführungszeichen enthalten, bei der Version mit USEBACKQ sollten jedoch keine Apostrophe in der Zeichenkette enthalten sein. Bei meinen Tests kam es in diesem Fall bei direkter Eingabe des Befehls an der Kommandozeile nach einem Verzeichniswechsel zu Fehlfunktionen von CMD.EXE. Die umgebenden Anführungszeichen werden nicht an die Laufvariable(n) zugewiesen. Bei Angabe von mehreren Zeichenketten kommt es auch zu Fehlfunktionen von CMD.EXE.

Beispiel 10:
In Batch-Skript kann mit dem Befehl SET /A gerechnet werden. Zahlen, die führende Nullen enthalten, werden dabei als Zahlen im Oktalsystem (zur Basis 8) interpretiert. Das führt beim Verrechnen von 08, 09, 018, 019 usw. zu Fehlermeldungen (diese Zahlen gibt es im Oktalsystem nicht), bei anderen Zahlen zu falschen Ergebnissen. Deshalb hier ein Schnipsel, der diese führenden Nullen abschneidet.
Als Trennzeichen wird durch DELIMS=0 die Ziffer 0 vereinbart. Durch TOKENS=* enthält die Laufvariable alle Tokens inkl. der vereinbarten Trennzeichen. Das erste Token beginnt aber erst dann, wenn ein vom Trennzeichen verschiedenes Zeichen auftritt, also bei der ersten von 0 verschiedenen Ziffer. Deshalb werden die führenden Nullen abgeschnitten, später auftretende Nullen bleiben erhalten. Zeile 10 dient nur dazu, die Variable %Number% auf 0 zu setzen, wenn 0 oder z.B. 0000 eingegeben oder einfach nur ENTER gedrückt wurde.

Ein Manko hat der Code: Man muss Zahlen eingeben, die Eingabe von Buchstaben wird nicht verhindert (Hallo Timo!). Im Abschnitt Praxistipps habe ich einen Schnipsel notiert, der das abfängt. Ihn hier zu verwenden wäre verfrüht, ich würde im Tutorial vorgreifen.

Beispiel 11:
Mit FOR /F und Zeichenketten lassen sich Arrays simulieren. Die Option TOKENS= kann dazu benutzt werden, um den Index des Elements im Array anzugeben, auf das zugegriffen werden soll. Im nachfolgenden Beispiel wird das Standard-Trennzeichen SPACE (Leerzeichen) verwendet, um die "Arrayelemente" zu separieren. Sollen die Arrayelemente selbst Leerzeichen enthalten, kann mit DELIMS=, z.B. das Komma als Trennzeichen vereinbart werden.
In Zeile 13 wird die erste Hex-Ziffer von links (ab dem Offset 0, 1 Zeichen) der Variablen %DIGIT% zugewiesen. In Zeile 14 wird diese Ziffer von der Variablen %HexNum% abgeschnitten (%HexNum% ist gleich Inhalt von %HexNum% ab dem Offset 1 bis zum Ende). Wenn %HexNum% leer ist, wird die Hauptschleife in Zeile 33 beendet.

Die Zeilen 18 bis 28 suchen im Array %HexDigits% nach der aktuell betrachteten Hex-Ziffer %Digit%. Wird sie gefunden, wird am gleichen Index in %ConvArray% das dezimale Äquivalent ausgelesen und die Schleife abgebrochen. Wenn die Schleife bis zum Ende (%Index% gleich 17) durchläuft, bedeutet das, dass ein Zeichen eingegeben wurde, was keine Hex-Ziffer darstellt und das Skript wird mit einer Fehlermeldung abgebrochen.

Man könnte einwenden, die Zeilen 18 bis 28 könnte man doch als FOR /L Schleife programmieren, also den Index damit erzeugen lassen. Hier kommt aber eine Einschränkung von FOR /F zum tragen: Die Werte bei TOKENS=, SKIP=, EOL= und DELIMS= dürfen keine Laufvariable einer anderen FOR-Schleife oder eine verzögert erweiterte Variable (in Ausrufezeichen eingeschlossen) enthalten. Der Grund dafür dürfte in der Art und Weise liegen, wie der Befehlszeileninterpreter eine solche Zeile auswertet und übersetzt.

Übrigens: Der einfachste Hex=>Dec Konverter in Batchskript ist natürlich

Verarbeiten des Inhalts von Dateien

Die Syntax zum Verarbeiten des Inhalts von Dateien ist:
oder bei Verwendung der Option USEBACKQ
Die Angabe von mehreren Dateien ist möglich. Die Dateien werden zeilenweise ausgelesen. Jede einzelne Zeile wird entsprechend den Optionen DELIMS=, TOKENS=, EOL= und SKIP= verarbeitet. Die bei der Zerlegung der einzelnen Dateizeilen entstehenden Tokens werden der/den Laufvariablen zugewiesen. Leere Zeilen werden nicht an die Laufvariable(n) zugewiesen. Wie das dennoch geht zeigt Beispiel 7a im Abschnitt Praxistipps.

Bei der Version mit USEBACKQ kann der Dateiname oder -pfad Leerzeichen enthalten, ohne USEBACKQ ist das nicht möglich. Gerade wenn man mit Dateinamen arbeitet, die während des Skriptlaufs dynamisch erzeugt werden, ist es deshalb fast schon Pflicht mit der USEBACKQ-Version zu arbeiten.

Beispiel 12:
Die erste FOR-Schleife in Zeile 11 löscht die Variablen, deren Namen in der Variablen %Vars% angegeben sind.

Die FOR /F Schleife in Zeile 13 liest die Datei, deren Name in der Variablen %ConfigFile% gespeichert ist, ein. Als Trennzeichen zwischen den Tokens wird das Gleichheitszeichen definiert. Die Laufvariable %%v enthält deshalb den Namen der Variablen, die durch TOKENS=1,2 automatisch definierte Laufvariable %%w enthält alles, was rechts vom Gleichheitszeichen in der Konfigurationsdatei steht. Durch das standardmäßig als Zeilenendezeichen definierte Semikolon können Kommentarzeilen in die Konfigurationsdatei geschrieben werden, die mit einem Semikolon beginnen.

Die dritte FOR-Schleife in Zeile 15-20 prüft, ob alle Variablen, deren Namen in der Variablen %Vars% angegeben sind, definiert sind. Wenn eine nicht definierte Variable gefunden wird, wird das Unterprogramm MissingVar mit dem Namen der nicht definierten Variablen als Parameter aufgerufen und eine Fehlermeldung ausgegeben. Außerdem wird die Variable %VarMissed% auf den Wert 1 gesetzt.

Wenn in Zeile 22 festgestellt wird, dass %VarMissed% den Wert 1 hat, wird das Skript abgebrochen.

Wenn die Datei Backup.conf folgenden Aufbau hat,
sind nach Ausführung von Zeile 13 in obigem Skript die Variablen Source, Destination, ExcludeFiles und ExcludeDirs mit den angegebenen Werten belegt.

Verarbeiten der Ausgabe eines Programms/Befehls

Die Syntax zum Verarbeiten der Ausgabe eines Programms/Befehls ist:
oder bei Verwendung der Option USEBACKQ
Im Unterschied zur Version ohne USEBACKQ wird der auszuführende Befehl bei der Version mit USEBACKQ in Gravis-Zeichen (SHIFT+Taste neben BACKSPACE, danach SPACE (Leerzeichen) drücken) eingeschlossen.

Befehl1 wird in einer separaten, versteckten Instanz von CMD.EXE ausgeführt. Die Ausgabe erscheint nicht auf dem Bildschirm, sondern wird zeilenweise unter Beachtung der Optionen DELIMS=, TOKENS=, EOL= und SKIP= verarbeitet. Die bei der Zerlegung der einzelnen Ausgabezeilen entstehenden Tokens werden der/den Laufvariablen zugewiesen. Leere Ausgabezeilen werden nicht an die Laufvariable(n) zugewiesen. Wie das dennoch geht zeigt Beispiel 7b im Abschnitt Praxistipps.

Wenn Befehl1 ein Programm ist, dessen Pfad Leerzeichen enthält, muss Befehl1 in Anführungszeichen eingeschlossen werden. Falls Befehl1 zusätzlich einen Parameter benötigt, der Leerzeichen enthält und deshalb ebenfalls in Anführungszeichen eingeschlossen werden muss (z.B. einen Dateipfad), funktioniert FOR /F nur unter Verwendung folgender Syntax:
oder bei Verwendung der Option USEBACKQ

Escapen von Steuerzeichen

Wenn Befehl1 bestimmte Zeichen/Zeichenkombinationen enthält, müssen diese unter Verwendung des Zeichens ^ "escaped" werden, d.h. das Escapezeichen ^ muss ihnen vorangestellt werden um zu verdeutlichen, dass das nachfolgende Zeichen nicht als Steuerzeichen interpretiert, sondern genau so an die Befehl1 ausführende Instanz von CMD.EXE übergeben werden soll. Die folgende Tabelle gibt einen Überblick.

[Edit] Neue Erkenntnisse zum Thema hat @pieh-ejdsch in diesem Posting veröffentlicht. [/Edit]

Zeichen	Bedeutung	"escapen" mit
>	Ausgabeumleitung (in Datei)	^>
<	Eingabeumleitung (aus Datei)	^<
2>&1	Standardfehlerkanal (Kanal 2) dorthin umleiten, wohin auch die Standardausgabe (Kanal 1 ) umgeleitet ist	2^>^&1
|	Ausgabeumleitung eines Befehls in eine Pipe	^|
&	Befehlsverkettung	^&
&&	Bedingte Befehlsverkettung Bei Erfolg des vorhergehenden Befehls	^&^&
| |	Bedingte Befehlsverkettung Bei Misserfolg des vorhergehenden Befehls	^|^|
(	öffnende Klammer	^(
)	schließende Klammer	^)
=	Zuweisungen	^=
,	Komma	^,
^	das Escapezeichen selbst	^^

Beispiel 13:
In Zeile 5 wird der Benutzer zur Eingabe einer Zeichenkette aufgefordert, die der Variablen %Str% zugewiesen wird. In Zeile 9 wird diese Zeichenkette zusammen mit Steuerzeichen in die Datei strlen.txt ins Verzeichnis für temporäre Dateien %TEMP% (vordefinierte Umgebungsvariable) geschrieben. Da das Zeichen < zum Sprachumfang von Batchskript gehört (Steuerzeichen für Eingabeumleitung), muss es mit dem Zeichen ^ "escaped" werden. Der Inhalt von strlen.txt sieht nach Eingabe von z.B. Ein String folgendermaßen aus:
Der FINDSTR-Befehl in der Klammer der FOR-Schleife in Zeile 10 durchsucht die Datei strlen.txt wegen dem Parameter /b nach Zeilen, die mit < beginnen und gibt diese aus. Vor dem Zeileninhalt wird wegen dem Parameter /o der Offset des ersten Zeichens der Zeile relativ zum Dateianfang, gefolgt von einem Doppelpunkt, ausgegeben. Die Ausgabe sieht für das Beispiel also so aus:
Diese Ausgabe wird ja bekanntlich nicht angezeigt, sondern durch die FOR-Schleife verarbeitet. Als Trennzeichen zwischen Tokens ist durch DELIMS=: der Doppelpunkt definiert. Weil die Angabe Tokens=X fehlt, wird nur das erste Token jeder Zeile verarbeitet. Da strlen.txt zwei Zeilen enthält, wird die FOR-Schleife zweimal durchlaufen. Beim zweiten Durchlauf hat die Laufvariable %%l also den Wert 13. Dieser Wert kommt folgendermaßen zustande: Das Zeichen <, nach dem FINDSTR sucht, am Anfang der ersten Zeile von strlen.txt hat den Offset 0. Deshalb gibt FINDSTR in seiner Ausgabe 0: vor der ersten Zeile aus. Das Zeichen g des Wortes String hat den Offset 10. Danach kommen in der Datei noch die zwei Zeichen <CARRIAGE RETURN> (Wagenrücklauf, ASCII-Code 13) und <LINEFEED> (Zeilenvorschub, ASCII-Code 10). Diese werden von FINDSTR mitgezählt. Deshalb hat das erste Zeichen < der zweiten Zeile von strlen.txt den Offset 13 relativ zum Dateianfang. Von diesem Offset muss man den Wagenrücklauf, den Zeilenvorschub und das Zeichen < in der ersten Zeile von strlen.txt (also 3) subtrahieren und erhält somit die Länge der Zeichenkette in Zeile 1 von strlen.txt.

Übrigens: Der Suchstring des FINDSTR-Befehls, das Zeichen <, muss nicht "escaped" werden, da er von Anführungszeichen eingeschlossen ist.

Erweiterung von Laufvariablen

Der Inhalt von Laufvariablen der FOR-Schleife kann durch hinzufügen bestimmter Kürzel zum Variablennamen verändert dargestellt werden. Fast alle Funktionen beziehen sich auf den Fall, dass die Laufvariable einen Dateinamen/-pfad enthält. In der folgenden Tabelle wird angenommen, dass die Laufvariable %I ist. Die gleichen Möglichkeiten zur Manipulation hat man auch bei den Variablen %0, %1, ... , %9, die die einem Batchfile/Unterprogramm übergebenen Parameter repräsentieren. Die Beschreibung habe ich weitgehend aus der FOR-Hilfe übernommen.

%~I	Erweitert %I und entfernt alle umschließenden Anführungszeichen (").
%~fI	Erweitert %I zu einem vollständigen Dateinamen inkl. Laufwerksbuchstaben und Pfad.
%~dI	Erzeugt nur den Laufwerksbuchstaben von %I.
%~pI	Erzeugt nur den Pfad von %I ohne Laufwerksbuchstaben.
%~nI	Erzeugt nur den Dateinamen von %I.
%~xI	Erzeugt nur die Dateierweiterung von %I.
%~sI	Erweitert %I zu einem vollständigen Dateinamen, in dem nur kurze Datei-/Verzeichnisnamen im 8.3-Format vorkommen.
%~aI	Erzeugt die Dateiattribute von %I.
%~tI	Erzeugt Datum und Zeit von %I.
%~zI	Erzeugt die Dateigröße von %I.
%~$PATH:I	Durchsucht die in der PATH-Umgebungsvariablen angegebenen Verzeichnisse nach der Datei, deren Name in %I steht und erweitert den Ausdruck auf Laufwerksbuchstabe:\Pfad\Dateiname.Erweiterung der ersten gefundenen Datei. Statt PATH kann auch eine andere Umgebungsvariable angegeben werden. Wenn der Name der Umgebungsvariablen nicht definiert ist oder die Datei, deren Name in %I steht, bei der Suche nicht gefunden wurde, wird der Ausdruck zu einer leeren Zeichenkette erweitert.

Beispiel 14 (für die Kommandozeile):
Betrachten wir ein Verzeichnis, bei dem DIR E:\Test\*.txt die folgende Ausgabe liefert:

Die folgende Tabelle gibt an, wie die Ausgabe zu jedem hinzugefügten Kürzel aussieht.

Befehl	Ausgabe
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~fF	E:\Test\Doku-Test.txt E:\Test\Versuch.txt
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~dF	E: E:
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~pF	\Test\ \Test\
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~nF	Doku-Test Versuch
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~xF	.txt .txt
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~sF	E:\Test\Doku-T~1.txt E:\Test\Versuch.txt
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~aF	--a------ --a------
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~tF	30.10.2010 18:52 09.09.2009 22:21
for /f "delims=" %F in ('dir /b E:\Test\*.txt') do @echo %~zF	8519 298
for %F in ("cmd.exe") do @echo %~F	cmd.exe
for %F in ("cmd.exe") do @echo %~$Path:F	C:\WINDOWS\system32\cmd.exe

Achtung! Der Befehl DIR /b E:\Test\*.txt aus den obigen Beispielen gibt nur die Dateinamen ohne Pfad aus. Wenn das aktuell gesetzte Verzeichnis nicht E:\Test ist und auch dort eine Datei mit Namen Versuch.txt vorhanden ist, werden von %~fF, %~dF, %~pF, %~sF, %~aF, %~tF und %~zF Daten zurückgegeben, die sich auf diese Datei beziehen, nicht auf E:\Test\Versuch.txt! Wenn Doku-Test.txt und Versuch.txt im aktuellen Verzeichnis nicht vorhanden sind, wird keine Fehlermeldung erzeugt, die Angaben zu Laufwerksbuchstaben und Pfaden werden einfach vom aktuellen Verzeichnis übernommen. Um obige Operatoren zu verwenden, immer dafür sorgen, dass die Laufvariable vollständige Pfade enthält!

Die o.g. Kürzel/Operatoren können auch kombiniert werden. So liefert z.B. %~dpF bei obigen Beispieldateien
und %~dpnxF ist gleichwertig zu %~fF.

Beispiel 15 (für die Kommandozeile):
Mit der Erweiterung von Laufvariablen und zwei geschachtelten FOR-Schleifen lässt sich das Problem aus Beispiel 9 nun lösen.
Die äußere FOR-Schleife listet die gewünschten Dateien mit Pfaden. Die innere FOR-Schleife wertet eine Zeichenkette aus, die aus dem Erstellungsdatum und der Erstellungszeit der Dateien besteht. Zwischen diesen beiden Angaben wird durch %~tf ein Leerzeichen erzeugt. Das erste Token ist das Erstellungsdatum, was an die Laufvariable %d zugewiesen wird. Der ECHO-Befehl gibt nur den Dateinamen, ohne Laufwerksbuchstaben und Pfad, sowie das Datum aus.

Wie man sieht, kann in der inneren FOR-Schleife die Laufvariable der äußeren FOR-Schleife benutzt werden.

FOR-Schleifen und GOTO

Ein GOTO-Befehl innerhalb von FOR-Schleifen, dessen Sprungziel ein Label ist, das ebenfalls innerhalb der FOR-Schleife liegt, führt zwar zu keiner Fehlermeldung, funktioniert aber nicht wie gewünscht. Ich übernehme hier Beispiele von @jeb-the-batcher aus seinem Kommentar zu diesem Tutorial.

Beispiel 16
FOR-Schleifen brechen ab, sobald man GOTO verwendet, selbst wenn das Ziel innerhalb der Schleife liegt.
Die Ausgabe ist folgende:
Statt in Zeile 7 den Inhalt der Laufvariablen auszugeben, wird nur noch %n ausgegeben. Von dem doppelten Prozentzeichen wird vom Befehlszeileninterpreter automatisch eines entfernt und das ganze nur noch als Text ausgegeben, weil der Befehl schon nicht mehr im Kontext der FOR-Schleife ausgeführt wird und somit die Laufvariable %%n nicht mehr definiert ist.

Beispiel 17
Aber Abbruch ist hier nicht mit einem sofortigen Abbruch zu verwechseln, hier dauert der Abbruch 10,5 Sekunden (System: Athlon 64 X2 3600+, 2x2GHz).
Die Ausgabe ist z.B. folgende:
An den Zeitangaben sieht man, dass die Schleife anscheinend wirklich 1.000.000 mal durchläuft. Die beiden ECHO-Befehle werden trotzdem jeweils nur einmal ausgeführt. Da hier keine verzögerte Variablenerweiterung aktiviert und benutzt wurde, müsste die Variable %time% auch bei beiden Ausgaben den gleichen Wert haben. Da das nicht so ist, sieht man auch daran, dass Zeile 7 ausserhalb des Kontexts der FOR-Schleife ausgeführt wird.

Praxistipps

Dieser Abschnitt ist als "Mitmach-Abschnitt" gedacht. Wer will, kann einen Schnipsel mit Erklärung posten, der

• erstaunlich kurz und trotzdem nützlich ist,
• besonders raffiniert programmiert ist oder
• einfach nur ein besonderes Detail von FOR-Schleifen vorstellt.

Ich werde die Postings in diesen Abschnitt integrieren. Mit der letzten Sorte von Schnipseln fange ich hier mal an.


1. Der Code
ist kürzer und schneller als
und liefert vollständige Pfade. Übrigens: Ich habe um den DIR-Befehl einen FOR /F Befehl gelegt, damit das Ergebnis, so wie bei der FOR-Variante, in einer Variablen vorliegt.


2. Der Code
liefert ein ähnliches Ergebnis wie
Die FOR /R Variante ist kürzer und schneller und es wird auch das Basisverzeichnis E:\Test gelistet.


3. Auch
und
sind sich im Ergebnis ähnlich. Abgesehen davon, dass die FOR /R Variante kürzer und schneller ist, wird auch das Wurzelverzeichnis gelistet und die Pfade haben keinen abschließenden Backslash (außer beim Wurzelverzeichnis E:\).


4. Beispiel 10 in einer Version, die die Eingabe von Zeichen, bei denen es sich nicht um Zahlen handelt, abfängt.
Gegenüber dem Beispiel 10 ist als relevanter Code nur Zeile 9 hinzugekommen. Deshalb werde ich nur dazu etwas sagen. Der Befehl FINDSTR wird hier dazu verwendet, um zu prüfen, ob %Number% etwas anderes als Zahlen enthält. Zuerst wird %Number% mit dem ECHO-Befehl ausgegeben. Die Ausgabe wird über eine Pipe an FINDSTR weitergeleitet. Der Suchstring von FINDSTR ist ein regulärer Ausdruck. Durch [^0-9] wird eine Klasse von Zeichen definiert. Diese Klasse enthält alle Zeichen ausser den Ziffern 0 bis 9. Enthält %Number% etwas anderes als Zahlen, findet FINDSTR also etwas, auf was sein Suchstring zutrifft. Dadurch wird die Ausgabe von FINDSTR an die Laufvariable %%c zugewiesen und der Befehl im Schleifenkörper des FOR-Befehls ausgeführt, also der Rücksprung zum Label InputNumber. Damit das ganze funktioniert, ist es wichtig, dass kein Leerzeichen zwischen dem abschließenden Prozentzeichen von %Number% und dem Escapezeichen ^ vor dem Pipezeichen | steht, das würde vom ECHO-Befehl sonst auch ausgegeben und der Rücksprung somit immer ausgeführt.


5. In Beispiel 12 wird ein Schnipsel vorgestellt, der eine Konfigurationsdatei einließt und dementsprechend Skript-Variablen setzt. Nachteilig an der Sache ist, daß ein Anwender gezwungen wäre, so eine Konfigurationsdatei mit einem Editor zu schreiben, der im DOS-/ASCII-Mode abspeichern kann, sonst gibt es Probleme bei Verzeichnisnamen, die eins der Zeichen ÄÖÜäöüß enthalten, denn die Befehle der Kommandozeile arbeiten immer noch im ASCII-Modus. Es muss also ein ANSI=>ASCII Konverter her, dann kann man Konfigurationsdateien mit Notepad schreiben.

Das folgende Skript demonstriert dabei gleich noch einen Programmiertrick. Oft ist man nämlich gezwungen, die verzögerte Variablenerweiterung zu benutzen, bekommt dann aber Probleme mit Variablen, die zur Laufzeit ein Ausrufezeichen enthalten können (z.B. weil Datei- oder Verzeichnisnamen darin gespeichert werden sollen). Es gibt aber eine Möglichkeit, auf die verzögerte Variablenerweiterung zu verzichten, indem man den Code, der mit einer in der FOR-Schleife veränderten Variablen arbeitet, in ein Unterprogramm auslagert. Netterweise hat die Variable dort, auch wenn ihr Name statt mit Ausrufezeichen ganz normal mit Prozentzeichen eingeschlossen ist, immer ihren aktuellen Wert. Im nachfolgenden Skript wird diese Technik aber nur deshalb verwendet, weil das Hin- und Herschalten der Codepage in der FOR-Schleife nicht funktioniert hat.


6. Um die Inhalte zweier Dateien zeilenweise zu mischen kann folgender Code verwendet werden:
Bei jedem Schleifendurchlauf wird aus jeder der beiden Eingabedateien jeweils eine Zeile gelesen.

Der FINDSTR-Befehl im Kopf der FOR-Schleife ließt wegen dem Parameter "^" alle Zeilen mit einem Anfang (dadurch werden alle Zeilen gelesen, auch leere) aus der ersten Eingabedatei. Durch den Parameter /n schreibt er vor jede Zeile die Zeilennummer gefolgt von einem Doppelpunkt. Der Doppelpunkt wird mit delims=: als Trennzeichen für den Tokenizer der FOR-Schleife festgelegt. Durch tokens=1* wird der vorgegebenen Laufvariablen %%a die Zeilennummer und der durch * automatisch erzeugten Laufvariablen %%b der Zeileninhalt zugewiesen.

Der Befehl set /p "line=" in Zeile 10 ließt die zweite Eingabedatei ein, denn diese wird in Zeile 13 des Scripts mit <"%InFile2%" der gesamten FOR-Schleife als Eingabedatei zugewiesen. Damit bei einer leeren Zeile in der zweiten Eingabedatei auch eine leere Zeile in der Ausgabedatei erscheint, wird in Zeile 9 die Variable gelöscht, die den Zeileninhalt aufnimmt.

Durch die Punkte nach den ECHO-Befehlen in den Zeilen 11 und 12 werden im Fall, dass eine der Variablen leer ist, tatsächlich Leerzeilen in die Ausgabedatei geschrieben. Ohne den Punkt nach dem ECHO-Befehl würde sonst die Meldung ECHO ist ausgeschaltet (OFF). in die Ausgabedatei geschrieben.

Falls die erste Eingabedatei weniger Zeilen als die zweite hat, werden aus der zweiten Eingabedatei nur so viele Zeilen gelesen, wie in der ersten Eingabedatei vorhanden sind.

Wenn die zweite Eingabedatei weniger Zeilen als die erste hat, werden für die fehlenden Zeilen Leerzeilen in die Ausgabedatei geschrieben.


7a. Eine Datei incl. Leerzeilen einlesen
Das Einlesen der Datei übernimmt der FINDSTR-Befehl. Damit können mit Hilfe sehr rudimentärer Regular Expressions Zeilen in Dateien gesucht werden, auf die das angegebene Suchmuster passt. Das Zeichen ^ steht für den Zeilenanfang. Dementsprechend passt das Suchmuster auf alle Zeilen. Durch den Parameter /n stellt FINDSTR jeder gefundenen Zeile die Zeilennummer gefolgt von einem Doppelpunkt voran. Der Doppelpunkt wird mit delims=: als Trennzeichen vereinbart. Die Zeilen der Eingabedatei werden wegen tokens=1* in zwei Tokens zerlegt. Das erste (in Laufvariable %%a, hier nicht verwendet) enthält die Zeilennummer und das zweite (in der automatisch erzeugten Laufvariable %%b) den Rest der Zeile nach dem Trennzeichen, also dem Doppelpunkt. Weil zwischen dem ECHO-Befehl und der Laufvariablen %%b ein Punkt steht, wird eine Leerzeile ausgegeben, wenn %%b nichts enthält, wenn also eine Leerzeile aus der Datei eingelesen wurde.

Der Code funktioniert übrigens auch einwandfrei, wenn die Datei Sonderzeichen enthält, die unter gewöhnlichen Umständen vom Batchscript-Interpreter als Steuerzeichen/Befehl angesehen werden. Der Inhalt der Laufvariablen von FOR-Schleifen wird NICHT interpretiert sondern als normaler Text angesehen.


7b. Die Ausgabe eines Befehls incl. Leerzeilen verarbeiten
Hier wird die Datei mit Hilfe des TYPE-Befehls eingelesen und über eine Pipe an den FINDSTR-Befehl geschickt. Statt TYPE könnte auch ein beliebiges anderes Kommando verwendet werden, z.B. DIR. Die Ausgabe von Leerzeilen wird durch den gleichen Trick wie in Beispiel 7a erledigt.

Der TYPE-Befehl ist übrigens dazu in der Lage, den Inhalt von Unicode-Dateien bei der Ausgabe in die aktuell eingestellte Codepage der Konsole zu konvertieren.


8. Laufvariablen einer FOR-Schleife in einem Unterprogramm verwenden
Als Grundgerüst wird hier nochmals der Code aus Beispiel 7 verwendet. Im Unterschied dazu wird die Ausgabe jedoch im Unterprogramm SubRoutine erledigt. Das besteht nur aus einer Dummy-FOR-Schleife, die lediglich den Zweck hat, die Verwendung von FOR-Laufvariablen zu erlauben - die Laufvariable %%b der FOR-Schleife aus dem Hauptprogramm!

Diese Technik sollte man zwar nur im äußersten Notfall benutzen (evtl. funktioniert dieser Trick in zukünftigen Versionen von CMD.exe nicht mehr), aber es ist gut zu wissen, dass diese Möglichkeit existiert.


9. Beschleunigung von FOR-Schleifen, die Ausgaben in eine Datei schreiben
Der Code ließt im aktuellen Verzeichnis alle Dateien mit der Erweiterung log ein und sucht in ihnen Zeilen, die den Begriff Error (ohne Berücksichtigung der Groß-/Kleinschreibung) enthalten. Gefundene Zeilen werden in eine Ausgabedatei geschrieben (mit dem vorangestellten Namen der Datei, aus der sie stammen).

Die Umleitung der Ausgabe in der letzten Zeile bezieht sich durch die Klammerung der beiden FOR-Schleifen auf den gesamten Codeblock innerhalb der Klammern. Dadurch muss die Ausgabedatei nur einmal geöffnet werden, was bei vielen Schreiboperationen den Scriptlauf sehr stark beschleunigt. Ich hatte schon Anwendungsfälle, wo durch diese Technik die Laufzeit von 15 Minuten auf 10 Sekunden verkürzt werden konnte.


10. Array-Simulation mit mehr als 31 Array-Elementen
In Beispiel 11 wurde bereits eine Array-Simulation gezeigt. Die Indizierung des Arrays wurde dort mittels der TOKENS-Option der FOR-Schleife durchgeführt, wodurch das Array aber höchstens 31 Elemente haben kann. Der folgende Schnipsel zeigt, wie man diese Begrenzung überwindet und wie man eine FOR-Schleife als auszuführenden Befehl in die Klammer einer äußeren FOR /F -Schleife schreibt.
Das Array wird mit der inneren FOR-Schleife Zeile für Zeile ausgegeben. Der FINDSTR-Befehl setzt durch den Parameter /N Zeilennummern und einen Doppelpunkt vor jedes Array-Element. Zeilennummer und Zeileninhalt werden von der äußeren FOR-Schleife durch die Optionen tokens=1* delims=: voneinander separiert. In der Laufvariablen %%a ist die Zeilennummer und in der Laufvariablen %%b der Zeileninhalt gespeichert. Wenn die Zeilennummer gleich dem gewünschten Index ist, wurde das Element gefunden. Dummerweise hängt der Batchscript-Interpreter noch ein Leerzeichen an den Zeileninhalt in %%b, das durch die Konstruktion in Zeile 21 entfernt wird.


11. Bestimmte Zeilen aus einer Datei extrahieren
In Beispiel 9 hatte ich erwähnt, dass man mit FOR /F zwar eine bestimmte Anzahl Zeilen vom Dateianfang aus überspringen kann, es jedoch keine Möglichkeit gibt, eine bestimmte Anzahl Zeilen am Ende einer Datei zu ignorieren oder nur eine bestimmte Anzahl Zeilen der Datei zu verarbeiten. Manchmal wäre es jedoch schon praktisch, ab einer bestimmten Dateizeile einen Block von Zeilen zu extrahieren und nur diese Zeilen weiterzuverarbeiten. Genau das leistet das folgende Script.
In dem Schnipsel werden einige bereits vorgestellte Techniken verwendet (innere FOR-Schleife im Kopf einer äußeren FOR-Schleife (Praxistipp 10), Einlesen einer Datei innerhalb einer FOR-Schleife durch Eingabeumleitung für die gesamte Schleife (Praxistipp 6) und Ausgabe von Variableninhalten innerhalb einer FOR-Schleife durch den SET-Befehl (Beispiel 7)).

Mit der inneren FOR-Schleife wird die Datei bis zur angegebenen Endzeile eingelesen. Jede eingelesene Zeile wird mit set /p "TmpVar=" an die Umgebungsvariable TmpVar zugewiesen, worauf der Variableninhalt mit set TmpVar ausgegeben wird. Beim Einlesen einer Leerzeile wird der Wert von TmpVar jedoch nicht verändert, der bisherige Wert bleibt erhalten. Damit der Inhalt der vorherigen Zeile nicht nochmals ausgegeben wird, wird TmpVar vor der Zuweisung des Inhalts einer Zeile mit set "TmpVar=" gelöscht. Damit in diesem Fall bei der Ausgabe des Variablenwerts keine Fehlermeldung ausgegeben wird (á la Umgebungsvariable existiert nicht), wird der Standard-Fehlerkanal auf das NUL-Device umgeleitet. Außerdem kann die fehlgeschlagene Ausführung von set TmpVar dazu benutzt werden, den Text TmpVar= auszugeben, damit die äußere FOR-Schleife an dieser Stelle eine Leerzeile ausgibt.

Die Ausgabe der inneren FOR-Schleife sieht ungefähr so aus:
Hier muss jetzt alles links vom Gleichheitszeichen entfernt und die gewünschte Anzahl Zeilen bis zur Startzeile übersprungen werden. Das macht die äußere FOR-Schleife, indem der Tokenizer mit den Optionen tokens=1* und delims== entsprechend eingestellt wird und mit der Option skip=... die nicht gewünschten Zeilen herausgefiltert werden.

Es gibt übrigens eine Einschränkung für das Script: Da die FOR /F-Schleife bei der Option SKIP= den Wert 0 nicht toleriert, kann man die Quelldatei nicht von Zeile 1 bis X sondern nur mindestens von Zeile 2 an verarbeiten. Für die Verarbeitung von Zeile 1 bis X muss die äußere FOR-Schleife entfernt und die innere entsprechend umgeschrieben werden, damit sie auch Stand-alone läuft (Escape-Zeichen entfernen).

setlocal DisableDelayedExpansion
FOR /F "delims=*" %%a in ("hallo ^caret!")  do (  
   echo %%a
   set var=%%a
)

setlocal DisableDelayedExpansion
FOR /F "delims=*" %%a in ("hallo ^caret!")  do (  
    set var=%%a
    setlocal EnableDelayedExpansion
    set "var=!var:h=b!"  
    echo !var!
    endlocal
)

setlocal EnableDelayedExpansion
set eins=1
set zwei=2
set drei=a
set "vier=set /p .=hallo < nul"  
FOR /F "tokens=!eins! delims=!zwei!" %%!drei! in ('!vier!')  do echo %%a  

for /L %%n in (1,1,100) DO (
  echo %%n
  goto :label
  :label
  echo %%n
)
echo ende
------------ AUSGABE ------
1
%n
ende

for /L %%n in (1,1,1000000) DO (
  echo %%n - %time%
  goto :xx
  :xx
  echo %%n - %time%
)
echo ende
------------ AUSGABE ------
1 - 22:28:05,73
%n - 22:28:21,09
ende

echo on
FOR /F ^"tokens^=1^ EOL^=^  

^ delims^=^" %%a in (myfile.txt) do echo %%a  

@echo off
for %%s in ("s-content") do (  
	echo loop1 loopvar-s=%%s
	call :test
)
exit /b

:test
echo test1 loopvar-s=%%s
for %%a in ("a-content") do (  
	echo loop2 loopvar-a=%%a
	echo loop2 loopvar-s=%%s
)
exit /b

setlocal
set "User=x-Tra"  
for /f %%i in (' " Dir /b *.bc? 2>nul|findstr /v /r /c:"[.]bco$"|findstr /v /r /c:"^%User%[.]"|find /v /c "" 2>nul " ') do echo %%i andere Dateien Vorhanden  

cmd /c"Befehl"
cmd /k"Befehl"

setlocal EnableDelayedExpansion
set eins=1
set zwei=2
set drei=a
set "vier=set /p .=hallo < nul"  
for /f "delims=" %%z in ( ' " FOR /F "tokens^=!eins! delims^=!zwei!" %%!drei! in (' " !vier! " ')  do @echo %%a " ' ) do echo %%z  

for %%x in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) do if exist %%x:\ echo Das Laufwerk ist angeschlossen %%x

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\batfile\shell\edit]
[HKEY_CLASSES_ROOT\batfile\shell\edit\command]
;"%ProgramFiles%\Windows NT\Accessories\wordpad.exe" "%1"  
@=hex(2):22,00,25,00,50,00,72,00,6f,00,67,00,72,00,61,00,6d,00,46,00,69,00,6c,\
  00,65,00,73,00,25,00,5c,00,57,00,69,00,6e,00,64,00,6f,00,77,00,73,00,20,00,\
  4e,00,54,00,5c,00,41,00,63,00,63,00,65,00,73,00,73,00,6f,00,72,00,69,00,65,\
  00,73,00,5c,00,77,00,6f,00,72,00,64,00,70,00,61,00,64,00,2e,00,65,00,78,00,\
  65,00,22,00,20,00,22,00,25,00,31,00,22,00,00,00

[HKEY_CLASSES_ROOT\batfile\shell\Notepad]
[HKEY_CLASSES_ROOT\batfile\shell\Notepad\command]
;%SystemRoot%\System32\NOTEPAD.EXE %1
@=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,\
  00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,4e,00,4f,00,\
  54,00,45,00,50,00,41,00,44,00,2e,00,45,00,58,00,45,00,20,00,25,00,31,00,00,\
  00

Windows Registry Editor Version 5.00

;Anwendung festlegen, mit welcher die .bat-Dateien standardmäßig bearbeitet werden sollen:
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[HKEY_CLASSES_ROOT\batfile\shell\edit\command]
;%SystemRoot%\System32\NOTEPAD.EXE %1
@=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,\
  00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,4e,00,4f,00,\
  54,00,45,00,50,00,41,00,44,00,2e,00,45,00,58,00,45,00,20,00,25,00,31,00,00,\
  00

;Zusätzliche Anwendung als Alternative festlegen bzw. entfernen
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[-HKEY_CLASSES_ROOT\batfile\shell\Notepad]
[-HKEY_CLASSES_ROOT\batfile\shell\Notepad\command]
;%SystemRoot%\System32\NOTEPAD.EXE %1
;@=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,\
  00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,4e,00,4f,00,\
  54,00,45,00,50,00,41,00,44,00,2e,00,45,00,58,00,45,00,20,00,25,00,31,00,00,\
  00

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Applets\Wordpad\Options]

;Statusleiste anzeigen
"ShowStatusBar"=dword:00000000  

;Lineal anzeigen
"ShowRuler"=dword:00000000  

"Units"=dword:00000001  
"Maximized"=dword:00000000  

;Am Fenster umbrechen
;Noch unbekannte Einstellung:	"FrameRect"=hex:50,01,00,00,80,00,00,00,bb,05,00,00,e9,03,00,00  
"Wrap"=dword:00000001  

"PageMargin"=hex:08,07,00,00,a0,05,00,00,08,07,00,00,a0,05,00,00  
"PrintPageNum"=dword:00000001  
"DefaultFormat"=dword:00000005