vimhelp 6.4 - en to de translation catalogue (133 entries)

en: *usr_40.txt*	For Vim version 6.4.  Last change: 2004 Feb 13
de: *usr_40.txt*	Für Vim version 6.4.  Letzte Änderung: 2004-Feb-13

en: 		     VIM USER MANUAL - by Bram Moolenaar
de: 		     VIM-BENUTZERHANDBUCH - von Bram Moolenaar

en: 			      Make new commands
de: 			      Neue Befehle machen

en: Vim is an extensible editor.  You can take a sequence of commands you use often and turn it into a new command.  Or redefine an existing command.  Autocommands make it possible to execute commands automatically.
de: Vim ist ein erweiterbarer Editor.  Sie können eine Folge von Befehlen nehmen, die Sie oft benutzen, und aus ihnen einen neuen Befehl machen.  Oder einen bestehenden Befehl neu definieren.  Automatische Befehle machen es möglich, Befehle automatisch auszuführen.

en: |40.1|	Key mapping |40.2|	Defining command-line commands |40.3|	Autocommands
de: |40.1|	Tasten belegen
    |40.2|	Befehlszeilen-Befehle definieren
    |40.3|	Automatische Befehle

en:      Next chapter: |usr_41.txt|  Write a Vim script
     Previous chapter: |usr_31.txt|  Exploiting the GUI
    Table of contents: |usr_toc.txt|
de: Nächstes Kapitel: |usr_41.txt|  Ein Vim-Skript schreiben
     Voriges Kapitel: |usr_31.txt| Die GUI ausnutzen
    Inhaltsübersicht: |usr_toc.txt|

en: *40.1*	Key mapping
de: *40.1*	Tasten belegen

en: A simple mapping was explained in section |05.3|.  The principle is that one
    sequence of key strokes is translated into another sequence of key strokes.
    This is a simple, yet powerful mechanism.
       The simplest form is that one key is mapped to a sequence of keys.  Since
    the function keys, except <F1>, have no predefined meaning in Vim, these are a
    good choice to map.  Example: >
de: Eine einfache Belegung wurde in Abschnitt |05.3| erklärt.  Das Prinzip ist,
    dass eine Folge von Tastendrücken in eine andere Folge von Tastendrücken
    übersetzt wird.  Dies ist ein einfacher, jedoch mächtiger Mechanismus.
       Die einfachste Form ist, dass eine Taste mit einer Folge von Tasten belegt
    wird.  Weil die Funktionstasten, außer <F1>, keine vordefinierte Bedeutung in
    Vim haben, sind diese eine gute Wahl zur Belegung.  Beispiel: >

en: This shows how three modes are used.  After going to the last line with "G",
    the "o" command opens a new line and starts Insert mode.  The text "Date: " is
    inserted and <Esc> takes you out of insert mode.
       Notice the use of special keys inside <>.  This is called angle bracket
    notation.  You type these as separate characters, not by pressing the key
    itself.  This makes the mappings better readable and you can copy and paste
    the text without problems.
       The ":" character takes Vim to the command line.  The ":read !date" command
    reads the output from the "date" command and appends it below the current
    line.  The <CR> is required to execute the ":read" command.
       At this point of execution the text looks like this:
de: Dies zeigt, wie drei Modi benutzt werden.  Nachdem mit »G« in die letzte Zeile
    gegangen wird, öffnet der Befehl »o« eine neue Zeile und geht in den
    Einfügemodus.  Der Text »Date: « wird eingefügt und <Esc> bringt uns aus dem
    Einfügemodus.
       Beachten Sie den Gebrauch von Sondertasten in <>.  Dies nennt sich Notation
    mit spitzen Klammern.  Sie tippen diese als getrennte Zeichen, nicht, indem
    Sie die Taste selbst drücken.  Dadurch wird die Belegung besser lesbar, und
    Sie können den Text ohne Probleme kopieren und einfügen.
       Das Zeichen »:« bringt Vim in die Befehlszeile.  Der Befehl »:read !date«
    liest die Ausgabe des Befehls »date« und hängt sie unter der aktuellen Zeile
    an.  Das <CR> wird benötigt, um den Befehl »:read« auszuführen.
       An dieser Stelle der Ausführung sieht der Text so aus:

en: Now "kJ" moves the cursor up and joins the lines together.
       To decide which key or keys you use for mapping, see |map-which-keys|.
de: Jetzt bewegt »kJ« den Cursor nach oben und fügt die Zeilen zusammen.
       Um zu entscheiden, welche Taste oder Tasten Sie zum Belegen verwenden,
    siehe |map-which-keys|.

en: MAPPING AND MODES
de: BELEGUNGEN UND MODI

en: The ":map" command defines remapping for keys in Normal mode.  You can also define mappings for other modes.  For example, ":imap" applies to Insert mode.  You can use it to insert a date below the cursor: >
de: Der Befehl »:map« definiert Neubelegungen für Tasten im normalen Modus.  Sie können auch Belegungen für andere Modi definieren.  »:imap« zum Beispiel ist für den Einfügemodus zuständig.  Sie können ihn benutzen, um ein Datum unter dem Cursor einzufügen: >

en: It looks a lot like the mapping for <F2> in Normal mode, only the start is
    different.  The <F2> mapping for Normal mode is still there.  Thus you can map
    the same key differently for each mode.
       Notice that, although this mapping starts in Insert mode, it ends in Normal
    mode.  If you want it to continue in Insert mode, append a "a" to the mapping.
de: Sie sieht sehr wie die Belegung für <F2> im normalen Modus aus, nur der Beginn
    ist verschieden.  Die Belegung von <F2> im normalen Modus ist noch da.  Also
    können Sie dieselbe Taste für jeden Modus unterschiedlich belegen.
       Beachten Sie, dass, obwohl diese Belegung im Einfügemodus beginnt, sie im
    normalen Modus endet.  Falls Sie im Einfügemodus fortfahren wollen, hängen Sie
    der Belegung ein »a« an.

en: Here is an overview of map commands and in which mode they work:
de: Hier ist eine Übersicht der Belegungsbefehle und in welchem Modus sie arbeiten:

en: 	:map		Normal, Visual and Operator-pending
    	:vmap		Visual
    	:nmap		Normal
    	:omap		Operator-pending
    	:map!		Insert and Command-line
    	:imap		Insert
    	:cmap		Command-line
de: 	:map		normal, visuell und Operator-hängend
    	:vmap		visuell
    	:nmap		normal
    	:omap		Operator-hängend
    	:map!		Einfügen und Befehlszeile
    	:imap		Einfügen
    	:cmap		Befehlszeile

en: Operator-pending mode is when you typed an operator character, such as "d" or "y", and you are expected to type the motion command or a text object.  Thus when you type "dw", the "w" is entered in operator-pending mode.
de: Der Operator-hängende Modus ist, wenn Sie ein Operator-Zeichen, so wie »d« oder »y«, getippt haben, und Vim auf einen Bewegungsbefehl oder ein Textobjekt wartet.  Wenn Sie also »dw« tippen, wird das »w« im Operator-hängenden Modus eingegeben.

en: Suppose that you want to define <F7> so that the command d<F7> deletes a C program block (text enclosed in curly braces, {}).  Similarly y<F7> would yank the program block into the unnamed register.  Therefore, what you need to do is to define <F7> to select the current program block.  You can do this with the following command: >
de: Angenommen, Sie wollen <F7> so definieren, dass der Befehl »d<F7>« einen C-Programm-Block löscht (in geschwungene Klammern, {}, eingeschlossener Text).  Analog würde »y<F7>« den Programm-Block in das unbenannte Register kopieren.  Was Sie demnach tun müssen, ist es, <F7> so zu definieren, dass sie den aktuellen Programm-Block auswählt.  Sie können dies mit dem folgenden Befehl tun: >

en: This causes <F7> to perform a select block "a{" in operator-pending mode, just like you typed it.  This mapping is useful if typing a { on your keyboard is a bit difficult.
de: Dies lässt <F7> eine Blockauswahl »a{« im Operator-hängenden Modus ausführen, genau als hätten Sie es getippt.  Diese Belegung ist nützlich, falls das Tippen von { auf Ihrer Tastatur schwierig ist.

en: LISTING MAPPINGS
de: BELEGUNGEN AUFLISTEN

en: To see the currently defined mappings, use ":map" without arguments.  Or one of the variants that include the mode in which they work.  The output could look like this:
de: Um die aktuell definierten Belegungen zu sehen, benutzen Sie »:map« ohne Argumente.  Oder eine der Varianten, die den Modus beinhalten, in dem sie arbeiten.  Die Ausgabe könnte so aussehen:

en: The first column of the list shows in which mode the mapping is effective.
    This is "n" for Normal mode, "i" for Insert mode, etc.  A blank is used for a
    mapping defined with ":map", thus effective in both Normal and Visual mode.
       One useful purpose of listing the mapping is to check if special keys in <>
    form have been recognized (this only works when color is supported).  For
    example, when <Esc> is displayed in color, it stands for the escape character.
    When it has the same color as the other text, it is five characters.
de: Die erste Spalte der Liste gibt an, in welchem Modus die Belegung
    funktioniert.  Dies ist »n« für den normalen Modus, »i« für den Einfügemodus
    usw.  Ein Leerzeichen wird für eine mit »:map« definierte Belegung verwandt,
    also effektiv im normalen und visuellen Modus.
       Ein nützlicher Aspekt, die Belegungen zu listen, ist zu prüfen, ob
    Sondertasten in <>-Form erkannt wurden (dies funktioniert nur, wenn Farbe
    unterstützt wird).  Wenn zum Beispiel <Esc> farbig dargestellt wird, steht es
    für die Escape-Taste.  Wenn es dieselbe Farbe wie der andere Text hat, sind es
    nur fünf Zeichen.

en: REMAPPING
de: NEUBELEGEN

en: The result of a mapping is inspected for other mappings in it.  For example, the mappings for <F2> above could be shortened to: >
de: Das Ergebnis einer Belegung wird nach anderen Belegungen in ihr inspiziert.  Zum Beispiel könnten die Belegungen für <F2> oben folgendermaßen abgekürzt werden: >

en: For Normal mode <F2> is mapped to go to the last line, and then behave like <F3> was pressed.  In Insert mode <F2> stops Insert mode with <Esc> and then also uses <F3>.  Then <F3> is mapped to do the actual work.
de: Für den normalen Modus wird <F2> so belegt, dass in die letzte Zeile gegangen wird, und dann so getan wird, als ob <F3> gedrückt wurde.  Im Einfügemodus beendet <F2> den Einfügemodus mit <Esc> und benutzt dann ebenfalls <F3>.  Dann wird <F3> so belegt, dass sie die tatsächliche Arbeit macht.

en: Suppose you hardly ever use Ex mode, and want to use the "Q" command to format text (this was so in old versions of Vim).  This mapping will do it: >
de: Angenommen, Sie benutzen kaum den Ex-Modus, und wollen den Befehl »Q« dazu verwenden, Text zu formatieren (so war es in alten Vim-Versionen).  Die folgende Belegung macht es: >

en: But, in rare cases you need to use Ex mode anyway.  Let's map "gQ" to Q, so that you can still go to Ex mode: >
de: Aber in seltenen Fällen brauchen Sie dennoch den Ex-Modus.  Lassen Sie uns »gQ« mit Q belegen, so dass Sie immer noch in den Ex-Modus gehen können: >

en: What happens now is that when you type "gQ" it is mapped to "Q".  So far so
    good.  But then "Q" is mapped to "gq", thus typing "gQ" results in "gq", and
    you don't get to Ex mode at all.
       To avoid keys to be mapped again, use the ":noremap" command: >
de: Was nun geschieht: Sie tippen »gQ« und es ist mit »Q« belegt.  So weit, so
    gut.  Aber dann ist »Q« mit »gq« belegt, also resultiert das Tippen von »gQ«
    in »gq«, und Sie kommen gar nicht in den Ex-Modus.
       Um zu vermeiden, dass Tasten wieder belegt werden, benutzen Sie den Befehl
    »:noremap«: >

en: Now Vim knows that the "Q" is not to be inspected for mappings that apply to it.  There is a similar command for every mode:
de: Nun weiß Vim, dass »Q« nicht nach weiteren Belegungen, die für es gelten, inspiziert werden soll.  Analoge Befehle gibt es für jeden Modus:

en: 	:noremap	Normal, Visual and Operator-pending
    	:vnoremap	Visual
    	:nnoremap	Normal
    	:onoremap	Operator-pending
    	:noremap!	Insert and Command-line
    	:inoremap	Insert
    	:cnoremap	Command-line
de: 	:noremap	normal, visuell und Operator-hängend
    	:vnoremap	visuell
    	:nnoremap	normal
    	:onoremap	Operator-hängend
    	:noremap!	Einfügen und Befehlszeile
    	:inoremap	Einfügen
    	:cnoremap	Befehlszeile

en: RECURSIVE MAPPING
de: DIE REKURSIVE BELEGUNG

en: When a mapping triggers itself, it will run forever.  This can be used to
    repeat an action an unlimited number of times.
       For example, you have a list of files that contain a version number in the
    first line.  You edit these files with "vim *.txt".  You are now editing the
    first file.  Define this mapping: >
de: Wenn eine Belegung sich selbst auslöst, läuft sie für immer.  Dies kann
    benutzt werden, um eine Aktion eine unbegrenzte Anzahl von Malen zu
    wiederholen.
       Sie haben zum Beispiel eine Liste von Dateien, die eine Versionsnummer in
    der ersten Zeile enthalten.  Sie editieren diese mit »vim *.txt«.  Sie
    editieren nun die erste Datei.  Definieren Sie diese Belegung: >

en: Now you type ",,".  This triggers the mapping.  It replaces "5.1" with "5.2"
    in the first line.  Then it does a ":wnext" to write the file and edit the
    next one.  The mapping ends in ",,".  This triggers the same mapping again,
    thus doing the substitution, etc.
       This continues until there is an error.  In this case it could be a file
    where the substitute command doesn't find a match for "5.1".  You can then
    make a change to insert "5.1" and continue by typing ",," again.  Or the
    ":wnext" fails, because you are in the last file in the list.
       When a mapping runs into an error halfway, the rest of the mapping is
    discarded.  CTRL-C interrupts the mapping (CTRL-Break on MS-Windows).
de: Nun tippen Sie »,,«.  Dies löst die Belegung aus.  Sie ersetzt in der ersten
    Zeile »5.1« durch »5.2«.  Dann macht sie »:wnext« um die Datei zu sichern und
    die nächste zu editieren.  Die Belegung endet mit »,,«.  Die löst dieselbe
    Belegung wieder aus, also die Ersetzung machen usw.
       Dies geht so weiter bis es einen Fehler gibt.  In diesem Falle könnte es
    eine Datei sein, wo der Befehl »:substitute« keine Übereinstimmung für »5.1«
    findet.  Sie können dann »5.1« einfügen und fortfahren, indem Sie »,,« erneut
    tippen.  Oder »:wnext« scheitert, weil Sie in der letzten Datei der Liste
    sind.
       Wenn eine Belegung auf halben Wege in einen Fehler läuft, wird der Rest der
    Belegung nicht mehr beachtet.  CTRL-C unterbricht die Belegung (unter
    MS-Windows CTRL-Untbr).

en: DELETE A MAPPING
de: EINE BELEGUNG LÖSCHEN

en: To remove a mapping use the ":unmap" command.  Again, the mode the unmapping applies to depends on the command used:
de: Um eine Belegung zu entfernen, benutzen Sie den Befehl »:unmap«.  Und wieder entspricht der Modus, für den die Belegung entfernt wird, dem benutzten Befehl:

en: 	:unmap		Normal, Visual and Operator-pending
    	:vunmap		Visual
    	:nunmap		Normal
    	:ounmap		Operator-pending
    	:unmap!		Insert and Command-line
    	:iunmap		Insert
    	:cunmap		Command-line
de: 	:unmap		normal, visuell und Operator-hängend
    	:vunmap		visuell
    	:nunmap		normal
    	:ounmap		Operator-hängend
    	:unmap!		Einfügen und Befehlszeile
    	:iunmap		Einfügen
    	:cunmap		Befehlszeile

en: There is a trick to define a mapping that works in Normal and Operator-pending mode, but not in Visual mode.  First define it for all three modes, then delete it for Visual mode: >
de: Es gibt einen Trick, eine Belegung zu definieren, die im normalen und Operator-hängenden Modus funktioniert, aber nicht im visuellen.  Zuerst definiere man sie für alle drei Modi, dann lösche man sie im visuellen Modus: >

en: Notice that the five characters "<C-A>" stand for the single key CTRL-A.
de: Beachten Sie, dass die fünf Zeichen »<C-A>« für die Tastenkombination CTRL-A stehen.

en: To remove all mappings use the |:mapclear| command.  You can guess the variations for different modes by now.  Be careful with this command, it can't be undone.
de: Um alle Belegungen zu entfernen, benutzen Sie den Befehl |:mapclear|.  Sie können die Variationen für verschiedene Modi nun raten.  Seien Sie vorsichtig mit diesem Befehl, er kann nicht rückgängig gemacht werden.

en: SPECIAL CHARACTERS
de: SONDERZEICHEN

en: The ":map" command can be followed by another command.  A | character
    separates the two commands.  This also means that a | character can't be used
    inside a map command.  To include one, use <Bar> (five characters).  Example:
    >
    	:map <F8> :write <Bar> !checkin %<CR>
de: Dem Befehl »:map« kann ein weiterer Befehl folgen.  Das Zeichen »|« trennt die
    beiden Befehle.  Dies bedeutet auch, dass das Zeichen »|« nicht in einem
    Belegungsbefehl verwandt werden kann.  Um eins einzubeziehen, benutzen Sie
    <Bar> (fünf Zeichen).  Beispiel:
    >
    	:map <F8> :write <Bar> !checkin %<CR>

en: The same problem applies to the ":unmap" command, with the addition that you
    have to watch out for trailing white space.  These two commands are different:
    >
    	:unmap a | unmap b
    	:unmap a| unmap b
de: Dasselbe Problem trifft auf den Befehl »:unmap« zu, und zusätzlich müssen Sie
    auf nachfolgende Leerzeichen achten.  Diese zwei Befehle sind verschieden:
    >
    	:unmap a | unmap b
    	:unmap a| unmap b

en: The first command tries to unmap "a ", with a trailing space.
de: Der erste Befehl versucht »a « freizugeben, mit einem nachfolgen Leerzeichen.

en: When using a space inside a mapping, use <Space> (seven characters): >
de: Wenn Sie ein Leerzeichen in einer Belegung verwenden, benutzen Sie <Space> (sieben Zeichen): >

en: This makes the spacebar move a blank-separated word forward.
de: Dies lässt die Leertaste ein Leerzeichen-getrenntes Wort vorwärts bewegen.

en: It is not possible to put a comment directly after a mapping, because the " character is considered to be part of the mapping.  You can use |", this starts a new, empty command with a comment.  Example: >
de: Es ist nicht möglich, einen Kommentar direkt nach eine Belegung zu setzen, weil das Zeichen »"« als Teil der Belegung angenommen wird.  Sie können »|"« verwenden, dies beginnt einen neuen, leeren Befehl mit einem Kommentar.  Beispiel: >

en: 	:map <Space> W|     " Use spacebar to move forward a word
de: 	:map <Space> W|     " Benutze Leertaste, um ein Wort vorwärts zu gehen

en: MAPPINGS AND ABBREVIATIONS
de: BELEGUNGEN UND ABKÜRZUNGEN

en: Abbreviations are a lot like Insert mode mappings.  The arguments are handled
    in the same way.  The main difference is the way they are triggered.  An
    abbreviation is triggered by typing a non-word character after the word.  A
    mapping is triggered when typing the last character.
       Another difference is that the characters you type for an abbreviation are
    inserted in the text while you type them.  When the abbreviation is triggered
    these characters are deleted and replaced by what the abbreviation produces.
    When typing the characters for a mapping, nothing is inserted until you type
    the last character that triggers it.  If the 'showcmd' option is set, the
    typed characters are displayed in the last line of the Vim window.
       An exception is when a mapping is ambiguous.  Suppose you have done two
    mappings: >
de: Abkürzungen verhalten sich sehr wie Belegungen für den Einfügemodus.  Die
    Argumente werden auf dieselbe Art behandelt.  Der Hauptunterschied ist die
    Art, wie sie ausgelöst werden.  Eine Abkürzung wird ausgelöst, indem man ein
    nicht-Wort-Zeichen nach dem Wort tippt.  Eine Belegung wird ausgelöst, wenn
    das letzte Zeichen getippt wird.
       Ein weiterer Unterschied ist, dass die Zeichen, die Sie für eine Abkürzung
    tippen in den Text eingefügt werden, während Sie sie tippen.  Wenn die
    Abkürzung ausgelöst wird, werden diese Zeichen gelöscht und durch das ersetzt,
    was die Abkürzung produziert.  Beim Tippen der Zeichen für eine Belegung
    wird nichts eingefügt, bis Sie das letzte Zeichen tippen, das sie auslöst.
    Falls die Option 'showcmd' gesetzt ist, werden die getippten Zeichen in der
    letzten Zeile des Vim-Fensters angezeigt.
       Eine Ausnahme ist, wenn eine Belegung mehrdeutig ist.  Angenommen, Sie
    haben zwei Belegungen gemacht: >

en: Now, when you type "aa", Vim doesn't know if it should apply the first or the second mapping.  It waits for another character to be typed.  If it is an "a", the second mapping is applied and results in "bar".  If it is a space, for example, the first mapping is applied, resulting in "foo", and then the space is inserted.
de: Wenn Sie nun »aa« tippen, weiß Vim nicht, ob er die erste oder das zweite Belegung anwenden soll.  Er wartet, ob ein weiteres Zeichen getippt ist.  Falls es ein »a« ist, wird die zwete Belegung angewandt und resultiert in »bar«.  Falls es zum Beispiel ein Leerzeichen ist, wird die erste Belegung angewandt, resultierend in »foo«, und dann wird das Leerzeichen einfügt.

en: ADDITIONALLY...
de: DARÜBERHINAUS...

en: The <script> keyword can be used to make a mapping local to a script.  See |:map-<script>|.
de: Das Schlüsselwort <script> kann benutzt werden, um ein Belegung lokal zu einem Skript zu machen.  Siehe |:map-<script>|.

en: The <buffer> keyword can be used to make a mapping local to a specific buffer.  See |:map-<buffer>|
de: Das Schlüsselwort <buffer> kann verwandt werden, um eine Belegung lokal zu einem bestimmten Puffer zu machen.  Siehe |:map-<buffer>|.

en: The <unique> keyword can be used to make defining a new mapping fail when it already exists.  Otherwise a new mapping simply overwrites the old one.  See |:map-<unique>|.
de: Das Schlüsselwort <unique> kann benutzt werden, um das Definieren einer Belegung scheitern zu lassen, wenn sie bereits existiert.  Ansonsten überschreibt eine neue Belegung einfach die alte.  Siehe |:map-<unique>|.

en: To make a key do nothing, map it to <Nop> (five characters).  This will make the <F7> key do nothing at all: >
de: Um eine Taste nichts machen zu lassen, belegen Sie sie mit <Nop> (fünf Zeichen).  Dies lässt die Taste <F7> überhaupt nichts machen: >

en: There must be no space after <Nop>.
de: Es darf kein Zeichen nach <Nop> sein.

en: *40.2*	Defining command-line commands
de: *40.2*	Befehlszeilen-Befehle definieren

en: The Vim editor enables you to define your own commands.  You execute these
    commands just like any other Command-line mode command.
       To define a command, use the ":command" command, as follows: >
de: Der Editor Vim ermöglicht Ihnen, Ihre eigenen Befehle zu definieren.  Sie
    führen diese ganz wie jeden anderen Befehl im Befehlszeilen-Modus aus.
       Um einen Befehl zu definieren, benutzen Sie den Befehl »:command«, wie
    folgt: >

en: Now when you execute the command ":DeleteFirst" Vim executes ":1delete", which deletes the first line.
de: Wenn Sie nun den Befehl »:DeleteFirst« ausführen, führt Vim »:1delete« aus, was die erste Zeile löscht.

en: 	Note:
    	User-defined commands must start with a capital letter.  You cannot
    	use ":X", ":Next" and ":Print".  The underscore cannot be used!  You
    	can use digits, but this is discouraged.
de: 	Anmerkung:
    	Benutzer-definierte Befehle müssen mit einem Großbuchstaben beginnen.
    	Sie können nicht »:X«, »:Next« und »:Print« verwenden.  Der
    	Unterstrich kann nicht benutzt werden! Sie können Ziffern verwenden,
    	aber davon wird abgeraten.

en: To list the user-defined commands, execute the following command: >
de: Um die benutzer-definierten Befehle aufzulisten, führen Sie den folgenden Befehl aus: >

en: Just like with the builtin commands, the user defined commands can be abbreviated.  You need to type just enough to distinguish the command from another.  Command line completion can be used to get the full name.
de: Ganz wie mit den eingebauten Befehlen, können die benutzer-definierten Befehle abgekürzt werden.  Sie brauchen nur soviel zu tippen, um den Befehl von einem anderen zu unterscheiden.  Befehlszeilen-Vervollständigung kann benutzt werden, um den vollen Namen zu erhalten.

en: NUMBER OF ARGUMENTS
de: ANZAHL VON ARGUMENTEN

en: User-defined commands can take a series of arguments.  The number of arguments must be specified by the -nargs option.  For instance, the example :DeleteFirst command takes no arguments, so you could have defined it as follows: >
de: Benutzer-definierte Befehle können eine Folge von Argumenten nehmen.  Die Zahl von Argumenten muss mit der Option -nargs angegeben werden.  Das Beispiel :DeleteFirst etwa nimmt keine Argumente, so dass Sie es wie folgt definieren können: >

en: However, because zero arguments is the default, you do not need to add "-nargs=0".  The other values of -nargs are as follows:
de: Da jedoch null Argumente der Standardfall sind, brauchen Sie nicht »-nargs=0« hinzufügen.  Die anderen Werte von -nargs sind wie folgt:

en: 	-nargs=0	No arguments
    	-nargs=1	One argument
    	-nargs=*	Any number of arguments
    	-nargs=?	Zero or one argument
    	-nargs=+	One or more arguments
de: 	-nargs=0	Keine Argumente
    	-nargs=1	Ein Argument
    	-nargs=*	Jede Anzahl von Argumenten
    	-nargs=?	Null oder ein Argument
    	-nargs=+	Ein oder mehr Argumente

en: USING THE ARGUMENTS
de: DIE ARGUMENTE BENUTZEN

en: Inside the command definition, the arguments are represented by the <args> keyword.  For example: >
de: Innerhalb der Befehls-Definition werden die Argumente durch das Schlüsselwort <args> repräsentiert.  Zum Beispiel: >

en: Now when you type >
de: Wenn Sie nun tippen >

en: Vim echoes "Hello World".  However, if you add a double quote, it won't work.  For example: >
de: gibt Vim »Hello World« aus.  Falls Sie jedoch ein doppeltes Zitatzeichen hinzufügen, funktioniert es nicht.  Zum Beispiel: >

en: To get special characters turned into a string, properly escaped to use as an expression, use "<q-args>": >
de: Um Sonderzeichen in eine Zeichenkette verwandelt zu bekommen, richtig geschützt als ein Ausdruck, benutzen Sie »<q-args>«: >

en: Now the above ":Say" command will result in this to be executed: >
de: Nun resultiert der obige Befehl »:Say« in diesem zur Ausführung: >

en: The <f-args> keyword contains the same information as the <args> keyword,
    except in a format suitable for use as function call arguments.  For example:
    >
    	:command -nargs=* DoIt :call AFunction(<f-args>)
    	:DoIt a b c
de: Das Schlüsselwort <f-args> enthält dieselben Informationen wie das
    Schlüsselwort <args>, außer dass sie in einem Format sind, das sich für
    einen Funktionsaufruf eignet.  Zum Beispiel:
    >
    	:command -nargs=* DoIt :call AFunction(<f-args>)
    	:DoIt a b c

en: Executes the following command: >
de: führt den folgenden Befehl aus: >

en: LINE RANGE
de: ZEILENBEREICH

en: Some commands take a range as their argument.  To tell Vim that you are defining such a command, you need to specify a -range option.  The values for this option are as follows:
de: Einige Befehlen nehmen einen Bereich als ihr Argument.  Um Vim zu sagen, dass Sie solch einen Befehl definieren, müssen Sie die Option -range angeben.  Die Werte für diese Option sind wie folgt:

en: 	-range		Range is allowed; default is the current line.
    	-range=%	Range is allowed; default is the whole file.
    	-range={count}	Range is allowed; the last number in it is used as a
    			single number whose default is {count}.
de: 	-range		Bereich ist erlaubt; Standard ist die aktuelle Zeile.
    	-range=%	Bereich ist erlaubt; Standard ist die ganze Datei.
    	-range={count}	Bereich ist erlaubt; die letzte Zeilenzahl in ihm wird
    			als eine einzelne Nummer genommern, deren Standard
    			{count} ist.

en: When a range is specified, the keywords <line1> and <line2> get the values of the first and last line in the range.  For example, the following command defines the SaveIt command, which writes out the specified range to the file "save_file": >
de: Wenn ein Bereich angegeben wird, erhalten die Schlüsselwörter <line1> und <line2> die Werte der ersten und letzten Zeile im Bereich.  Der folgende Befehl definiert zum Beispiel den Befehl SaveIt, der den angegeben Bereich in die Datei »save_file« schreibt: >

en: OTHER OPTIONS
de: ANDERE OPTIONEN

en: Some of the other options and keywords are as follows:
de: Einige der anderen Optionen und Schlüsselwörter sind wie folgt:

en: 	-count={number}		The command can take a count whose default is
    				{number}.  The resulting count can be used
    				through the <count> keyword.
    	-bang			You can use a !. If present, using <bang> will
    				result in a !.
    	-register		You can specify a register. (The default is
    				the unnamed register.)
    				The register specification is available as
    				<reg> (a.k.a. <register>).
    	-complete={type}	Type of command-line completion used.  See
    				|:command-completion| for the list of possible
    				values.
    	-bar			The command can be followed by | and another
    				command, or " and a comment.
    	-buffer			The command is only available for the current
    				buffer.
de: 	-count={number}		Der Befehl kann eine Anzahl nehmen, deren
    				Standard {number} ist.  Die resultierende
    				Anzahl kann über das Schlüsselwort <count>
    				verwandt werden.
    	-bang			Sie können ein ! benutzen.  Falls vorhanden,
    				ergibt das Benutzen von <bang> ein !.
    	-register		Sie können ein Register angeben.  (Standard
    				ist das unbenannte Register.)
    				Die Registerangabe ist verfügbar als <reg>
    				(aka. <register>).
    	-complete={type}	Typ der zu verwendenden Befehlszeilen-
    				Vervollständigung. Siehe |:command-completion|
    				für die Liste möglicher Werte.
    	-bar			Dem Befehl kann | und ein anderer Befehl
    				folgen, oder " und ein Kommentar
    	-buffer			Der Befehl ist nur für den aktuellen Puffer
    				verfügbar.

en: Finally, you have the <lt> keyword.  It stands for the character <.  Use this to escape the special meaning of the <> items mentioned.
de: Schließlich haben Sie das Schlüsselwort <lt>.  Es steht für das Zeichen <.  Benutzen Sie dies, um die besondere Bedeutung der erwähnten <>-Elemente aufzuheben.

en: REDEFINING AND DELETING
de: NEUDEFINIEREN UND LÖSCHEN

en: To redefine the same command use the ! argument: >
de: Um denselben Befehl neu zu definieren, benutzen Sie das Argument »!«: >

en: To delete a user command use ":delcommand".  It takes a single argument, which is the name of the command.  Example: >
de: Um einen Benutzer-Befehl zu löschen, benutzen Sie »:delcommand«.  Er nimmt ein einzelnes Argument, das der Name des Befehls ist.  Beispiel: >

en: To delete all the user commands: >
de: Um alle Benutzer-Befehle zu löschen: >

en: Careful, this can't be undone!
de: Vorsicht, dies kann nicht zurück genommen werden!

en: More details about all this in the reference manual: |user-commands|.
de: Mehr Details über all dies im Referenz-Handbuch: |user-commands|.

en: *40.3*	Autocommands
de: *40.3*	Automatische Befehle

en: An autocommand is a command that is executed automatically in response to some
    event, such as a file being read or written or a buffer change. Through the
    use of autocommands you can train Vim to edit compressed files, for example.
    That is used in the |gzip| plugin.
       Autocommands are very powerful.  Use them with care and they will help you
    avoid typing many commands.  Use them carelessly and they will cause a lot of
    trouble.
de: Ein automatischer Befehl wird automatisch als Antwort auf irgendein Ereignis
    ausgeführt, sei es, dass eine Datei gelesen wird, oder ein Puffer-Wechsel.
    Durch die Benutzung von automatischen Befehlen können Sie Vim zum Beispiel
    beibringen, komprimierte Dateien zu editieren.  Dies wird in dem |gzip|-Plugin
    benutzt.
       Automatische Befehle sind sehr mächtig.  Nutzen Sie sie sorgsam, und sie
    werden Ihnen sehr helfen.  Nutzen Sie sie sorglos, werden Sie Ihnen viel Ärger
    bereiten.

en: Suppose you want to replace a date stamp on the end of a file every time it is written.  First you define a function: >
de: Angenommen, Sie haben einen Zeitstempel am Ende einer Datei, und wollen ihn jedesmal, wenn die Datei geschrieben wird, ersetzen.  Zuerst definieren Sie eine Funktion: >

en: You want this function to be called each time, just before a file is written.  This will make that happen: >
de: Sie wollen diese Funktion jedesmal aufrufen, gerade bevor eine Datei geschrieben wird.  Dies lässt es geschehen: >

en: "FileWritePre" is the event for which this autocommand is triggered: Just
    before (pre) writing a file.  The "*" is a pattern to match with the file
    name.  In this case it matches all files.
       With this command enabled, when you do a ":write", Vim checks for any
    matching FileWritePre autocommands and executes them, and then it
    performs the ":write".
       The general form of the :autocmd command is as follows: >
de: »FileWritePre« ist das Ereignis, für das dieser automatische Befehl ausgelöst
    wird: Gerade vor (prä) dem Sichern einer Datei.  Der »*« ist ein Muster zur
    Übereinstimmung mit dem Dateinamen.  In diesem Falle greift es bei allen
    Dateien.
       Wenn dieser Befehl aktiv ist, und Sie »:write« geben, prüft Vim nach
    jedweden automatischen Befehlen für FileWritePre und führt sie aus, und macht
    dann das »:write«.
       Die generelle Form des Befehls :autocmd ist wie folgt: >

en: The [group] name is optional.  It is used in managing and calling the commands
    (more on this later).  The {events} parameter is a list of events (comma
    separated) that trigger the command.
       {file_pattern} is a filename, usually with wildcards.  For example, using
    "*.txt" makes the autocommand be used for all files whose name end in ".txt".
    The optional [nested] flag allows for nesting of autocommands (see below), and
    finally, {command} is the command to be executed.
de: Der Gruppenname ist optional.  Er wird zum Verwalten und Aufrufen der Befehle
    verwandt (mehr dazu später).  Der Parameter {events} ist eine (komma-
    getrennte) Liste von Ereignissen, die den Befehl auslösen.
       {file_pattern} ist ein Dateiname, für gewöhnlich mit Wildcards.  Das
    Benutzen von »*.txt« lässt den automatischen Befehl für alle Dateien, deren
    Name in ».txt« endet, wirken.  Das optionale Flag [nested] erlaubt die
    Verschachtelung von automatischen Befehlen, und schließlich ist {command} der
    auszuführende Befehl.

en: EVENTS
de: EREIGNISSE

en: One of the most useful events is BufReadPost.  It is triggered after a new file is being edited.  It is commonly used to set option values.  For example, you know that "*.gsm" files are GNU assembly language.  To get the syntax file right, define this autocommand: >
de: Eines der nützlichsten Ereignisse ist BufReadPost.  Es wird ausgelöst, nachdem eine neue Datei editiert wird.  Es wird für gewöhnlich zum Setzen von Optionen verwandt.  Sie wissen zum Beispiel, dass »*.gsm«-Dateien GNU-Assembler-Sprache sind.  Um die Syntax richtig zu bekommen, definieren Sie diesen automatischen Befehl: >

en: If Vim is able to detect the type of file, it will set the 'filetype' option for you.  This triggers the Filetype event.  Use this to do something when a certain type of file is edited.  For example, to load a list of abbreviations for text files: >
de: Falls Vim den Typ der Datei erkennen kann, setzt er die Option 'filetype' für Sie.  Dies löst das Ereignis Filetype aus.  Benutzen Sie dies, um etwas zu tun, wenn ein bestimmter Typ Dateien editiert wird.  Zum Beispiel das Laden einer List von Abkürzungen für Text-Dateien: >

en: When starting to edit a new file, you could make Vim insert a skeleton: >
de: Beim Beginnen, eine neue Datei zu editieren, könnten Sie Vim ein Skelett einfügen lassen: >

en: See |autocmd-events| for a complete list of events.
de: Siehe |autocmd-events| für eine komplette Liste von Ereignissen.

en: PATTERNS
de: MUSTER

en: The {file_pattern} argument can actually be a comma-separated list of file
    patterns.  For example: "*.c,*.h" matches files ending in ".c" and ".h".
       The usual file wildcards can be used.  Here is a summary of the most often
    used ones:
de: Das Argument {file_pattern} kann tatsächlich eine komma-getrennte Liste von
    Datei-Mustern sein.  »*.c,*.h« zum Beispiel trifft Dateien, die auf ».c« oder
    ».h« enden.
       Die gewöhnlichen Datei-Wildcards können benutzt werden.  Hier ist eine
    Zusammenfassung der am häufigsten benutzten:

en: 	*		Match any character any number of times
    	?		Match any character once
    	[abc]		Match the character a, b or c
    	.		Matches a dot
    	a{b,c}		Matches "ab" and "ac"
de: 	*		Trifft jedes Zeichen jede Anzahl von Malen
    	?		Trifft jegliches Zeichen einmal
    	[abc]		Trifft die Zeichen a, b oder c
    	.		Trifft einen Punkt
    	a{b,c}		Triff »ab« und »ac«

en: When the pattern includes a slash (/) Vim will compare directory names.
    Without the slash only the last part of a file name is used.  For example,
    "*.txt" matches "/home/biep/readme.txt".  The pattern "/home/biep/*" would
    also match it.  But "home/foo/*.txt" wouldn't.
       When including a slash, Vim matches the pattern against both the full path
    of the file ("/home/biep/readme.txt") and the relative path (e.g.,
    "biep/readme.txt").
de: Wenn das Muster einen Schrägstrich (/) beinhalten, vergleicht Vim
    Verzeichnisnamen.  Ohne Schrägstrich wird nur der letzte Teil eines
    Dateinamens benutzt.  Zum Beispiel trifft »*.txt« »/home/biep/readme.txt«.
    Das Muster »/home/biep/*« würde es auch treffen.  Aber nicht »/home/foo/*.txt«
       Wenn ein Schrägstrich einbezogen wird, vergleicht Vim das Muster sowohl
    gegen den vollen Datei-Pfad (»/home/biep/readme.txt« als auch den relativen
    (z.B. »biep/readme.txt«).

en: 	Note:
    	When working on a system that uses a backslash as file separator, such
    	as MS-Windows, you still use forward slashes in autocommands.  This
    	makes it easier to write the pattern, since a backslash has a special
    	meaning.  It also makes the autocommands portable.
de: 	Anmerkung:
    	Wenn Sie mit einem System arbeiten, das einen Rückwärtsschrägstrich
    	als Verzeichnistrenner benutzt, so wie MS-Windows, benutzen Sie immer
    	noch Vorwärtsschrägstriche.  Dies macht es einfacher, das Muster zu
    	schreiben, weil ein Rückwärtsschrägstrich eine besondere Bedeutung
    	hat.  Es macht den automatischen Befehl außerdem portabel.

en: DELETING
de: LÖSCHEN

en: To delete an autocommand, use the same command as what it was defined with, but leave out the {command} at the end and use a !.  Example: >
de: Um einen automatischen Befehl zu löschen, benutzen Sie denselben Befehl, mit dem es definiert wurde, aber lassen {command} am Ende aus und benutzen ein »!«.  Beispiel: >

en: This will delete all autocommands for the "FileWritePre" event that use the "*" pattern.
de: Dies löscht alle automatischen Befehle für das Ereignis »FileWritePre«, die das Muster »*« benutzen.

en: LISTING
de: AUFLISTEN

en: To list all the currently defined autocommands, use this: >
de: Um alle aktuell definierten automatischen Befehle aufzulisten, benutzen Sie dies: >

en: The list can be very long, especially when filetype detection is used.  To list only part of the commands, specify the group, event and/or pattern.  For example, to list all BufNewFile autocommands: >
de: Die Liste kann sehr lang sein, besonders wenn Dateityp-Erkennung benutzt wird.  Um nur einen Teil der Befehle aufzulisten, geben Sie die Gruppe, das Ereignis und/oder das Muster an.  Um zum Beispiel alle automatischen Befehle für BufNewFile aufzulisten: >

en: To list all autocommands for the pattern "*.c": >
de: Um alle automatischen Befehle für das Muster »*.c« aufzulisten: >

en: Using "*" for the event will list all the events.  To list all autocommands for the cprograms group: >
de: Das verwenden von »*« für das Ereignis listet alle Ereignisse auf.  Um alle automatischen Befehle für die Gruppe cprograms aufzulisten: >

en: GROUPS
de: GRUPPEN

en: The {group} item, used when defining an autocommand, groups related autocommands
    together.  This can be used to delete all the autocommands in a certain group,
    for example.
       When defining several autocommands for a certain group, use the ":augroup"
    command.  For example, let's define autocommands for C programs: >
de: Das Element {group}, benutzt beim Definieren eines automatischen Befehls,
    gruppiert verwandte automatische Befehle zusammen.  Dies kann zum Beispiel
    benutzt werden, um alle automatischen Befehle in einer gewissen Gruppe zu
    löschen.
       Wenn Sie mehrere automatische Befehle für eine gewisse Gruppe definieren,
    benutzen Sie den Befehl »:augroup«.  Lassen Sie uns zum Beispiel automatische
    Befehle für C-Programme definieren: >

en: This will do the same as: >
de: Dies tut dasselbe wie: >

en: To delete all autocommands in the "cprograms" group: >
de: Um alle automatischen Befehle der Gruppe »cprograms« zu löschen: >

en: NESTING
de: VERSCHACHTELUNG

en: Generally, commands executed as the result of an autocommand event will not trigger any new events.  If you read a file in response to a FileChangedShell event, it will not trigger the autocommands that would set the syntax, for example.  To make the events triggered, add the "nested" argument: >
de: Generell lösen Befehle, die als das Ergebnis eines automatischen Befehls ausgeführt werden, keine neuen Ereignisse aus.  Falls Sie zum Beispiel eine Datei als Antwort auf ein Ereignis FileChangedShell lesen, werden die automatischen Befehle, die die Syntax setzen, nicht ausgelöst.  Um zu erreichen, dass die Ereignisse ausgelöst werden, fügen Sie das Argument »nested« hinzu: >

en: EXECUTING AUTOCOMMANDS
de: AUTOMATISCHE BEFEHLE AUSFÜHREN

en: It is possible to trigger an autocommand by pretending an event has occurred.  This is useful to have one autocommand trigger another one.  Example: >
de: Es ist möglich, einen automatischen Befehl auszulösen, indem man vorgibt, dass sich ein Ereignis ereignet hat.  Dies ist nützlich, um einen automatischen Befehl einen anderen auslösen zu lassen.  Beispiel: >

en: This defines an autocommand that is triggered when a new file has been edited.  The file name must end in ".new".  The ":execute" command uses expression evaluation to form a new command and execute it.  When editing the file "tryout.c.new" the executed command will be: >
de: Dies definiert einen automatischen Befehl, der ausgelöst wird, wenn eine neue Datei editiert wird.  Der Dateiname muss auf ».new« enden.  Der Befehl »:execute« benutzt Ausdrucks-Auswertung, um einen neuen Befehl zu formen und auszuführen.  Wenn die Datei »tryout.c.new« editiert wird, ist der ausgeführte Befehl: >

en: The expand() function takes the "<afile>" argument, which stands for the file name the autocommand was executed for, and takes the root of the file name with ":r".
de: Die Funktion expand() nimmt das Argument »<afile>«, was für den Dateinamen steht, für den der automatische Befehl ausgeführt wurde, und nimmt die Wurzel des Dateinamens mit »:r«.

en: ":doautocmd" executes on the current buffer.  The ":doautoall" command works like "doautocmd" except it executes on all the buffers.
de: »:doautocmd« führt auf dem aktuellen Puffer aus.  Der Befehl »:doautoall« funktioniert wie »doautocmd«, außer dass er auf allen Puffern ausführt.

en: USING NORMAL MODE COMMANDS
de: BEFEHLE DES NORMALEN MODUS BENUTZEN

en: The commands executed by an autocommand are Command-line command.  If you want to use a Normal mode command, the ":normal" command can be used.  Example: >
de: Die Befehle, die von einem automatischen Befehl ausgeführt werden, sind Befehlszeilen-Befehle.  Falls Sie einen Befehl des normalen Modus verwenden wollen, kann der Befehl »:normal« benutzt werden.  Beispiel: >

en: This will make the cursor jump to the last line of *.log files when you start
    to edit it.
       Using the ":normal" command is a bit tricky.  First of all, make sure its
    argument is a complete command, including all the arguments.  When you use "i"
    to go to Insert mode, there must also be a <Esc> to leave Insert mode again.
    If you use a "/" to start a search pattern, there must be a <CR> to execute
    it.
       The ":normal" command uses all the text after it as commands.  Thus there
    can be no | and another command following.  To work around this, put the
    ":normal" command inside an ":execute" command.  This also makes it possible
    to pass unprintable characters in a convenient way.  Example: >
de: Dies lässt den Cursor in die letzte Zeile von *.log-Dateien springen, wenn Sie
    beginnen, eine zu editieren.
       Den Befehl »:normal« zu verwenden ist ein wenig verzwickt.  Zuerst stellen
    Sie sicher, dass sein Argument ein vollständiger Befehl ist, eingeschlossen
    aller Argumente.  Wenn Sie »i« benutzen, um in den Einfüge-Modus zu gehen,
    muss es auch auch ein <Esc> geben, um den Einfüge-Modus zu verlassen.  Falls
    Sie »/« verwenden, um ein Suchmuster zu beginnen, muss es ein <CR> geben, um
    es auszuführen.
       Der Befehl »:normal« benutzt allen Text nach ihm als Befehle.  Also kann es
    kein | geben, dem ein weiterer Befehl folgt.  Um dies zu umgehen, packen Sie
    den Befehl »:normal« in einen »:execute«-Befehl.  Dies macht es auch möglich,
    undruckbare Zeichen auf eine angenehme Weise zu übergeben.  Beispiel: >

en: This also shows the use of a backslash to break a long command into more lines.  This can be used in Vim scripts (not at the command line).
de: Dies zeigt auch den Gebrauch des Rückwärtsschrägstrichs, um einen langen Befehl auf mehrere Zeilen zu verteilen.  Dies kann in Vim-Skripten verwandt werden (nicht auf der Befehlszeile).

en: When you want the autocommand do something complicated, which involves jumping around in the file and then returning to the original position, you may want to restore the view on the file.  See |restore-position| for an example.
de: Wenn Sie wollen, dass der automatische Befehl etwas Kompliziertes macht, was es beinhaltet, in der Datei herumzuspringen und dann an die ursprüngliche Position zurückzukehren, mögen Sie die Ansicht der Datei wiederherstellen wollen.  Siehe |restore-position| für ein Beispiel.

en: IGNORING EVENTS
de: EREIGNISSE IGNORIEREN

en: At times, you will not want to trigger an autocommand.  The 'eventignore' option contains a list of events that will be totally ignored.  For example, the following causes events for entering and leaving a window to be ignored: >
de: Bisweilen wollen Sie nicht, dass ein automatischer Befehl ausgelöst wird.  Die Option 'eventignore' enthält eine List von Ereignissen, die komplett ignoriert werden.  Das folgende zum Beispiel lässt Ereignisse für das Betreten und Verlassen eines Fensters ignorieren: >

en: To ignore all events, use the following command: >
de: Um alle Ereignisse zu ignorieren, benutzen Sie den folgenden Befehl: >

en: To set it back to the normal behavior, make 'eventignore' empty: >
de: Um es zum normalen Verhalten zurück zu setzen, machen Sie 'eventignore' leer: >

en: Next chapter: |usr_41.txt| Write a Vim script
de: Nächstes Kapitel: |usr_41.txt| Ein Vim-Skript schreiben

en: Copyright: see |manual-copyright| vim:tw=78:ts=8:ft=help:norl:
de: Copyright: siehe |manual-copyright| vim:tw=78:ts=8:ft=help:norl:
