vimhelp 7.2 - en to de translation catalogue (431 entries)

en: *usr_41.txt*	For Vim version 7.2.  Last change: 2008 Jun 21
de: *usr_41.txt*	Für Vim version 7.2.  Letzte Änderung: 2008-Jun-21

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

en: 			      Write a Vim script
de: 			      Ein Vim-Skript schreiben

en: The Vim script language is used for the startup vimrc file, syntax files, and many other things.  This chapter explains the items that can be used in a Vim script.  There are a lot of them, thus this is a long chapter.
de: Vims Skriptsprache wird für die Startup-Datei vimrc, Syntax-Dateien und viele andere Dinge verwendet.  Dieses Kapitel erklärt die Elemente, die in einem Vim-Skript benutzt werden können.  Davon gibt es eine Menge, daher ist dies ein langes Kapitel.

en: |41.1|	Introduction |41.2|	Variables |41.3|	Expressions |41.4|	Conditionals |41.5|	Executing an expression |41.6|	Using functions |41.7|	Defining a function |41.8|	Lists and Dictionaries |41.9|	Exceptions |41.10|	Various remarks |41.11|	Writing a plugin |41.12|	Writing a filetype plugin |41.13|	Writing a compiler plugin |41.14|	Writing a plugin that loads quickly |41.15|	Writing library scripts |41.16|	Distributing Vim scripts
de: |41.1|	Einführung
    |41.2|	Variablen
    |41.3|	Ausdrücke
    |41.4|	Bedingungen
    |41.5|	Einen Ausdruck ausführen
    |41.6|	Funktionen benutzen
    |41.7|	Eine Funktion definieren
    |41.8|	Listen und Wörterbücher
    |41.9|	Ausnahmen
    |41.10|	Verschiedene Anmerkungen
    |41.11|	Ein Plugin schreiben
    |41.12|	Ein Dateityp-Plugin schreiben
    |41.13|	Ein Kompiler-Plugin schreiben
    |41.14|	Ein Plugin so schreiben, dass es schnell lädt
    |41.15|	Bibliotheksskripte schreiben
    |41.16|	Vim-Skripte verteilen

en:      Next chapter: |usr_42.txt|  Add new menus
     Previous chapter: |usr_40.txt|  Make new commands
    Table of contents: |usr_toc.txt|
de: Nächstes Kapitel: |usr_42.txt|  Neue Menüs hinzufügen
     Voriges Kapitel: |usr_40.txt|  Neue Befehle machen
    Inhaltsübersicht: |usr_toc.txt|

en: *41.1*	Introduction				*vim-script-intro* *script*
de: *41.1*	Einführung				*vim-script-intro* *script*

en: Your first experience with Vim scripts is the vimrc file.  Vim reads it when
    it starts up and executes the commands.  You can set options to values you
    prefer.  And you can use any colon command in it (commands that start with a
    ":"; these are sometimes referred to as Ex commands or command-line commands).
       Syntax files are also Vim scripts.  As are files that set options for a
    specific file type.  A complicated macro can be defined by a separate Vim
    script file.  You can think of other uses yourself.
de: Ihre erste Erfahrung mit Vim-Skripten ist die Datei vimrc.  Vim liest sie beim
    Start und führt die Befehle aus.  Sie können Optionen auf Werte setzen, die
    Sie bevorzugen.  Und Sie können jeden Doppelpunkt-Befehl in ihr benutzen
    (Befehle, die mit »:« starten, diese werden manchmal Ex-Befehle oder
    Befehlszeilen-Befehle genannt.
       Syntax-Dateien sind ebenfalls Vim-Skripte. So wie Dateien, die für einen
    bestimmten Dateityp Optionen setzen.  Ein kompliziertes Makro kann in einer
    eigenen Vim-Skript-Datei definiert werden.  Sie können sich nun weitere
    Möglichkeiten ausmalen.

en: Let's start with a simple example: >
de: Lassen Sie uns mit einem einfachen Beispiel beginnen: >

en: 	:let i = 1
    	:while i < 5
    	:  echo "count is" i
    	:  let i += 1
    	:endwhile
    <
    	Note:
    	The ":" characters are not really needed here.  You only need to use
    	them when you type a command.  In a Vim script file they can be left
    	out.  We will use them here anyway to make clear these are colon
    	commands and make them stand out from Normal mode commands.
    	Note:
    	You can try out the examples by yanking the lines from the text here
    	and executing them with :@"
de: 	:let i = 1
    	:while i < 5
    	:  echo "Zähler ist" i
    	:  let i += 1
    	:endwhile
    <
    	Anmerkung:
    	Die »:« werden hier nicht wirklich gebraucht.  Sie brauchen sie nur,
    	wenn Sie einen Befehl in Vim tippen.  In einer Vim-Skript-Datei können
    	sie ausgelassen werden.  Wir benutzen Sie hier dennoch, um klar zu
    	machen, dass dies Doppelpunkt-Befehle sind, und um sie sich von den
    	Befehlen des Normalmodus abheben zu lassen.
    	Anmerkung:
    	Sie können die Beispiele ausprobieren, indem Sie die Zeilen von hier
    	in ein Register kopieren und sie mit :@" ausführen.

en: The output of the example code is:
de: Die Ausgabe des Beispielcodes ist:

en: 	count is 1 ~
    	count is 2 ~
    	count is 3 ~
    	count is 4 ~
de: 	Zähler ist 1 ~
    	Zähler ist 2 ~
    	Zähler ist 3 ~
    	Zähler ist 4 ~

en: In the first line the ":let" command assigns a value to a variable.  The generic form is: >
de: In der ersten Zeile verknüpft der Befehl »:let« einen Wert mit einer Variablen.  Die generische Form ist: >

en: 	:let {variable} = {expression}
de: 	:let {variable} = {ausdruck}

en: In this case the variable name is "i" and the expression is a simple value,
    the number one.
       The ":while" command starts a loop.  The generic form is: >
de: In diesem Falle ist der Variablenname »i« und der Ausdruck ist ein einfacher
    Wert, die Zahl eins.
        Der Befehl »:while« beginnt eine Schleife.  Die generische Form ist: >

en: 	:while {condition}
    	:  {statements}
    	:endwhile
de: 	:while {bedingung}
    	:  {anweisungen}
    	:endwhile

en: The statements until the matching ":endwhile" are executed for as long as the
    condition is true.  The condition used here is the expression "i < 5".  This
    is true when the variable i is smaller than five.
    	Note:
    	If you happen to write a while loop that keeps on running, you can
    	interrupt it by pressing CTRL-C (CTRL-Break on MS-Windows).
de: Die Anweisungen bis zum entsprechenden »:endwhile« werden so lange ausgeführt,
    wie die Bedingung wahr ist.  Die hier benutzte Bedingung ist der Ausdruck
    »i < 5«.  Dies ist wahr, wenn die Variable i kleiner als fünf ist.
    	Anmerkung:
    	Falls Sie versehentlich eine While-Schleife schreiben, die nicht
    	abbricht, können Sie sie durch Drücken von CTRL-C (CTRL-Pause unter
    	MS-Windows) unterbrechen.

en: The ":echo" command prints its arguments.  In this case the string "count is" and the value of the variable i.  Since i is one, this will print:
de: Der Befehl »:echo« gibt seine Argumente aus.  In diesem Falle die Zeichenkette »Zähler ist« und den Wert der Variablen i. Weil i eins ist, wird folgendes ausgegeben:

en: 	count is 1 ~
de: 	Zähler ist 1 ~

en: Then there is the ":let i += 1" command.  This does the same thing as ":let i = i + 1".  This adds one to the variable i and assigns the new value to the same variable.
de: Dann kommt der Befehl »:let i += 1«.  Dies macht dasselbe wie »:let i = i +1«.  Dies addiert eins zu der Variablen i und verknüpft den neuen Wert mit derselben Variablen.

en: The example was given to explain the commands, but would you really want to make such a loop it can be written much more compact: >
de: Das Beispiel wurde aufgeführt, um die Befehle zu erläutern, aber wenn Sie wirklich solch eine Schleife bauen wollen, kann dies viel kompakter geschrieben werden: >

en: 	:for i in range(1, 4)
    	:  echo "count is" i
    	:endfor
de: 	:for i in range(1, 4)
    	:  echo "Zähler ist" i
    	:endfor

en: We won't explain how |:for| and |range()| work until later.  Follow the links if you are impatient.
de: Wir erklären |:for| und |range()| zunächst nicht.  Folgen Sie den Verweisen, wenn Sie ungeduldig sind.

en: THREE KINDS OF NUMBERS
de: DREI ARTEN VON ZAHLEN

en: Numbers can be decimal, hexadecimal or octal.  A hexadecimal number starts
    with "0x" or "0X".  For example "0x1f" is decimal 31.  An octal number starts
    with a zero.  "017" is decimal 15.  Careful: don't put a zero before a decimal
    number, it will be interpreted as an octal number!
       The ":echo" command always prints decimal numbers.  Example: >
de: Zahlen können dezimal, hexadezimal oder oktal sein.  Eine hexadezimale Zahl
    beginnt mir »0x« oder »0X«.  »0x1f« ist zum Beispiel dezimal 31.  Eine oktale
    Zahl beginnt mit einer Null.  »017« ist dezimal 15.  Achtung: setzen Sie keine
    Null vor eine dezimale Zahl, sie wird dann als oktale Zahl interprätiert!
       Der Befehl »:echo« gibt immer dezimale Zahlen aus.  Beispiel: >

en: A number is made negative with a minus sign.  This also works for hexadecimal
    and octal numbers.   A minus sign is also used for subtraction.  Compare this
    with the previous example: >
de: Eine Zahl wird mit einem Minus-Zeichen negativ gemacht.  Dies funktioniert
    auch für hexadezimale und oktale Zahlen.  Das Minus-Zeichen wird auch für die
    Substraktion verwandt.  Vergleichen Sie dies mit dem vorigen Beispiel: >

en: White space in an expression is ignored.  However, it's recommended to use it for separating items, to make the expression easier to read.  For example, to avoid the confusion with a negative number above, put a space between the minus sign and the following number: >
de: Whitespace in einem Ausdruck wird ignoriert.  Dennoch empfiehlt es sich, ihn zu benutzen, um Elemente zu trennen, um den Ausdruck leichter lesbar zu machen.  Um zum Beispiel oben die Verwechslung mit einer negativen Zahl zu vermeiden, setzen Sie ein Leerzeichen zwischen das Minus-Zeichen und die darauf folgende Zahl: >

en: *41.2*	Variables
de: *41.2*	Variablen

en: A variable name consists of ASCII letters, digits and the underscore.  It cannot start with a digit.  Valid variable names are:
de: Ein Variablenname besteht aus ASCII-Buchstaben, Ziffern und dem Unterstrich.  Er kann nicht mit einer Ziffer beginnen.  Gültige Variablennamen sind:

en: Invalid names are "foo+bar" and "6var".
       These variables are global.  To see a list of currently defined variables
    use this command: >
de: Ungültige Namen sind »foo+bar« und »6var«.
       Diese Variablen sind global.  Um eine Liste aktuell definierter Variablen
    zu sehen, benutzen Sie diesen Befehl: >

en: You can use global variables everywhere.  This also means that when the variable "count" is used in one script file, it might also be used in another file.  This leads to confusion at least, and real problems at worst.  To avoid this, you can use a variable local to a script file by prepending "s:".  For example, one script contains this code: >
de: Sie können überall globale Variablen verwenden.  Dies bedeutet auch, dass, wenn eine Variable »zaehler« in einer Skript-Datei benutzt wird, sie auch in einer andereren Datei benutzt werden könnte.  Dies führt bestenfalls zu Verwirrung, schlimmstenfalls zu wirklichen Problemen.  Um dies zu vermeiden, können Sie eine Variable lokal zu einem Skript verwenden, indem Sie »s:« voranstellen.  Ein Skript enthält zum Beispiel diesen Code: >

en: Since "s:count" is local to this script, you can be sure that sourcing the "other.vim" script will not change this variable.  If "other.vim" also uses an "s:count" variable, it will be a different copy, local to that script.  More about script-local variables here: |script-variable|.
de: Weil »s:count« lokal zu diesem Skript ist, können Sie sicher sein, dass das Einlesen von »other.vim« diese Variable nicht verändert.  Falls »other.vim« ebenfalls eine Variable »s:count« enthält, ist dies eine andere Einheit, lokal zu diesem Skript.  Mehr über Variablen, die lokal zu einem Skript sind, unter: |script-variable|

en: There are more kinds of variables, see |internal-variables|.  The most often used ones are:
de: Es gibt noch mehr Arten von Variablen, siehe |internal-variables|.  Die am häufigsten gebrauchten sind:

en: 	b:name		variable local to a buffer
    	w:name		variable local to a window
    	g:name		global variable (also in a function)
    	v:name		variable predefined by Vim
de: 	b:name		Variable lokal zu einem Puffer
    	w:name		Variable lokal zu einem Fenster
    	g:name		globale Variable (auch in einer Funktion)
    	v:name		von Vim vordefinierte Variable

en: DELETING VARIABLES
de: VARIABLEN LöSCHEN

en: Variables take up memory and show up in the output of the ":let" command.  To delete a variable use the ":unlet" command.  Example: >
de: Variablen belegen Speicher und erscheinen in der Ausgabe des Befehls »:let«. Um eine Variable zu löschen, benutzen Sie den Befehl »:unlet«.  Beispiel: >

en: This deletes the script-local variable "s:count" to free up the memory it uses.  If you are not sure if the variable exists, and don't want an error message when it doesn't, append !: >
de: Dies löscht die skript-lokale Variable »s:count« um den Speicher freizugeben, den sie belegt.  Wenn Sie nicht sicher sind, ob die Variable existiert und Sie keine Fehlermeldung wollen, wenn sie es nicht tut, hängen Sie »!« an: >

en: When a script finishes, the local variables used there will not be automatically freed.  The next time the script executes, it can still use the old value.  Example: >
de: Wenn ein Skript terminiert, werden die in ihm benutzten lokalen Variablen nicht automatisch freigegeben.  Das nächste Mal, wenn das Skript ausgeführt wird, kann es immernoch den alten Wert benutzen.  Beispiel: >

en: 	:if !exists("s:call_count")
    	:  let s:call_count = 0
    	:endif
    	:let s:call_count = s:call_count + 1
    	:echo "called" s:call_count "times"
de: 	:if !exists("s:aufruf_zaehler")
    	:  let s:aufruf_zaehler = 0
    	:endif
    	:let s:aufruf_zaehler = s:aufruf_zaehler + 1
    	:echo s:aufruf_zaehler "Male aufgerufen"

en: The "exists()" function checks if a variable has already been defined.  Its argument is the name of the variable you want to check.  Not the variable itself! If you would do this: >
de: Die Funktion »exists()« prüft, ob eine Variable bereits definiert wurde.  Ihr Argument ist der Name der Variablen, die man überprüfen will.  Nicht die Variable selbst!  Falls Sie dies tun würden: >

en: 	:if !exists(s:call_count)
de: 	:if !exists(s:aufruf_zaehler)

en: Then the value of s:call_count will be used as the name of the variable that
    exists() checks.  That's not what you want.
       The exclamation mark ! negates a value.  When the value was true, it
    becomes false.  When it was false, it becomes true.  You can read it as "not".
    Thus "if !exists()" can be read as "if not exists()".
       What Vim calls true is anything that is not zero.  Zero is false.
    	Note:
    	Vim automatically converts a string to a number when it is looking for
    	a number.  When using a string that doesn't start with a digit the
    	resulting number is zero.  Thus look out for this: >
    		:if "true"
    <	The "true" will be interpreted as a zero, thus as false!
de: Dann wird der Wert von s:aufruf_zaehler als der Name der Variablen, die
    exists() überprüft, genommen.  Das ist nicht, was Sie wollen.
       Das Ausrufezeichen ! negiert einen Wert.  Wenn der Wert wahr war, wird er
    falsch.  Wenn er falsch war, wird er wahr.  Sie können es als »nicht« lesen.
    Also kann »if !exists()« als »if not exists()« gelesen werden.
       Was Vim als wahr betrachtet, ist alles, was nicht Null ist.  Null ist
    falsch.
    	Anmerkung:
    	Vim konvertiert eine Zeichenkette automatisch zu einer Zahl, wenn er
    	nach einer Zahl sucht.  Bei einer Zeichenkette, die nicht mit einer
    	Ziffer beginnt, ist die resultierende Zahl Null.  Also geben Sie
    	hierauf acht: >
    		:if "true"
    >	Das »true« wird als Null interprätiert, also als falsch!

en: STRING VARIABLES AND CONSTANTS
de: ZEICHENKETTENVARIABLEN UND -KONSTANTEN

en: So far only numbers were used for the variable value.  Strings can be used as
    well.  Numbers and strings are the basic types of variables that Vim supports.
    The type is dynamic, it is set each time when assigning a value to the
    variable with ":let".  More about types in |41.8|.
       To assign a string value to a variable, you need to use a string constant.
    There are two types of these.  First the string in double quotes: >
de: So weit wurden nur Zahlen für den Variablenwert benutzt.  Zeichenketten können
    auch benutzt werden.  Zahlen und Zeichenketten sind die Grundtypen von
    Variablen, die Vim unterstützt.  Der Typ ist dynamisch, er wird jedes Mal
    gesetzt, wenn der Variablen mit »:let« ein Wert zugewiesen wird.  Mehr zu
    Typen in |41.8|.
       Um einer Variablen einen Zeichenkettenwert zuzuweisen, müssen Sie eine
    Zeichenkettenkonstante benutzen.  Davon gibt es zwei Typen.  Zuerst die
    Zeichenkette in doppelten Zitatzeichen: >

en: If you want to include a double quote inside the string, put a backslash in front of it: >
de: Falls Sie ein doppeltes Zitatzeichen in die Zeichenkette einbeziehen wollen, stellen Sie ihm einen Rückwärtsschrägstrich voran: >

en: To avoid the need for a backslash, you can use a string in single quotes: >
de: Um den Rückwärtsschrägstrich zu vermeiden, können Sie eine Zeichenkette in einfachen Zitatzeichen verwenden: >

en: Inside a single-quote string all the characters are as they are.  Only the
    single quote itself is special: you need to use two to get one.  A backslash
    is taken literally, thus you can't use it to change the meaning of the
    character after it.
       In double-quote strings it is possible to use special characters.  Here are
    a few useful ones:
de: In einer Zeichenkette mit einfachen Zitatzeichen sind alle Zeichen wie sie
    sind.  Nur das einzelne Zitatzeichen selbst ist besonders: Sie müssen zwei
    verwenden, um eins zu bekommen.  Ein Rückwärtsschrägstrich wird wörtlich
    genommen, also können Sie ihn nicht benutzen, um die Bedeutung des Zeichens
    danach zu verändern.
       In Zeichenketten mit doppelten Zitatzeichen ist es möglich, besondere
    Zeichen zu verwenden.  Hier sind ein Paar nützliche:

en: 	\t		<Tab>
    	\n		<NL>, line break
    	\r		<CR>, <Enter>
    	\e		<Esc>
    	\b		<BS>, backspace
    	\"		"
    	\\		\, backslash
    	\<Esc>		<Esc>
    	\<C-W>		CTRL-W
de: 	\t		<Tab>
    	\n		<NL>, Zeilenumbruch
    	\r		<CR>, <Enter>
    	\e		<Esc>		\b		<BS>, Backspace
    	\"		"
    	\\		\. Rückwärtsschrägstrich
    	\<Esc>		<Esc>
    	\<C-W>		CTRL-W

en: The last two are just examples.  The  "\<name>" form can be used to include
    the special key "name".
       See |expr-quote| for the full list of special items in a string.
de: Die letzten zwei sind nur Beispiele.  Die Form »\<name>« kann benutzt werden,
    um die Sondertaste »name« einzubeziehen.
       Siehe |expr-quote| für die volle Liste besonderer Elemente in einer
    Zeichenkette.

en: *41.3*	Expressions
de: *41.3*	Ausdrücke

en: Vim has a rich, yet simple way to handle expressions.  You can read the
    definition here: |expression-syntax|.  Here we will show the most common
    items.
       The numbers, strings and variables mentioned above are expressions by
    themselves.  Thus everywhere an expression is expected, you can use a number,
    string or variable.  Other basic items in an expression are:
de: Vim hat eine reichhaltige, aber dennoch einfache Weise, um Ausdrücke zu
    behandeln.  Sie können die Definition hier lesen: |expression-syntax|. Hier
    werden wir die gebräuchlichsten zeigen.
       Die oben erwähnten Zahlen, Zeichenketten und Variablen sind selbst
    Ausdrücke.  Also können Sie überall, wo ein Ausdruck erwartet wird, eine Zahl,
    Zeichenkette oder Variable verwenden.  Andere Grundelemente in einem Ausdruck
    sind:

en: 	$NAME		environment variable
    	&name		option
    	@r		register
de: 	$NAME		Umgebungsvariable
    	&name		Option
    	@r		Register

en: Examples: >
de: Beispiele: >

en: 	:echo "The value of 'tabstop' is" &ts
    	:echo "Your home directory is" $HOME
    	:if @a > 5
de: 	:echo "Der Wert von 'tabstop' ist" &ts
    	:echo "Ihr Heimverzeichnis ist" $HOME
    	:if @a > 5

en: The &name form can be used to save an option value, set it to a new value, do something and restore the old value.  Example: >
de: Die Form &name kann benutzt werden, um den Wert einer Option zwischen zu speichern, sie auf einen neuen Wert zu setzen, etwas zu tun und den alten Wert zu restaurieren.  Beispiel: >

en: 	:let save_ic = &ic
    	:set noic
    	:/The Start/,$delete
    	:let &ic = save_ic
de: 	:let save_ic = &ic
    	:set noic
    	:/Der Beginn/,$delete
    	:let &ic = save_ic

en: This makes sure the "The Start" pattern is used with the 'ignorecase' option off.  Still, it keeps the value that the user had set.  (Another way to do this would be to add "\C" to the pattern, see |/\C|.)
de: Dies stellt sicher, dass das Muster »Der Beginn« mit deaktivierter Option 'ignorecase' benutzt wird.  Jedoch behält es den Wert, den der Benutzer gesetzt hat.  (Eine andere Möglichkeit, dies zu tun, wäre dem Suchmuster »\C« hinzuzufügen, siehe |/\C|.)

en: MATHEMATICS
de: MATHEMATIK

en: It becomes more interesting if we combine these basic items.  Let's start with mathematics on numbers:
de: Es wird interessanter, wenn wir diese Grundelemente kombinieren.  Lassen Sie uns mit Mathematik auf Zahlen beginnen

en: 	a + b		add
    	a - b		subtract
    	a * b		multiply
    	a / b		divide
    	a % b		modulo
de: 	a + b		Addition
    	a - b		Subtraktion
    	a * b		Multiplikation
    	a / b		Division
    	a % b		Modulo

en: The usual precedence is used.  Example: >
de: Die gewöhnliche Präzedenz wird benutzt.  Beispiel: >

en: Grouping is done with braces.  No surprises here.  Example: >
de: Gruppierung mit Klammern.  Keine Überraschungen hier.  Beispiel: >

en: Strings can be concatenated with ".".  Example: >
de: Zeichenketten können mit ».« verkettet werden.  Beispiel: >

en: When the ":echo" command gets multiple arguments, it separates them with a space.  In the example the argument is a single expression, thus no space is inserted.
de: Wenn der Befehl »:echo« mehrere Argumente erhält, trennt er sie mit einem Leerzeichen.  In diesem Beispiel ist das Argument ein einzelner Ausdruck, also wird kein Leerzeichen eingefügt.

en: Borrowed from the C language is the conditional expression:
de: Aus der Sprache C entliehen ist der konditionale Ausdruck:

en: If "a" evaluates to true "b" is used, otherwise "c" is used.  Example: >
de: Falls »a« wahr ergibt, wird »b« verwandt, ansonsten wird »c« benutzt.  Beispiel: >

en: The three parts of the constructs are always evaluated first, thus you could see it work as:
de: Die drei Teile des Konstrukts werden immer zuerst berechnet, also könnten Sie als als das Folgende funktionieren sehen:

en: *41.4*	Conditionals
de: *41.4*	Bedingungen

en: The ":if" commands executes the following statements, until the matching ":endif", only when a condition is met.  The generic form is:
de: Der Befehl »:if« führt die folgenden Anweisungen aus, bis zum übereinstimmenden »:endif«, nur wenn eine Bedingung erfüllt ist.  Die generische Form ist:

en: 	:if {condition}
    	   {statements}
    	:endif
de: 	:if {bedingung}
    	   {anweisungen}
    	:endif

en: Only when the expression {condition} evaluates to true (non-zero) will the
    {statements} be executed.  These must still be valid commands.  If they
    contain garbage, Vim won't be able to find the ":endif".
       You can also use ":else".  The generic form for this is:
de: Nur wenn der Ausdruck {bedingung} wahr (nicht-null) ergibt, werden die
    {anweisungen} ausgeführt.  Dies müssen immer noch gültige Befehle sein.  Falls
    sie Müll enthalten, ist es Vim nicht möglich, das »:endif« zu finden.
       Sie können auch »:else« verwenden.  Die generische Form hierfür ist:

en: 	:if {condition}
    	   {statements}
    	:else
    	   {statements}
    	:endif
de: 	:if {bedingung}
    	   {anweisungen}
    	:else
    	   {anweisungen}
    	:endif

en: The second {statements} is only executed if the first one isn't.
       Finally, there is ":elseif":
de: Der zweite Block {anweisungen} wird nur ausgeführt, wenn der erste nicht wird.
       Schließlich gibt es »:elseif«:

en: 	:if {condition}
    	   {statements}
    	:elseif {condition}
    	   {statements}
    	:endif
de: 	:if {bedingung}
    	   {anweisungen}
    	:elseif {bedingung}
    	   {anweisungen}
    	:endif

en: This works just like using ":else" and then "if", but without the need for an
    extra ":endif".
       A useful example for your vimrc file is checking the 'term' option and
    doing something depending upon its value: >
de: Dies funktioniert genauso, wie »:else« und dann »if« zu verwenden, aber ohne
    ein extra »:endif« zu benutzen.
       Ein nützliches Beispiel für Ihre vimrc ist, die Option 'term' zu prüfen,
    und abhängig von ihrem Wert etwas zu tun: >

en: 	:if &term == "xterm"
    	:  " Do stuff for xterm
    	:elseif &term == "vt100"
    	:  " Do stuff for a vt100 terminal
    	:else
    	:  " Do something for other terminals
    	:endif
de: 	:if &term == "xterm"
    	:  " Mache etwas für xterm
    	:elseif &term == "vt100"
    	:  " Mache etwas für ein VT100-Terminal
    	:else
    	:  " Mache etwas für andere Terminals
    	:endif

en: LOGIC OPERATIONS
de: LOGISCHE OPERATIONEN

en: We already used some of them in the examples.  These are the most often used ones:
de: Wir haben bereits einige in den Beispielen benutzt.  Dies sind die am häufigsten verwandten:

en: 	a == b		equal to
    	a != b		not equal to
    	a >  b		greater than
    	a >= b		greater than or equal to
    	a <  b		less than
    	a <= b		less than or equal to
de: 	a == b		gleich
    	a != b		ungleich
    	a >  b		größer als
    	a >= b		größer als oder gleich
    	a <  b		kleiner als
    	a <= b		kleiner als oder gleich

en: The result is one if the condition is met and zero otherwise.  An example: >
de: Das Ergebnis ist eins, falls die Bedingung erfüllt ist, sonst null.  Ein Beispiel: >

en: 	:if v:version >= 700
    	:  echo "congratulations"
    	:else
    	:  echo "you are using an old version, upgrade!"
    	:endif
de: 	:if v:version >= 700
    	:  echo "Gratulation"
    	:else
    	:  echo "Sie benutzen eine alte Version.  Aktualisieren Sie!"
    	:endif

en: Here "v:version" is a variable defined by Vim, which has the value of the Vim version.  600 is for version 6.0.  Version 6.1 has the value 601.  This is very useful to write a script that works with multiple versions of Vim.  |v:version|
de: Hier ist »v:version« eine von Vim definierte Variable, die den Wert der Vim-Version hat.  600 ist für Version 6.0.  Version 6.1 hat den Wert 601.  Dies ist sehr nützlich beim Schreiben eines Skript, das mit verschiedenen Versionen von Vim funktionieren soll.  |v:version|

en: The logic operators work both for numbers and strings.  When comparing two
    strings, the mathematical difference is used.  This compares byte values,
    which may not be right for some languages.
       When comparing a string with a number, the string is first converted to a
    number.  This is a bit tricky, because when a string doesn't look like a
    number, the number zero is used.  Example: >
de: Die logischen Operatoren funktionieren sowohl für Zahlen wie auch für
    Zeichenketten.  Beim Vergleich zweier Zeichenketten wird der mathematische
    Unterschied benutzt.  Dies vergleicht Byte-Werte, was für manche Sprachen
    eventuell nicht richtig ist.
       Beim Vergleich einer Zeichenkette mit einer Zahl wird die Zeichenkette
    zuerst in eine Zahl verwandelt.  Dies ist ein wenig verzwickt, wenn eine
    Zeichenkette nicht wie eine Zahl aussieht, wird die Zahl Null verwandt.
    Beispiel: >

en: 	:if 0 == "one"
    	:  echo "yes"
    	:endif
de: 	;if 0 == "eins"
    	:  echo "ja"
    	:endif

en: This will echo "yes", because "one" doesn't look like a number, thus it is converted to the number zero.
de: Dies gibt »ja« aus, weil »eins« nicht wie eine Zahl aussieht, es also zur Zahl Null konvertiert wird.

en: For strings there are two more items:
de: Für Zeichenketten gibt es zwei weitere Elemente:

en: 	a =~ b		matches with
    	a !~ b		does not match with
de: 	a =~ b		stimmt mit überein
    	a !~ b		stimmt nicht mit überein

en: The left item "a" is used as a string.  The right item "b" is used as a pattern, like what's used for searching.  Example: >
de: Das linke Element »a« wird als Zeichenkette verwandt.  Das rechte Element »b« wird als Muster benutzt, wie beim Suchen.  Beispiel: >

en: 	:if str =~ " "
    	:  echo "str contains a space"
    	:endif
    	:if str !~ '\.$'
    	:  echo "str does not end in a full stop"
    	:endif
de: 	:if str =~ " "
    	:  echo "str enthält ein Leerzeichen"
    	:endif
    	:if str !~ '\.$'
    	:  echo "str endet nicht mit einem Punkt"
    	:endif

en: Notice the use of a single-quote string for the pattern.  This is useful, because backslashes would need to be doubled in a double-quote string and patterns tend to contain many backslashes.
de: Beachten Sie den Gebrauch der einfach zitierten Zeichenkette.  Dies ist nützlich, weil Rückwärtsschrägstriche in doppelt zitierten Zeichenketten verdoppelt werden müssten, und Muster dazu neigen, viele Rückwärtsschrägstriche zu enthalten.

en: The 'ignorecase' option is used when comparing strings.  When you don't want that, append "#" to match case and "?" to ignore case.  Thus "==?" compares two strings to be equal while ignoring case.  And "!~#" checks if a pattern doesn't match, also checking the case of letters.  For the full table see |expr-==|.
de: Die Option 'ignorecase' wird beim Vergleich von Zeichenketten benutzt.  Wenn Sie dies nicht wollen, hängen Sie »#« an, für Übereinstimmung von Groß-/Kleinschreibung, und »?«, um dies zu ignorieren.  Also vergleicht »==?« zwei Zeichenketten auf Gleichheit, während Groß-/Kleinschreibung ignoriert wird.  Und »!~#« prüft, ob ein Muster nicht passt, auch Groß-/Kleinschreibung überprüfend.  Für die volle Tabelle siehe |expr-==|.

en: MORE LOOPING
de: MEHR ÜBER SCHLEIFEN

en: The ":while" command was already mentioned.  Two more statements can be used in between the ":while" and the ":endwhile":
de: Der Befehl »:while« wurde bereits erwähnt.  Zwei weitere Anweisungen können zwischen dem »:while« und dem »:endwhile« benutzt werden:

en: 	:continue		Jump back to the start of the while loop; the
    				loop continues.
    	:break			Jump forward to the ":endwhile"; the loop is
    				discontinued.
de: 	:continue		Springe zurück zum Beginn der While-Schleife;
    				die Schleife wird fortgesetzt.
    	:break			Springe vorwärts zum »:endwhile«; die Schleife
    				wird abgebrochen.

en: Example: >
de: Beispiel: >

en: 	:while counter < 40
    	:  call do_something()
    	:  if skip_flag
    	:    continue
    	:  endif
    	:  if finished_flag
    	:    break
    	:  endif
    	:  sleep 50m
    	:endwhile
de: 	:while zaehler < 40
    	:  call tue_etwas()
    	:  if flag_ueberspringen
    	:    continue
    	:  endif
    	:  if flag_beendet
    	:    break
    	:  endif
    	:  sleep 50m
    	:endwhile

en: The ":sleep" command makes Vim take a nap.  The "50m" specifies fifty milliseconds.  Another example is ":sleep 4", which sleeps for four seconds.
de: Der Befehl »:sleep« lässt Vim ein Nickerchen machen.  »50m« gibt fünzig Millisekunden an.  Ein weiteres Beispiel ist »:sleep 4«, was für vier Sekunden schläft.

en: Even more looping can be done with the ":for" command, see below in |41.8|.
de: Sogar noch mehr Schleifen können mit dem Befehl »:for« gemacht werden, siehe unten in |41.8|.

en: *41.5*	Executing an expression
de: *41.5*	Einen Ausdruck ausführen

en: So far the commands in the script were executed by Vim directly.  The
    ":execute" command allows executing the result of an expression.  This is a
    very powerful way to build commands and execute them.
       An example is to jump to a tag, which is contained in a variable: >
de: So weit wurden die Befehle in dem Skript von Vim direkt ausgeführt.  Der
    Befehl »:execute« erlaubt das Ausführen des Ergebnisses eines Ausdrucks.  Dies
    ist eine sehr mächtige Möglichkeit, Befehle aufzubauen und sie ausführen zu
    lassen.
       Ein Beispiel ist ein Tag anzuspringen, das in einer Variablen enthalten
    ist: >

en: The "." is used to concatenate the string "tag " with the value of variable "tag_name".  Suppose "tag_name" has the value "get_cmd", then the command that will be executed is: >
de: Der ».« wird verwandt, um die Zeichenkette »tag « mit dem Wert der Variablen »tag_name« zu verketten.  Angenommen, »tag_name« hat den Wert »get_cmd«, dann ist der ausgeführte Befehl: >

en: The ":execute" command can only execute colon commands.  The ":normal" command executes Normal mode commands.  However, its argument is not an expression but the literal command characters.  Example: >
de: Der Befehl »:execute« kann nur Doppelpunkt-Befehle ausführen.  Der Befehl »:normal« führt Befehl des Normalmodus aus.  Jedoch ist sein Argument kein Ausdruck, sondern die wörtlichen Befehlszeichen.  Beispiel: >

en: This jumps to the first line and formats all lines with the "=" operator.
       To make ":normal" work with an expression, combine ":execute" with it.
    Example: >
de: Dies springt in die erste Zeile und formatiert alle Zeilen mit dem Operator
    »=«.
       Damit »:normal« mit einem Ausdruck funktioniert, kombinieren Sie
    »:execute« mit ihm.  Beispiel: >

en: 	:execute "normal " . normal_commands
de: 	:execute "normal " . normal_befehle

en: The variable "normal_commands" must contain the Normal mode commands.
       Make sure that the argument for ":normal" is a complete command.  Otherwise
    Vim will run into the end of the argument and abort the command.  For example,
    if you start Insert mode, you must leave Insert mode as well.  This works: >
de: Die Variable »normal_befehle« muss die Normal-Modus-Befehle enthalten.
       Stellen Sie sicher, dass das Argument für »:normal« ein vollständiger
    Befehl ist.  Ansonsten läuft Vim in das Ende des Arguments und führt den
    Befehl nicht aus.  Falls Sie zum Beispiel den Einfüge-Modus starten, müssen
    Sie auch den Einfüge-Modus verlassen.  Dies funktioniert: >

en: 	:execute "normal Inew text \<Esc>"
de: 	:execute "normal INeuer Text \<Esc>"

en: This inserts "new text " in the current line.  Notice the use of the special key "\<Esc>".  This avoids having to enter a real <Esc> character in your script.
de: Dies fügt »Neuer Text « in der aktuellen Zeile ein.  Beachten Sie den Gebrauch der Sondersequenz »\<Esc>«.  Dies vermeidet, dass sie ein wirkliches <Esc>-Zeichen in Ihr Skript einfügen müssen.

en: If you don't want to execute a string but evaluate it to get its expression value, you can use the eval() function: >
de: Falls Sie eine Zeichenkette nicht ausführen, sondern auswerten möchten, um ihren Ausdruckswert zu bekommen, können Sie die Funktion eval() benutzen: >

en: A "&" character is prepended to "path", thus the argument to eval() is
    "&path".  The result will then be the value of the 'path' option.
       The same thing can be done with: >
    	:exe 'let optval = &' . optname
de: Ein »&«-Zeichen wird »path« vorangestellt, also ist das Argument für eval()
    »&path«.  Das Ergebnis ist dann der Wert der Option 'path'.
       Dasselbe kann mit dem folgenden gemacht werden: >
    	:exe 'let optval = &' . optname

en: *41.6*	Using functions
de: *41.6*	Funktionen benutzen

en: Vim defines many functions and provides a large amount of functionality that way.  A few examples will be given in this section.  You can find the whole list here: |functions|.
de: Vim definiert viele Funktionen und bietet so einen großen Betrag an Funktionalität.  Einige wenige Beispiele werden in diesem Abschnitt gegeben.  Sie können die ganze Liste hier finden: |functions|.

en: A function is called with the ":call" command.  The parameters are passed in between braces, separated by commas.  Example: >
de: Eine Funktion wird mit dem Befehl »:call« aufgerufen.  Die Parameter werden in Klammern übergeben, getrennt durch Kommata.  Beispiel: >

en: This calls the search() function, with arguments "Date: " and "W".  The search() function uses its first argument as a search pattern and the second one as flags.  The "W" flag means the search doesn't wrap around the end of the file.
de: Dies ruft die Funktion search() auf, mit den Argumenten »Date: « und »W«.  Die Funktion search() benutzt ihr erstes Argument als Suchmuster und das zweite als Flags.  Das Kennzeichen »W« bedeutet, dass die Suche am Ende der Datei nicht an ihrem Beginn fortgesetzt werden soll (wrap around).

en: A function can be called in an expression.  Example: >
de: Eine Funktion kann in einem Ausdruck aufgerufen werden.  Beispiel: >

en: 	:let line = getline(".")
    	:let repl = substitute(line, '\a', "*", "g")
    	:call setline(".", repl)
de: 	:let zeile = getline(".")
    	:let ersetzt = substitute(zeile, '\a', "*", "g")
    	:call setline(".", ersetzt)

en: The getline() function obtains a line from the current buffer.  Its argument
    is a specification of the line number.  In this case "." is used, which means
    the line where the cursor is.
       The substitute() function does something similar to the ":substitute"
    command.  The first argument is the string on which to perform the
    substitution.  The second argument is the pattern, the third the replacement
    string.  Finally, the last arguments are the flags.
       The setline() function sets the line, specified by the first argument, to a
    new string, the second argument.  In this example the line under the cursor is
    replaced with the result of the substitute().  Thus the effect of the three
    statements is equal to: >
de: Die Funktion getline() holt eine Zeile aus dem aktuellen Puffer.  Ihr Argument
    ist eine Spezifikation der Zeilennummer.  In diesem Falle wird ».« benutzt,
    was die Zeile meint, wo sich der Cursor befindet.
       Die Funktion substitute() tut etwas ähnliches wie der Befehl »:substitute«.
    Das erste Argument ist die Zeichenkette, auf der die Ersetzung stattfinden
    soll.  Das zweite Argument ist das Muster, das dritte die
    Ersetzungszeichenkette.  Schließlich sind die letzten Argumente die Flags.
       Die Funktion setline() setzt die Zeile, die durch das erste Argument
    spezifiziert wird, auf eine neue Zeichenkette, das zweite Argument.  In diesem
    Beispiel wird die Zeile unter dem Cursor ersetzt durch das Ergebnis von
    substitute().  Also ist der Effekt der drei Anweisungen gleich: >

en: Using the functions becomes more interesting when you do more work before and after the substitute() call.
de: Die Funktionen benutzen wird interessanter, wenn Sie mehr Arbeit vor und nach dem Aufruf von substitute() erledigen.

en: FUNCTIONS						*function-list*
de: FUNKTIONEN						*function-list*

en: There are many functions.  We will mention them here, grouped by what they are used for.  You can find an alphabetical list here: |functions|.  Use CTRL-] on the function name to jump to detailed help on it.
de: Es gibt viele Funktionen.  Wir werden Sie hier erwähnen, gruppiert nach ihrem Verwendungszweck.  Sie können hier eine alphabetische Liste finden: |functions|.  Benutzen Sie CTRL-] auf dem Funktionsnamen, um zu einer detailierten Hilfe zu ihr zu springen.

en: String manipulation:
    	nr2char()		get a character by its ASCII value
    	char2nr()		get ASCII value of a character
    	str2nr()		convert a string to a Number
    	str2float()		convert a string to a Float
    	printf()		format a string according to % items
    	escape()		escape characters in a string with a '\'
    	shellescape()		escape a string for use with a shell command
    	fnameescape()		escape a file name for use with a Vim command
    	tr()			translate characters from one set to another
    	strtrans()		translate a string to make it printable
    	tolower()		turn a string to lowercase
    	toupper()		turn a string to uppercase
    	match()			position where a pattern matches in a string
    	matchend()		position where a pattern match ends in a string
    	matchstr()		match of a pattern in a string
    	matchlist()		like matchstr() and also return submatches
    	stridx()		first index of a short string in a long string
    	strridx()		last index of a short string in a long string
    	strlen()		length of a string
    	substitute()		substitute a pattern match with a string
    	submatch()		get a specific match in a ":substitute"
    	strpart()		get part of a string
    	expand()		expand special keywords
    	iconv()			convert text from one encoding to another
    	byteidx()		byte index of a character in a string
    	repeat()		repeat a string multiple times
    	eval()			evaluate a string expression
de: Zeichenketten-Manipulation:
    	nr2char()		gibt ein Zeichen nach seinem ASCII-Wert
    	char2nr()		gibt den ASCII-Wert eines Zeichens
    	str2nr()		konvertiert eine Zeichenkette in eine Zahl
    	str2float()		konvertiert eine Zeichenkette in eine
    				Gleitpunktzahl
    	printf()		formatiert eine Zeichenkette nach %-Elementen
    	escape()		schützt Zeichen in einer Zeichenkette mit
    				einem »\«
    	shellescape()		schützt eine Zeichenkette zum Gebrauch mit
    				einem Shell-Befehl
    	fnameescape()		schützt einen Dateinamen zum Gebrauch mit
    				einem Vim-Befehl
    	tr()			übersetzt Zeichen von einer Menge in eine
    				andere
    	strtrans()		übersetzt eine Zeichenkette, um sie druckbar
    				zu machen
    	tolower()		konvertiert eine Zeichenkette in
    				Kleinbuchstaben
    	toupper()		konvertiert eine Zeichenkette in
    				Großbuchstaben
    	match()			Position, wo ein Muster in einer Zeichenkette
    				übereinstimmt
    	matchend()		Postion, wo eine Musterübereinstimmung in
    				einer Zeichenkette endet
    	matchstr()		Übereinstimmung eines Musters in einer
    				Zeichenkette
    	matchlist()		wie matchstr(), gibt auch
    				Unterübereinstimmungen zurück
    	stridx()		erster Index einer kurzen in einer langen
    				Zeichenkette
    	strridx()		letzter Index einer kurzen in einer langen
    				Zeichenkette
    	strlen()		Länge einer Zeichenkette
    	substitute()		ersetze eine Musterübereinstimmung durch eine
    				Zeichenkette
    	submatch		liefert eine bestimmte Übereinstimmung in
    				einem »:substitute«
    	strpart()		liefert Teil einer Zeichenkette
    	expand()		expandiert besondere Schlüsselwörter
    	iconv()			konvertiert Text von einer Kodierung
    				in eine andere
    	byteidx()		Byte-Index eines Zeichens in einer Zeichenkette
    	repeat()		wiederholt eine Zeichenkette mehrere Male
    	eval()			wertet einen Zeichenkettenausdruck aus

en: List manipulation:
    	get()			get an item without error for wrong index
    	len()			number of items in a List
    	empty()			check if List is empty
    	insert()		insert an item somewhere in a List
    	add()			append an item to a List
    	extend()		append a List to a List
    	remove()		remove one or more items from a List
    	copy()			make a shallow copy of a List
    	deepcopy()		make a full copy of a List
    	filter()		remove selected items from a List
    	map()			change each List item
    	sort()			sort a List
    	reverse()		reverse the order of a List
    	split()			split a String into a List
    	join()			join List items into a String
    	range()			return a List with a sequence of numbers
    	string()		String representation of a List
    	call()			call a function with List as arguments
    	index()			index of a value in a List
    	max()			maximum value in a List
    	min()			minimum value in a List
    	count()			count number of times a value appears in a List
    	repeat()		repeat a List multiple times
de: Listen-Manipulation:
    	get()			liefert ein Element ohne Fehler für falschen
    				Index
    	len()			Anzahl Elemente in einer Liste
    	empty()			prüft, ob eine Liste leer ist
    	insert()		fügt ein Element irgendwo in einer Liste ein
    	add()			hängt ein Element an eine Liste an
    	extend()		hängt eine Liste an eine Liste an
    	remove()		entfernt ein oder mehrere Elemente
    				aus einer Liste
    	copy()			macht eine oberflächliche Kopie einer Liste
    	deepcopy()		macht eine volle Kopie einer Liste
    	filter()		entfernt ausgewählte Elemente einer Liste
    	map()			ändert jedes Listenelement
    	sort()			sortiert eine Liste
    	reverse()		kehrt die Reihenfolge einer Liste um
    	split()			spaltet eine Zeichenkette in eine Liste
    	join()			fügt Listenelemente zu einer Zeichenkette
    				zusammen
    	range()			gibt eine Liste mit einer Folge von Zahlen
    				zurück
    	string()		Zeichenkettenrepräsentation einer Liste
    	call()			ruft eine Funktion auf mit Liste als Argumente
    	index()			Index eines Werts in einer Liste
    	max()			maximaler Wert in einer Liste
    	min()			minimaler Wert in einer Liste
    	count()			zählt Anzahl, wie oft ein Wert in einer Liste
    				erscheint
    	repeat()		wiederholt eine Liste mehrere Male

en: Dictionary manipulation:
    	get()			get an entry without an error for a wrong key
    	len()			number of entries in a Dictionary
    	has_key()		check whether a key appears in a Dictionary
    	empty()			check if Dictionary is empty
    	remove()		remove an entry from a Dictionary
    	extend()		add entries from one Dictionary to another
    	filter()		remove selected entries from a Dictionary
    	map()			change each Dictionary entry
    	keys()			get List of Dictionary keys
    	values()		get List of Dictionary values
    	items()			get List of Dictionary key-value pairs
    	copy()			make a shallow copy of a Dictionary
    	deepcopy()		make a full copy of a Dictionary
    	string()		String representation of a Dictionary
    	max()			maximum value in a Dictionary
    	min()			minimum value in a Dictionary
    	count()			count number of times a value appears
de: Wörterbuch-Manipulation:
    	get()			liefert einen Eintrag ohne einen Fehler
    				für einen falschen Schlüssel
    	len()			Anzahl von Einträgen in einem Wörterbuch
    	has_key()		prüft, ob ein Schlüssel in einem Wörterbuch
    				erscheint
    	empty()			prüft, ob ein Wörterbuch leer ist
    	remove()		entfernt einen Eintrag aus einem Wörterbuch
    	extend()		kopiert Einträge von einem Wörterbuch
    				in ein anderes
    	filter()		entfernt ausgewählte Einträge
    				aus einem Wörterbuch
    	map()			ändert jeden Wörterbuch-Eintrag
    	keys()			liefert Liste von Wörterbuch-Schlüsseln
    	values()		liefert Liste von Wörterbuch-Werten
    	items()			liefert Liste von
    				Wörterbuch-Schlüssel-Wert-Paaren
    	copy()			macht eine oberflächliche Kopie
    				eines Wörterbuchs
    	deepcopy		macht eine volle Kopie eines Wörterbuchs
    	string()		Zeichenkettenrepräsentation eines Wörterbuchs
    	max()			maximaler Wert in einem Wörterbuch
    	min()			minimaler Wert in einem Wörterbuch
    	count()			Anzahl, wie oft ein Wert erscheint

en: Floating point computation:
    	float2nr()		convert Float to Number
    	abs()			absolute value (also works for Number)
    	round()			round off
    	ceil()			round up
    	floor()			round down
    	trunc()			remove value after decimal point
    	log10()			logarithm to base 10
    	pow()			value of x to the exponent y
    	sqrt()			square root
    	sin()			sine
    	cos()			cosine
    	atan()			arc tangent
de: Gleitpunkt-Berechnung:
    	float2nr()		konvertiert Gleitpunktzahl zu Zahl
    	abs()			Absolut-Wert (funktioniert auch für Zahl)
    	round()			rundet
    	ceil()			rundet auf
    	floor()			rundet ab
    	trunc()			entfernt Wert nach Dezimalpunkt
    	log10()			Logarithmus zur Basis 10
    	pow()			Wert von x hoch y
    	sqrt()			Quadratwurzel
    	sin()			Sinus
    	cos()			Cosinus
    	atan()			Arcustangens

en: Variables:
    	type()			type of a variable
    	islocked()		check if a variable is locked
    	function()		get a Funcref for a function name
    	getbufvar()		get a variable value from a specific buffer
    	setbufvar()		set a variable in a specific buffer
    	getwinvar()		get a variable from specific window
    	gettabwinvar()		get a variable from specific window & tab page
    	setwinvar()		set a variable in a specific window
    	settabwinvar()		set a variable in a specific window & tab page
    	garbagecollect()	possibly free memory
de: Variablen:
    	type()			Typ einer Variablen
    	islocked()		prüft, ob eine Variable gelockt ist
    	function()		liefert eine Funktionsreferenz für einen
    				Funktionsnamen
    	getbufvar()		liefert einen Variablenwert aus einem
    				bestimmten Puffer
    	setbufvar()		setzt eine Variable in einem bestimmten Puffer
    	getwinvar()		liefert eine Variable aus einem bestimmten
    				Fenster
    	gettabwinvar()		liefert eine Variable für bestimmtes Fenster
    				und Reiterseite
    	setwinvar()		setzt eine Variable in einem bestimmten
    				Fenster
    	settabwinvar()		setzt eine Variable für bestimmtes Fenster und
    				Reiterseite
    	garbagecollect()	gibt möglicherweise Speicher frei

en: Cursor and mark position:
    	col()			column number of the cursor or a mark
    	virtcol()		screen column of the cursor or a mark
    	line()			line number of the cursor or mark
    	wincol()		window column number of the cursor
    	winline()		window line number of the cursor
    	cursor()		position the cursor at a line/column
    	getpos()		get position of cursor, mark, etc.
    	setpos()		set position of cursor, mark, etc.
    	byte2line()		get line number at a specific byte count
    	line2byte()		byte count at a specific line
    	diff_filler()		get the number of filler lines above a line
de: Cursor- und Markierungs-Position:
    	col()			Spaltennummer von Cursor oder einer Markierung
    	virtcol()		Bildschirmspalte von Cursor oder einer
    				Markierung
    	line()			Zeilennummer von Cursor oder einer Markierung
    	wincol()		Fensterspaltennummer des Cursors
    	winline()		Fensterzeilennummer des Cursors
    	cursor()		positioniert den Cursor auf einer Zeile/Spalte
    	getpos()		liefert Position von Cursor, Markierung usw.
    	setpos()		setzt Position von Cursor, Markierung usw.
    	byte2line()		liefert Zeilennummer bei einer bestimmten
    				Byte-Anzahl
    	line2byte()		Byte-Anzahl bei einer bestimmten Zeile
    	diff_filler()		liefert die Anzahl von Füllzeilen über einer
    				Zeile

en: Working with text in the current buffer:
    	getline()		get a line or list of lines from the buffer
    	setline()		replace a line in the buffer
    	append()		append line or list of lines in the buffer
    	indent()		indent of a specific line
    	cindent()		indent according to C indenting
    	lispindent()		indent according to Lisp indenting
    	nextnonblank()		find next non-blank line
    	prevnonblank()		find previous non-blank line
    	search()		find a match for a pattern
    	searchpos()		find a match for a pattern
    	searchpair()		find the other end of a start/skip/end
    	searchpairpos()		find the other end of a start/skip/end
    	searchdecl()		search for the declaration of a name
de: Arbeiten mit dem Text im aktuellen Puffer:
    	getline()		liefert eine Zeile oder Liste von Zeilen aus
    				dem aktuellen Puffer
    	setline()		ersetzt eine Zeile im Puffer
    	append()		fügt eine Zeile oder Liste von Zeilen im
    				Puffer an
    	indent()		Einrückung einer bestimmten Zeile
    	cindent()		rückt eine Zeile nach Einrückung für C ein
    	lispindent()		rückt eine Zeile nach Einrückung für Lisp ein
    	nextnonblank()		findet nächste nicht-leere Zeile
    	prevnonblank()		findet vorige nicht-leere Zeile
    	search()		findet eine Übereinstimmung für ein Muster
    	searchpos()		findet eine Übereinstimmung für ein Muster
    	searchpair()		findet das andere Ende eines Start/Skip/End
    	searchpairpos()		findet das andere Ende eines Start/Skip/End
    	searchdecl()		sucht nach der Deklaration eines Namens

en: System functions and manipulation of files:
    	glob()			expand wildcards
    	globpath()		expand wildcards in a number of directories
    	findfile()		find a file in a list of directories
    	finddir()		find a directory in a list of directories
    	resolve()		find out where a shortcut points to
    	fnamemodify()		modify a file name
    	pathshorten()		shorten directory names in a path
    	simplify()		simplify a path without changing its meaning
    	executable()		check if an executable program exists
    	filereadable()		check if a file can be read
    	filewritable()		check if a file can be written to
    	getfperm()		get the permissions of a file
    	getftype()		get the kind of a file
    	isdirectory()		check if a directory exists
    	getfsize()		get the size of a file
    	getcwd()		get the current working directory
    	haslocaldir()		check if current window used |:lcd|
    	tempname()		get the name of a temporary file
    	mkdir()			create a new directory
    	delete()		delete a file
    	rename()		rename a file
    	system()		get the result of a shell command
    	hostname()		name of the system
    	readfile()		read a file into a List of lines
    	writefile()		write a List of lines into a file
de: Systemfunktionen und Manipulation von Dateien:
    	glob()			expandiere Wildcards
    	globpath()		expandiere Wildcards in einer Reihe von
    				Verzeichnissen
    	findfile()		findet eine Datei in einer Liste von
    				Verzeichnissen
    	finddir()		findet ein Verzeichnis in einer Liste von
    				Verzeichnissen
    	resolve()		findet heraus, wohin ein Shortcut zeigt
    	fnamemodify()		modifiziert einen Dateinamen
    	pathshorten()		verkürzt Verzeichnisnamen in einem Pfad
    	simplify()		vereinfacht einen Pfad, ohne seine Bedeutung
    				zu verändern
    	executable()		prüft, ob ein ausführbares Programm existiert
    	filereadable()		prüft, ob eine Datei gelesen werden kann
    	filewritable()		prüft, ob in eine Datei geschrieben werden kann
    	getfperm()		liefert die Zugriffsrechte einer Datei
    	getftype()		liefert die Art einer Datei
    	isdirectory()		prüft, ob ein Verzeichnis existiert
    	getfsize()		liefert die Größe einer Datei
    	getcwd()		liefert das aktuelle Arbeitsverzeichnis
    	haslocaldir()		prüft, ob das aktuelle Fenster |:lcd| benutzt
    				hat
    	tempname()		liefert den Namen einer temporären Datei
    	mkdir()			erzeugt ein neues Verzeichnis
    	delete()		löscht eine Datei
    	rename()		benennt eine Datei um
    	system()		liefert das Ergebnis eines Shell-Befehls
    	hostname()		Rechnername
    	readfile()		lese eine Datei in eine Liste von Zeilen
    	writefile()		schreibe eine Liste von Zeilen in eine Datei

en: Date and Time:
    	getftime()		get last modification time of a file
    	localtime()		get current time in seconds
    	strftime()		convert time to a string
    	reltime()		get the current or elapsed time accurately
    	reltimestr()		convert reltime() result to a string
de: Datum und Zeit:
    	getftime()		liefert Zeit der letzten Modifikation
    				einer Datei
    	localtime()		liefert aktuelle Zeit in Sekunden
    	strftime()		konvertiert Zeit in eine Zeichenkette
    	reltime()		liefert die aktuelle oder vergangene Zeit
    				akkurat
    	reltimestr()		konvertiert Ergebnis von reltime() in eine
    				Zeichenkette

en: Buffers, windows and the argument list:
    	argc()			number of entries in the argument list
    	argidx()		current position in the argument list
    	argv()			get one entry from the argument list
    	bufexists()		check if a buffer exists
    	buflisted()		check if a buffer exists and is listed
    	bufloaded()		check if a buffer exists and is loaded
    	bufname()		get the name of a specific buffer
    	bufnr()			get the buffer number of a specific buffer
    	tabpagebuflist()	return List of buffers in a tab page
    	tabpagenr()		get the number of a tab page
    	tabpagewinnr()		like winnr() for a specified tab page
    	winnr()			get the window number for the current window
    	bufwinnr()		get the window number of a specific buffer
    	winbufnr()		get the buffer number of a specific window
    	getbufline()		get a list of lines from the specified buffer
de: Puffer, Fenster und die Argumentenliste:
    	argc()			Anzahl von Einträgen in der Argumentenliste
    	argidx()		aktuelle Position in der Argumentenliste
    	argv()			liefert einen Eintrag aus der Argumentenliste
    	bufexists()		prüft, ob ein Puffer existiert
    	buflisted()		prüft, ob ein Puffer existiert und gelistet ist
    	bufloaded()		prüft, ob ein Puffer existiert und geladen ist
    	bufname()		liefert den Namen eines bestimmten Puffers
    	bufnr()			liefert die Puffernummer eines bestimmten
    				Puffers
    	tabpagebuflist()	gibt eine Liste der Puffer in einer
    				Reiterseite zurück
    	tabpagenr()		liefert die Nummer einer Reiterseite
    	tabpagewinnr()		wie winnr() für eine bestimmte Reiterseite
    	winnr()			liefert die Fensternummer für das aktuelle
    				Fenster
    	bufwinnr()		liefert die Fensternummer eines bestimmten
    				Puffers
    	winbufnr()		liefert die Puffernummer eines bestimmten
    				Fensters
    	getbufline()		liefert eine Liste von Zeilen aus dem
    				bestimmten Puffer

en: Command line:
    	getcmdline()		get the current command line
    	getcmdpos()		get position of the cursor in the command line
    	setcmdpos()		set position of the cursor in the command line
    	getcmdtype()		return the current command-line type
de: Befehlszeile:
    	getcmdline()		liefert die aktuelle Befehlszeile
    	getcmdpos()		liefert Position des Cursors in der Befehlszeile
    	setcmdpos()		setzt Position des Cursors in der Befehlszeile
    	getcmdtype()		gibt den Typ der aktuellen Befehlszeile zurück

en: Quickfix and location lists:
    	getqflist()		list of quickfix errors
    	setqflist()		modify a quickfix list
    	getloclist()		list of location list items
    	setloclist()		modify a location list
de: Quickfix und Lokationslisten:
    	getqflist()		Liste von Quickfix-Fehlern
    	setqflist()		modifiziere eine Quickfix-Liste
    	getloclist()		Liste von Lokationslisten-Elementen
    	setloclist()		modifiziere eine Lokationsliste

en: Insert mode completion:
    	complete()		set found matches
    	complete_add()		add to found matches
    	complete_check()	check if completion should be aborted
    	pumvisible()		check if the popup menu is displayed
de: Vervollständigung im Einfügemodus:
    	complete()		setzt gefundene Übereinstimmungen
    	complete_add()		fügt zu gefundenen Übereinstimmungen hinzu
    	complete_check()	prüft, ob Vervollständigung abgebrochen werden
    				sollte
    	pumvisible()		prüft, ob das Aufklapp-Menü angezeigt wird

en: Folding:
    	foldclosed()		check for a closed fold at a specific line
    	foldclosedend()		like foldclosed() but return the last line
    	foldlevel()		check for the fold level at a specific line
    	foldtext()		generate the line displayed for a closed fold
    	foldtextresult()	get the text displayed for a closed fold
de: Falten:
    	foldclosed()		prüft auf eine geschlossene Faltung in einer
    				bestimmten Zeile
    	foldclosedend()		wie foldclosed(), aber gibt die letzte Zeile
    				zurück
    	foldlevel()		prüft auf die Faltungsebene in einer
    				bestimmten Zeile
    	foldtext()		erzeugt die für eine geschlossene Faltung
    				angezeigte Zeile
    	foldtextresult()	liefert den für eine geschlossene Faltung
    				angezeigten Text

en: Syntax and highlighting:
    	clearmatches()		clear all matches defined by |matchadd()| and
    				the |:match| commands
    	getmatches()		get all matches defined by |matchadd()| and
    				the |:match| commands
    	hlexists()		check if a highlight group exists
    	hlID()			get ID of a highlight group
    	synID()			get syntax ID at a specific position
    	synIDattr()		get a specific attribute of a syntax ID
    	synIDtrans()		get translated syntax ID
    	diff_hlID()		get highlight ID for diff mode at a position
    	matchadd()		define a pattern to highlight (a "match")
    	matcharg()		get info about |:match| arguments
    	matchdelete()		delete a match defined by |matchadd()| or a
    				|:match| command
    	setmatches()		restore a list of matches saved by
    				|getmatches()|
de: Syntax und Hervorhebung:
    	clearmatches()		löscht alle von |matchadd()| und den |:match|-
    				Befehlen definierte Übereinstimmungen
    	getmatches()		holt alle von |matchadd()| und den |:match|-
    				Befehlen definierten Übereinstimmungen
    	hlexists()		prüft, ob eine Hervorhebungsgruppe existiert
    	hlID()			liefert ID einer Hervorhebungsgruppe
    	synID()			liefert Syntax-ID an einer bestimmten Position
    	synIDattr()		liefert ein bestimmtes Attribut einer Syntax-ID
    	synIDtrans()		liefert übersetzte Syntax-ID
    	diff_hlID()		liefert Hervorhebungs-ID für den Diff-Modus
    				an einer Position
    	matcharg()		liefert Informationen über Argumente
    				von |:match|
    	matchdelete()		löscht eine von |matchadd()| oder den |:match|-
    				Befehlen definierte Übereinstimmungen
    	setmatches()		stellt eine von |getmatches()| gespeicherte
    				Liste von Übereinstimmungen wieder her

en: Spelling:
    	spellbadword()		locate badly spelled word at or after cursor
    	spellsuggest()		return suggested spelling corrections
    	soundfold()		return the sound-a-like equivalent of a word
de: Rechtschreibkontrolle:
    	spellbadword()		lokalisiert falsch geschriebenes Wort am
    				oder nach dem Cursor
    	spellsuggest()		liefert vorgeschlagene Schreibungskorrekturen
    				zurück
    	soundfold()		liefert die ähnlich klingende Entsprechung
    				eines Wortes zurück

en: History:
    	histadd()		add an item to a history
    	histdel()		delete an item from a history
    	histget()		get an item from a history
    	histnr()		get highest index of a history list
de: Verläufe:
    	histadd()		fügt ein Element einem Verlauf hinzu
    	histdel()		löscht ein Element aus einem Verlauf
    	histget()		liefert ein Element aus einem Verlauf
    	histnr()		liefert den höchsten Index einer Verlaufsliste

en: Interactive:
    	browse()		put up a file requester
    	browsedir()		put up a directory requester
    	confirm()		let the user make a choice
    	getchar()		get a character from the user
    	getcharmod()		get modifiers for the last typed character
    	feedkeys()		put characters in the typeahead queue
    	input()			get a line from the user
    	inputlist()		let the user pick an entry from a list
    	inputsecret()		get a line from the user without showing it
    	inputdialog()		get a line from the user in a dialog
    	inputsave()		save and clear typeahead
    	inputrestore()		restore typeahead
de: Interaktiv:
    	browse()		stellt eine Datei-Anfrage zur Verfügung
    	browsedir()		stellt eine Verzeichnis-Anfrage zur Verfügung
    	confirm()		lässt den Benutzer eine Auswahl machen
    	getchar()		holt ein Zeichen vom Benutzer
    	getcharmod()		liefert die Modifikatoren für das letzte
    				eingegebene Zeichen
    	feedkeys()		stellt Zeichen in die Vorauseingabe-Schleife
    	input()			holt eine Zeile vom Benutzer
    	inputlist()		lässt den Benutzer einen Eintrag aus einer
    				Liste auswählen
    	inputsecret()		holt eine Zeile vom Benutzer ohne sie
    				anzuzeigen
    	inputdialog()		holt eine Zeile vom Benutzer in einem Dialog
    	inputsave()		speichert und löscht Vorauseingabe
    	inputrestore()		stellt die Vorauseingabe wieder her

en: GUI:
    	getfontname()		get name of current font being used
    	getwinposx()		X position of the GUI Vim window
    	getwinposy()		Y position of the GUI Vim window
de: GUI:
    	getfontname()		liefert den Namen des aktuell benutzten
    				Schriftstils
    	getwinposx()		X-Position des GUI-Vim-Fensters
    	getwinposy()		Y-Position des GUI-Vim-Fensters

en: Vim server:
    	serverlist()		return the list of server names
    	remote_send()		send command characters to a Vim server
    	remote_expr()		evaluate an expression in a Vim server
    	server2client()		send a reply to a client of a Vim server
    	remote_peek()		check if there is a reply from a Vim server
    	remote_read()		read a reply from a Vim server
    	foreground()		move the Vim window to the foreground
    	remote_foreground()	move the Vim server window to the foreground
de: Vim-Server:
    	serverlist()		gibt eine Liste von Server-Namen zurück
    	remote_send()		sendet Befehlszeichen an einen Vim-Server
    	remote_expr()		wertet einen Ausdruck in einem Vim-Server aus
    	server2client()		sendet eine Antwort an einen Client eines
    				Vim-Servers
    	remote_peek()		prüft, ob es eine Antwort von einem Vim-Server
    				gibt
    	remote_read()		liest eine Antwort von einem Vim-Server
    	foreground()		bewegt das Vim-Fenster in den Vordergrund
    	remote_foreground()	bewegt das Fenster des Vim-Servers in den
    				Vordergrund

en: Window size and position:
    	winheight()		get height of a specific window
    	winwidth()		get width of a specific window
    	winrestcmd()		return command to restore window sizes
    	winsaveview()		get view of current window
    	winrestview()		restore saved view of current window
de: Fenster-Größe und -Position:
    	winheight()		liefert die Höhe eines bestimmten Fensters
    	winwidth()		liefert die Breite eines bestimmten Fensters
    	winrestcmd()		gibt Befehl zurück, um Fenstergrößen
    				wiederherzustellen
    	winsaveview()		liefert Ansicht des aktuellen Fensters
    	winrestview()		stellt gespeicherte Ansicht des aktuellen
    				Fensters wieder her

en: Various:
    	mode()			get current editing mode
    	visualmode()		last visual mode used
    	hasmapto()		check if a mapping exists
    	mapcheck()		check if a matching mapping exists
    	maparg()		get rhs of a mapping
    	exists()		check if a variable, function, etc. exists
    	has()			check if a feature is supported in Vim
    	changenr()		return number of most recent change
    	cscope_connection()	check if a cscope connection exists
    	did_filetype()		check if a FileType autocommand was used
    	eventhandler()		check if invoked by an event handler
    	getpid()		get process ID of Vim
de: Verschiedenes:
    	mode()			liefert aktuelle Editiermodus
    	visualmode()		der letzte benutzte visuelle Modus
    	hasmapto()		prüft, ob eine Belegung existiert
    	mapcheck()		prüft, ob eine passende Belegung existiert
    	maparg()		liefert die rechte Seite einer Belegung
    	exists()		prüft, ob eine Variable, Funktion usw.
    				existiert
    	has()			prüft, ob ein Feature von Vim unterstützt wird
    	changenr()		gibt die Nummer der letzten Änderung zurück
    	cscope_connection()	prüft, ob eine CScope-Anbindung existiert
    	did_filetype()		prüft, ob ein automatischer Befehl eines
    				Dateityps benutzt wurde
    	eventhandler()		prüft, ob von einem Ereignis-Behandler
    				aufgerufen wurde
    	getpid()		liefert Prozess-ID von Vim

en: 	libcall()		call a function in an external library
    	libcallnr()		idem, returning a number
de: 	libcall()		ruft eine Funktion in einer externen
    				Bibliothek auf
    	libcallnr()		ebenso, gibt eine Zahl zurück

en: 	getreg()		get contents of a register
    	getregtype()		get type of a register
    	setreg()		set contents and type of a register
de: 	getreg()		liefert Inhalt eines Registers
    	getregtype()		liefert Typ eines Registers
    	setreg()		setzt Inhalt und Typ eines Registers

en: 	taglist()		get list of matching tags
    	tagfiles()		get a list of tags files
de: 	taglist()		liefert Liste passender Tags
    	tagfiles()		liefert Liste von Tag-Dateien

en: *41.7*	Defining a function
de: *41.7*	Eine Funktion definieren

en: Vim enables you to define your own functions.  The basic function declaration begins as follows: >
de: Vim ermöglicht es Ihnen, eigene Funktionen zu definieren.  Die grundlegende Funktions-Deklaration beginnt wie folgt: >

en: 	:function {name}({var1}, {var2}, ...)
    	:  {body}
    	:endfunction
    <
    	Note:
    	Function names must begin with a capital letter.
de: 	:function {name}({var1}, {var2}, ...)
    	:  {body}
    	:endfunction
    <
    	Anmerkung:
    	Funktions-Namen müssen mit einem Großbuchstaben beginnen.

en: Let's define a short function to return the smaller of two numbers.  It starts with this line: >
de: Lassen Sie uns eine kurze Funktion definieren, die die kleinere von zwei Zahlen zurückgibt.  Sie beginnt mit dieser Zeile: >

en: This tells Vim that the function is named "Min" and it takes two arguments:
    "num1" and "num2".
       The first thing you need to do is to check to see which number is smaller:
       >
    	:  if a:num1 < a:num2
de: Dies sagt Vim, dass die Funktion »Min« heißt und zwei Argumente nimmt, »num1«
    und »num2«.
       Als erstes müssen wir überprüfen, welche Zahl kleiner ist:
       >
    	:  if a:num1 < a:num2

en: The special prefix "a:" tells Vim that the variable is a function argument.  Let's assign the variable "smaller" the value of the smallest number: >
de: Das besondere Präfix »a:« sagt Vim, dass die Variable ein Funktions-Argument ist.  Weisen wir nun der Variablen »smaller« den Wert der kleineren Zahl zu: >

en: The variable "smaller" is a local variable.  Variables used inside a function are local unless prefixed by something like "g:", "a:", or "s:".
de: Die Variable »smaller« ist eine lokale Variable.  In einer Funktion benutzte Variablen sind lokal, solange ihnen nicht etwas wie »g:«, »a:« oder »s:« vorangestellt wird.

en: 	Note:
    	To access a global variable from inside a function you must prepend
    	"g:" to it.  Thus "g:today" inside a function is used for the global
    	variable "today", and "today" is another variable, local to the
    	function.
de: 	Anmerkung:
    	Um innerhalb einer Funktion auf eine globale Variable zuzugreifen,
    	müssen Sie ihr »g:« voranstellen.  Also wird innerhalb einer Funktion
    	»g:today« für die globale Funktion »today« verwandt, und ein einfaches
    	»today« ist eine andere Variable, die zur Funktion lokal ist.

en: You now use the ":return" statement to return the smallest number to the user.  Finally, you end the function: >
de: Nun benutzen wir die Anweisung »:return« um die kleinere Zahl an den Aufrufer zurückzugeben.  Die Funktion endet schließlich: >

en: The complete function definition is as follows: >
de: Die vollständige Funktions-Definition ist wie folgt: >

en: For people who like short functions, this does the same thing: >
de: Für Leute, die kurze Funktionen mögen, leistet dies dasselbe: >

en: A user defined function is called in exactly the same way as a built-in function.  Only the name is different.  The Min function can be used like this: >
de: Eine benutzerdefinierte Funktion wird genauso aufgerufen, wie eine eingebaute.  Nur der Name ist verschieden.  Die Funktion Min kann so benutzt werden: >

en: Only now will the function be executed and the lines be interpreted by Vim.  If there are mistakes, like using an undefined variable or function, you will now get an error message.  When defining the function these errors are not detected.
de: Erst jetzt wird die Funktion ausgeführt, und die Zeilen werden von Vim interpretiert.  Falls es Fehler gibt, wie das Nutzen einer undefinierten Variablen oder Funktion, erhalten Sie nun eine Fehlermeldung.  Beim Definieren der Funktion werden diese Fehler nicht erkannt.

en: When a function reaches ":endfunction" or ":return" is used without an argument, the function returns zero.
de: Wenn eine Funktion »:endfunction« erreicht, oder »:return« wird ohne Argument benutzt, gibt die Funktion Null zurück.

en: To redefine a function that already exists, use the ! for the ":function" command: >
de: Um eine bereits existierende Funktion erneut zu definieren, benutzen Sie »:function« mit dem !-Modifikator: >

en: USING A RANGE
de: EINEN BEREICH BENUTZEN

en: The ":call" command can be given a line range.  This can have one of two
    meanings.  When a function has been defined with the "range" keyword, it will
    take care of the line range itself.
      The function will be passed the variables "a:firstline" and "a:lastline".
    These will have the line numbers from the range the function was called with.
    Example: >
de: Dem Befehl »:call« kann ein Zeilenbereich gegeben werden.  Dies kann eine von
    zwei Bedeutungen haben.  Wenn eine Funktion mit dem Schlüsselwort »range«
    definiert wurde, kümmert sie sich selbst um den Zeilenbereich.
      Der Funktion werden die Variablen »a:firstline« und »a:lastline« übergeben.
    Diese haben die Zeilennummern des Bereiches, mit dem die Funktion aufgerufen
    wurde.  Beispiel: >

en: 	:function Count_words() range
    	:  let lnum = a:firstline
    	:  let n = 0
    	:  while lnum <= a:lastline
    	:    let n = n + len(split(getline(lnum)))
    	:    let lnum = lnum + 1
    	:  endwhile
    	:  echo "found " . n . " words"
    	:endfunction
de: 	:function Count_words() range
    	:  let lnum = a:firstline
    	:  let n = 0
    	:  while lnum <= a:lastline
    	:    let n = n + Wordcount(getline(lnum))
    	:    let lnum = lnum + 1
    	:  endwhile
    	:  echo "found " . n . " words"
    	:endfunction

en: You can call this function with: >
de: Sie können diese Funktion aufrufen mit: >

en: It will be executed once and echo the number of words.
       The other way to use a line range is by defining a function without the
    "range" keyword.  The function will be called once for every line in the
    range, with the cursor in that line.  Example: >
de: Sie wird einmal ausgeführt und gibt die Anzahl an Worten aus.
       Die andere Möglichkeit einen Zeilenbereich zu benutzen ist, eine Funktion
    ohne das Schlüsselwort »range« zu definieren.  Die Funktion wird einmal für
    jede Zeile in dem Bereich aufgerufen, mit dem Cursor in dieser Zeile.
    Beispiel: >

en: If you call this function with: >
de: Falls Sie diese Funktion aufrufen mit: >

en: The function will be called six times.
de: wird die Funktion sechs Mal aufgerufen.

en: VARIABLE NUMBER OF ARGUMENTS
de: VARIABLE ANZAHL VON ARGUMENTEN

en: Vim enables you to define functions that have a variable number of arguments.  The following command, for instance, defines a function that must have 1 argument (start) and can have up to 20 additional arguments: >
de: Vim ermöglicht Ihnen, Funktionen zu definieren, die eine variable Anzahl von Argumenten haben.  Der folgende Befehl zum Beispiel definiert eine Funktion, die ein Argument haben muss (start), und die bis zu 20 zusätzliche Argumente haben kann: >

en: The variable "a:1" contains the first optional argument, "a:2" the second, and
    so on.  The variable "a:0" contains the number of extra arguments.
       For example: >
de: Die Variable »a:1« enthält das erste optionale Argument, »a:2« das zweite und
    so weiter.  Die Variable »a:0« enthält die Anzahl von zusätzlichen Argumenten
       Zum Beispiel: >

en: This uses the ":echohl" command to specify the highlighting used for the following ":echo" command.  ":echohl None" stops it again.  The ":echon" command works like ":echo", but doesn't output a line break.
de: Dies benutzt den Befehl »:echohl« um die für den nächsten »:echo«-Befehl benutzte Hervorhebung anzugeben.  »:echohl None« deaktiviert dies.  Der Befehl »:echon« funktioniert wie »:echo«, gibt aber keinen Zeilenumbruch aus.

en: You can also use the a:000 variable, it is a List of all the "..." arguments.  See |a:000|.
de: Sie können auch die Variable a:000 benutzen.  Dies ist eine Liste aller optionalen Argumente.  Siehe |a:000|.

en: LISTING FUNCTIONS
de: FUNKTIONEN AUFLISTEN

en: The ":function" command lists the names and arguments of all user-defined functions: >
de: Der Befehl »:function« listet die Namen und Argumente aller benutzerdefinierten Funktionen auf: >

en: To see what a function does, use its name as an argument for ":function": >
de: Um zu sehen, was eine Funktion tut, benutzen Sie ihren Namen als Argument für »:function«: >

en: DEBUGGING
de: FEHLERSUCHE

en: The line number is useful for when you get an error message or when debugging.
    See |debug-scripts| about debugging mode.
       You can also set the 'verbose' option to 12 or higher to see all function
    calls.  Set it to 15 or higher to see every executed line.
de: Die Zeilennummer ist nützlich, wenn Sie eine Fehlermeldung erhalten, oder bei
    der Fehlersuche.  Siehe |debug-scripts| für den Fehlersuche-Modus.
       Sie können auch die Option 'verbose' auf 12 oder höher setzen, um alle
    Funktionsaufrufe zu sehen.  Setzen Sie sie auf 15 oder höher um jede
    ausgeführte Zeile zu sehen.

en: DELETING A FUNCTION
de: EINE FUNKTION LÖSCHEN

en: To delete the Show() function: >
de: Um die Funktion Show() zu löschen: >

en: You get an error when the function doesn't exist.
de: Sie erhalten eine Fehlermeldung, wenn die Funktion nicht existiert.

en: FUNCTION REFERENCES
de: FUNKTIONSREFERENZEN

en: Sometimes it can be useful to have a variable point to one function or another.  You can do it with the function() function.  It turns the name of a function into a reference: >
de: Manchmal kann es nützlich sein, eine Variable auf die eine oder andere Funktion zeigen zu lassen.  Dies können Sie mit der Funktion function() machen.  Sie verwandelt den Namen einer Funktion in eine Referenz: >

en: Note that the name of a variable that holds a function reference must start
    with a capital.  Otherwise it could be confused with the name of a builtin
    function.
       The way to invoke a function that a variable refers to is with the call()
    function.  Its first argument is the function reference, the second argument
    is a List with arguments.
de: Beachten Sie, dass der Name einer Variablen, die eine Funktionsreferenz
    enthält, mit einem Großbuchstaben beginnen muss.  Andernfalls könnte er mit
    dem Namen einer eingebauten Funktion verwechselt werden.
       Der Weg, eine Funktion aufzurufen, die eine Variable referenziert, ist es,
    die Funktion call() zu benutzen.  Ihr erstes Argument ist die
    Funktionsreferenz, das zweite Argument ist eine Liste von Argumenten.

en: Function references are most useful in combination with a Dictionary, as is explained in the next section.
de: Funktionsreferenzen sind am nützlichsten in Kombination mit einem Wörterbuch, was im nächsten Abschnitt erklärt wird.

en: *41.8*	Lists and Dictionaries
de: *41.8*	Listen und Wörterbücher

en: So far we have used the basic types String and Number.  Vim also supports two composite types: List and Dictionary.
de: Bis jetzt haben wir die Basistypen String (Zeichenkette) und Number (Zahl) benutzt.  Vim unterstützt auch zwei zusammengesetzte Typen: Liste und Dictionary (Wörterbuch).

en: A List is an ordered sequence of things.  The things can be any kind of value, thus you can make a List of numbers, a List of Lists and even a List of mixed items.  To create a List with three strings: >
de: Eine Liste ist eine geordnete Folge von Dinge.  Die Dinge können jeglicher Art von Wert sein, also können Sie eine Liste von Zahlen machen, eine Liste von Listen, und sogar eine Liste von gemischten Elementen.  Um eine Liste mit drei Zeichenketten zu erzeugen: >

en: The List items are enclosed in square brackets and separated by commas.  To create an empty List: >
de: Die Listenelemente sind in eckige Klammern eingeschlossen und durch Kommata getrennt.  Um eine leere Liste zu erzeugen: >

en: You can add items to a List with the add() function: >
de: Mit der Funktion add() können Sie einer Liste Elemente hinzufügen: >

en: List concatenation is done with +: >
de: Listen-Konkatenation wird mit + erledigt: >

en: Or, if you want to extend a List directly: >
de: Oder falls Sie eine Liste direkt erweitern wollen: >

en: Notice that using add() will have a different effect: >
de: Beachten Sie, dass das Benutzen von add() einen anderen Effekt hat: >

en: The second argument of add() is added as a single item.
de: Das zweite Argument von add() wird als einzelnes Element hinzugefügt.

en: FOR LOOP
de: FOR-SCHLEIFE

en: One of the nice things you can do with a List is iterate over it: >
de: Eines der netten Dinge, die Sie mit einer Liste machen können, ist über sie zu iterieren: >

en: This will loop over each element in List "alist", assigning the value to variable "n".  The generic form of a for loop is: >
de: Dies läuft über jedes Element in der Liste »alist«, wobei es den Wert der Variablen »n« zuweist.  Die generische Form einer For-Schleife ist: >

en: To loop a certain number of times you need a List of a specific length.  The range() function creates one for you: >
de: Um über eine bestimmte Anzahl von Malen zu laufen, brauchen Sie eine Liste einer bestimmten Länge.  Die Funktion range() erzeugt einem eine: >

en: Notice that the first item of the List that range() produces is zero, thus the
    last item is one less than the length of the list.
       You can also specify the maximum value, the stride and even go backwards: >
de: Beachten Sie, dass das erste Element der Liste, die range() produziert, Null
    ist, also ist das letzte Element eins weniger als die Länge der Liste.
       Sie können auch den Maximalwert angeben, den Inkrement, und sogar rückwärts
    laufen: >

en: A more useful example, looping over lines in the buffer: >
de: Ein nützlicheres Beispiel, das über Zeilen im Puffer läuft: >

en: This looks into lines 1 to 20 (inclusive) and echoes any date found in there.
de: Dies schaut sich Zeilen 1 bis 20 (einschließlich) an, und gibt jedes dort gefundene Datum aus.

en: DICTIONARIES
de: WÖRTERBÜCHER

en: A Dictionary stores key-value pairs.  You can quickly lookup a value if you know the key.  A Dictionary is created with curly braces: >
de: Ein Wörterbuch speichert Schlüssel-Wert-Paare.  Man kann schnell einen Wert nachschlagen, wenn man den Schlüssel kennt.  Ein Wörterbuch wird mit geschwungenen Klammern erzeugt: >

en: Now you can lookup words by putting the key in square brackets: >
de: Nun kann man Wörter nachschlagen, indem man den Schlüssel in eckige Klammern setzt: >

en: The generic form for defining a Dictionary is: >
de: Die generische Form für das Definieren eines Wörterbuchs ist: >

en: An empty Dictionary is one without any keys: >
de: Ein leeres Wörterbuch ist eines ohne Schlüssel: >

en: The possibilities with Dictionaries are numerous.  There are various functions for them as well.  For example, you can obtain a list of the keys and loop over them: >
de: Die Möglichkeiten mit Wörterbüchern sind zahlreich.  Ebenso gibt es für sie verschiedene Funktionen.  Zum Beispiel kann man eine Liste der Schlüssel beziehen und sie durchlaufen: >

en: You will notice the keys are not ordered.  You can sort the list to get a specific order: >
de: Sie werden bemerken, dass die Schlüssel nicht geordnet sind.  Man kann die Liste sortieren, um eine bestimmte Ordnung zu erhalten: >

en: But you can never get back the order in which items are defined.  For that you need to use a List, it stores items in an ordered sequence.
de: Aber man kann nie die Reihenfolge zurückbekommen, in der die Elemente definiert wurden.  Dafür muss man eine Liste benutzen, sie speichert Elemente in einer geordneten Reihenfolge.

en: DICTIONARY FUNCTIONS
de: WÖRTERBUCHFUNKTIONEN

en: The items in a Dictionary can normally be obtained with an index in square brackets: >
de: Die Elemente in einem Wörterbuch können normalerweise mit einem Index in eckigen Klammern bezogen werden: >

en: A method that does the same, but without so many punctuation characters: >
de: Eine Methode, die dasselbe tut, aber ohne so viele Zeichen: >

en: This only works for a key that is made of ASCII letters, digits and the underscore.  You can also assign a new value this way: >
de: Dies funktioniert nur für einen Schlüssel, der aus ASCII-Buchstaben, Ziffern und dem Unterstrich besteht.  Auf diese Weise kann man auch einen neuen Wert zuweisen: >

en: And now for something special: you can directly define a function and store a reference to it in the dictionary: >
de: Und nun zu etwas Besonderem: man kann direkt eine Funktion definieren und eine Referenz auf diese in dem Wörterbuch speichern: >

en: Let's first try it out: >
de: Probieren wir dies zunächst einmal aus: >

en: The first special thing you notice is the "dict" at the end of the ":function"
    line.  This marks the function as being used from a Dictionary.  The "self"
    local variable will then refer to that Dictionary.
       Now let's break up the complicated return command: >
de: Das erste Besondere, das Sie bemerken, ist das »dict« am Ende der Zeile
    mit
    »:function«.  Dies markiert die Funktion als aus einem Wörterbuch zu benutzen.
    Die Variable »self« referenziert dann dieses Wörterbuch.
       Schauen wir uns den komplizierten Rückgabebefehl nun Stück für Stück an: >

en: The split() function takes a string, chops it into white separated words and returns a list with these words.  Thus in the example it returns: >
de: Die Funktion split() nimmt eine Zeichenkette, schneidet sie in leerzeichen-getrennte Wörter, und gibt eine Liste mit diesen Wörtern zurück.  Im Beispiel also: >

en: This list is the first argument to the map() function.  This will go through the list, evaluating its second argument with "v:val" set to the value of each item.  This is a shortcut to using a for loop.  This command: >
de: Diese Liste ist das erste Argument an die Funktion map().  Diese geht durch die Liste, und wertet dabei ihr zweite Argument mit »v:val« auf den Wert jedes Elements gesetzt.  Dies ist eine Abkürzung zum Benutzen einer For-Schleife.  Dieser Befehl: >

en: Is equivalent to: >
de: ist gleichbedeutend mit: >

en: The get() function checks if a key is present in a Dictionary.  If it is, then the value is retrieved.  If it isn't, then the default value is returned, in the example it's '???'.  This is a convenient way to handle situations where a key may not be present and you don't want an error message.
de: Die Funktion get() prüft, ob ein Schlüssel in einem Wörterbuch vorhanden ist.  Falls er es ist, wird der Wert zurückgegeben.  Falls nicht, wird ein Standardwert zurückgegeben, im Beispiel '???'.  Dies ist eine bequeme Art Situationen zu behandeln, in denen ein Schlüssel möglicherweise nicht vorhanden ist und man keine Fehlermeldung möchte.

en: The join() function does the opposite of split(): it joins together a list of
    words, putting a space in between.
      This combination of split(), map() and join() is a nice way to filter a line
    of words in a very compact way.
de: Die Funktion join() tut das Gegenteil von split(): sie fügt eine Liste von
    Wörtern zusammen, wobei sie ein Leerzeichen zwischen sie setzt.
      Diese Kombination von split(), map() und join() ist eine schöne Möglichkeit,
    eine Zeile von Wörtern auf eine sehr kompakte Weise zu filtern.

en: OBJECT ORIENTED PROGRAMMING
de: OBJEKT-ORIENTIERTE PROGRAMMIERUNG

en: Now that you can put both values and functions in a Dictionary, you can
    actually use a Dictionary like an object.
       Above we used a Dictionary for translating Dutch to English.  We might want
    to do the same for other languages.  Let's first make an object (aka
    Dictionary) that has the translate function, but no words to translate: >
de: Jetzt, da Sie sowohl Werte wie Funktionen in ein Wörterbuch stecken können,
    können Sie ein Wörterbuch tatsächlich wie ein Objekt benutzen.
       Oben haben wir ein Wörterbuch benutzt, um Holländisch in Englisch zu
    übersetzen.  Wir könnten dasselbe für andere Sprachen tun wollen.  Machen wir
    zunächst ein Objekt (aka Wörterbuch), das die Übersetzungsfunktion hat, aber
    keine Wörter zum Übersetzen: >

en: It's slightly different from the function above, using 'self.words' to lookup word translations.  But we don't have a self.words.  Thus you could call this an abstract class.
de: Es ist ein wenig verschieden von der Funktion oben, indem wir 'self.words' benutzen, um Wort-Übersetzungen nachzuschlagen.  Aber wir haben keine self.words.  Also könnte man dies eine abstrakte Klasse nennen.

en: Now we can instantiate a Dutch translation object: >
de: Nun können wir ein Übersetzungsobjekt für Holländisch instanziieren: >

en: And a German translator: >
de: Und einen Übersetzer für Deutsch: >

en: You see that the copy() function is used to make a copy of the "transdict" Dictionary and then the copy is changed to add the words.  The original remains the same, of course.
de: Sie sehen, dass die Funktion copy() benutzt wird, um eine Kopie des Wörterbuchs »transdict« zu machen, und dann diese Kopie verändert wird, um die Worte aufzunehmen.  Das Original bleibt natürlich dasselbe.

en: Now you can go one step further, and use your preferred translator: >
de: Nun kann man einen Schritt weiter gehen, und den bevorzugten Übersetzer verwenden: >

en: Here "trans" refers to one of the two objects (Dictionaries).  No copy is made.  More about List and Dictionary identity can be found at |list-identity| and |dict-identity|.
de: Hier referenziert »trans« eines der beiden Objekte (Wörterbücher).  Es wird keine Kopie gemacht.  Mehr über Listen- und Wörterbuch-Identität kann unter |list-identity| und |dict-identity| gefunden werden.

en: Now you might use a language that isn't supported.  You can overrule the translate() function to do nothing: >
de: Nun könnte man eine Sprache benutzen, die nicht unterstützt wird.  Man kann die Funktion translate() überstimmen, nichts zu machen: >

en: Notice that a ! was used to overwrite the existing function reference.  Now use "uk2uk" when no recognized language is found: >
de: Beachten Sie, dass ein ! benutzt wurde, um die bestehende Funktionsreferenz zu überschreiben.  Nun benutze »uk2uk«, falls keine erkannte Sprache gefunden wird: >

en: For further reading see |Lists| and |Dictionaries|.
de: Zum Weiterlesen siehe |Lists| und |Dictionaries|.

en: *41.9*	Exceptions
de: *41.9*	Ausnahmen

en: Let's start with an example: >
de: Beginnen wir mit einem Beispiel: >

en: The ":read" command will fail if the file does not exist.  Instead of generating an error message, this code catches the error and gives the user a nice message instead.
de: Der Befehl »:read« scheitert, falls die Datei nicht existiert.  Statt eine Fehlermeldung zu generieren, fängt dieser Code den Fehler auf und gibt dem Benutzer stattdessen eine nette Meldung.

en: For the commands in between ":try" and ":endtry" errors are turned into exceptions.  An exception is a string.  In the case of an error the string contains the error message.  And every error message has a number.  In this case, the error we catch contains "E484:".  This number is guaranteed to stay the same (the text may change, e.g., it may be translated).
de: Für die Befehle zwischen »:try« und »:endtry« werden Fehler in Ausnahmen verwandelt.  Eine Ausnahme ist eine Zeichenkette.  Im Falle eines Fehlers enthält die Zeichenkette die Fehlernummer.  Und jede Fehlermeldung hat eine Nummer.  In diesem Fall enthält der Fehler, den wir auffangen, »E484:«.  Diese Nummer bleibt garantiert dieselbe (der Text kann sich ändern, z.B. übersetzt werden).

en: When the ":read" command causes another error, the pattern "E484:" will not match in it.  Thus this exception will not be caught and result in the usual error message.
de: Wenn der Befehl »:read« einen anderen Fehler verursacht, passt das Muster »E484:« nicht.  Also wird diese Ausnahme nicht aufgefangen und resultiert in der üblichen Fehlermeldung.

en: You might be tempted to do this: >
de: Sie sind vielleicht versucht, dies zu tun: >

en: This means all errors are caught.  But then you will not see errors that are useful, such as "E21: Cannot make changes, 'modifiable' is off".
de: Dies bedeutet, dass alle Fehler aufgefangen werden.  Dann aber sehen Sie keine nützlichen Fehler, so wie »E21: Kann keine Änderungen machen, 'modifiable' ist aus«.

en: Another useful mechanism is the ":finally" command: >
de: Ein weiterer nützlicher Mechanismus ist der Befehl »:finally«: >

en: This filters the lines from the cursor until the end of the file through the "filter" command, which takes a file name argument.  No matter if the filtering works, something goes wrong in between ":try" and ":finally" or the user cancels the filtering by pressing CTRL-C, the "call delete(tmp)" is always executed.  This makes sure you don't leave the temporary file behind.
de: Dies filtert die Zeilen vom Cursor bis zum Dateiende durch das Programm »filter«, das einen Dateinamen als Argument nimmt.  Egal, ob das Filtern funktioniert, etwas geht zwischen »:try« und »:finally« schief, oder der Benutzer bricht das Filtern ab, indem er CTRL-C drückt, »call delete(tmp)« wird jederzeit ausgeführt.  Dies stellt sicher, dass man nicht die temporäre Datei zurücklässt.

en: More information about exception handling can be found in the reference manual: |exception-handling|.
de: Weiter Informationen über Ausnahme-Behandlung können im Referenzhandbuch gefunden werden: |exception-handling|.

en: *41.10*	Various remarks
de: *41.10*	Verschiedene Anmerkungen

en: Here is a summary of items that apply to Vim scripts.  They are also mentioned elsewhere, but form a nice checklist.
de: Hier ist eine Sammlung von Elementen, die auf Vim-Skripte zutreffen.  Sie werden auch anderswo erwähnt, aber formen eine nette Prüfliste.

en: The end-of-line character depends on the system.  For Unix a single <NL> character is used.  For MS-DOS, Windows, OS/2 and the like, <CR><LF> is used.  This is important when using mappings that end in a <CR>.  See |:source_crnl|.
de: Das Zeichen für das Zeilenende hängt vom System ab.  Unix benutzt ein einzelnes <NL>-Zeichen.  Unter MS-DOS, Windows, OS/2 und so wird <CR><LF> benutzt.  Dies ist wichtig, wenn Belegungen verwandt werden, die in einem <CR> enden.  Siehe |:source_crnl|.

en: Blank lines are allowed and ignored.
de: Leere Zeilen sind erlaubt und werden ignoriert.

en: Leading whitespace characters (blanks and TABs) are always ignored.  The whitespaces between parameters (e.g. between the 'set' and the 'cpoptions' in the example below) are reduced to one blank character and plays the role of a separator, the whitespaces after the last (visible) character may or may not be ignored depending on the situation, see below.
de: Führende Leerzeichen und Tabulatoren werden immer ignoriert.  Der Whitespace zwischen Parametern (z.B zwischen dem 'set' und dem 'cpoptions' im Beispiel unten) wird reduziert auf ein Leerzeichen und spielt die Rolle eines Trenners, der Whitespace nach dem letzten (sichtbaren) Zeichen kann situationsabhängig ignoriert werden oder auch nicht, siehe unten.

en: For a ":set" command involving the "=" (equal) sign, such as in: >
de: Für einen »:set«-Befehl, der das Zeichen »=« (gleich) enthält, so wie in: >

en: the whitespace immediately before the "=" sign is ignored.  But there can be no whitespace after the "=" sign!
de: wird der Whitespace unmittelbar vor dem Zeichen »=« ignoriert.  Aber es darf kein Whitespace nach dem »=«-Zeichen sein!

en: To include a whitespace character in the value of an option, it must be escaped by a "\" (backslash)  as in the following example: >
de: Um ein Whitespace-Zeichen im Wert einer Option zu verwenden, muss es durch einen »\« (Backslash) geschützt werden, wie in dem folgenden Beispiel: >

en: The same example written as >
de: Dasselbe Bespiel geschrieben als >

en: will issue an error, because it is interpreted as: >
de: resultiert in einem Fehler, weil es interpretiert wird als: >

en: COMMENTS
de: KOMMENTARE

en: The character " (the double quote mark) starts a comment.  Everything after and including this character until the end-of-line is considered a comment and is ignored, except for commands that don't consider comments, as shown in examples below.  A comment can start on any character position on the line.
de: Das Zeichen " (das doppelte Anführungszeichen) leitet einen Kommentar ein.  Alles nach und einschließlich dieses Zeichens bis zum Zeilenende wird als Kommentar betrachtet und ignoriert, außer bei Befehlen, die keine Kommentare beachten, wie in den Beispielen unten gezeigt.  Ein Kommentar kann an jeder Zeichen-Position auf der Zeile beginnen.

en: There is a little "catch" with comments for some commands.  Examples: >
de: Bei einigen Befehlen gibt es »Fallen« mit Kommentaren.  Beispiele: >

en: The abbreviation 'dev' will be expanded to 'development     " shorthand'.  The
    mapping of <F3> will actually be the whole line after the 'o# ....' including
    the '" insert include'.  The "execute" command will give an error.  The "!"
    command will send everything after it to the shell, causing an error for an
    unmatched '"' character.
       There can be no comment after ":map", ":abbreviate", ":execute" and "!"
    commands (there are a few more commands with this restriction).  For the
    ":map", ":abbreviate" and ":execute" commands there is a trick: >
de: Die Abkürzung 'dev' wird expandiert zu 'development     " shorthand'.  Die
    Belegung von <F3> ist tatsächlich die ganze Zeile nach dem 'o# ....',
    einschließlich dem '" insert include'.  Der »execute«-Befehl ergibt einen
    Fehler.  Der »!«-Befehl schickt alles nach ihm an die Shell, was einen Fehler
    wegen eines unbalancierten '"'-Zeichens verursacht.
       Nach den Befehlen »:map«, »:abbreviate«, »:execute« und »!« kann kein
    Kommentar stehen (es gibt ein paar Befehle mehr mit dieser Einschränkung).
    Für die Befehle »:map«, »:abbreviate« und »:execute« gibt es einen Trick: >

en: With the '|' character the command is separated from the next one.  And that
    next command is only a comment.  For the last command you need to do two
    things: |:execute| and use '|': >
    	:exe '!ls *.c'			|" list C files
de: Mit dem Zeichen '|' wird ein Befehl vom nächsten getrennt.  Und dieses nächste
    Zeichen ist nur ein Kommentar.  Für den letzten Befehl müssen Sie zwei Dinge
    machen: |:execute| und '|' benutzen: >
    
    	:exe '!ls *.c'			|" list C files

en: Notice that there is no white space before the '|' in the abbreviation and mapping.  For these commands, any character until the end-of-line or '|' is included.  As a consequence of this behavior, you don't always see that trailing whitespace is included: >
de: Man beachte, das hier kein Leerzeichen vor dem '|' in der Abkürzung und der Belegung ist.  Bei diesen Befehlen wird jedes Zeichen bis zum Zeilenende oder dem '|' einbezogen.  Als Konsequenz dieses Verhaltens sieht man nicht immer, das nachstehende Leerzeichen einbezogen werden: >

en: To spot these problems, you can set the 'list' option when editing vimrc files.
de: Um diese Probleme zu erkennen, können Sie die Option 'list' setzen, wenn Sie vimrc-Dateien editieren.

en: For Unix there is one special way to comment a line, that allows making a Vim
    script executable: >
    	#!/usr/bin/env vim -S
    	echo "this is a Vim script"
    	quit
de: Für Unix gibt es eine besondere Möglichkeit, eine Zeile zu kommentieren, die
    es erlaubt, ein Vim-Skript ausführbar zu machen: >
    
    	#!/usr/bin/env vim -S
    	echo "this is a Vim script"
    	quit

en: The "#" command by itself lists a line with the line number.  Adding an exclamation mark changes it into doing nothing, so that you can add the shell command to execute the rest of the file. |:#!| |-S|
de: Der Befehl »#« selbst listet eine Zeile mit der Zeilennummer.  Das Hinzufügen eines Ausrufezeichen lässt ihn nichts machen, so dass Sie den Shell-Befehl hinzufügen können, um den Rest der Datei auszuführen. |:#!| |-S|

en: PITFALLS
de: FALLEN

en: Even bigger problem arises in the following example: >
de: Ein noch größeres Problem ensteht im folgenden Beispiel: >

en: Here the unmap command will not work, because it tries to unmap ",ab ".  This does not exist as a mapped sequence.  An error will be issued, which is very hard to identify, because the ending whitespace character in ":unmap ,ab " is not visible.
de: Hier funktioniert der unmap-Befehl nich, weil er versucht »,ab « freizugeben.  Dies existiert nicht als Belegungsfolge.  Ein Fehler wird ausgegeben, der sehr schwer zu identifizieren ist, weil das nachstehende Leerzeichen in »:unmap ,ab « nicht sichtbar ist.

en: And this is the same as what happens when one uses a comment after an 'unmap' command: >
de: Und es ist dasselbe wie wenn man einen Kommentar nach einem »unmap«-Befehl benutzt: >

en: Here the comment part will be ignored.  However, Vim will try to unmap
    ',ab     ', which does not exist.  Rewrite it as: >
de: Hier wird der Teil, der Kommentar, ist ignoriert.  Vim versucht dennoch
    »,ab     «, freizugeben, was nicht existiert.  Wir schreiben es um als: >

en: RESTORING THE VIEW
de: DIE ANSICHT WIEDERHERSTELLEN

en: Sometimes you want to make a change and go back to where cursor was.
    Restoring the relative position would also be nice, so that the same line
    appears at the top of the window.
       This example yanks the current line, puts it above the first line in the
    file and then restores the view: >
de: Manchmal will man eine Änderung machen und dahin zurück gehen, wo der Cursor
    war.  Die relative Position wiederherstellen wäre auch nett, so dass dieselbe
    Zeile die oberste im Fenster ist.
       Dieses Beispiel kopiert die aktuelle Zeile, setzt sie über die erste Zeile
    der Datei, und stellt dann die Ansicht wieder her: >

en: What this does: >
    	ma"aYHmbgg"aP`bzt`a
    <	ma			set mark a at cursor position
    	  "aY			yank current line into register a
    	     Hmb		go to top line in window and set mark b there
    		gg		go to first line in file
    		  "aP		put the yanked line above it
    		     `b		go back to top line in display
    		       zt	position the text in the window as before
    			 `a	go back to saved cursor position
de: Was dies tut: >
    	ma"aYHmbgg"aP`bzt`a
    <	ma			setze Markierung a bei Cursor-Position
    	  "aY			kopiere aktuelle Zeile in Register a
    	     Hmb		gehe zur obersten Zeile im Fenster und setze
    				dort Markierung b
    		gg		gehe zur ersten Zeile der Datei
    		  "aP		setze kopierte Zeile über sie
    		     `b		gehe zurück zur obersten Zeile der Anzeige
    		       zt	positioniere den Text im Fenster wie vorher
    			 `a	gehe zurück zur gespeicherten Cursor-Position

en: PACKAGING
de: PAKETIERUNG

en: To avoid your function names to interfere with functions that you get from
    others, use this scheme:
    - Prepend a unique string before each function name.  I often use an
      abbreviation.  For example, "OW_" is used for the option window functions.
    - Put the definition of your functions together in a file.  Set a global
      variable to indicate that the functions have been loaded.  When sourcing the
      file again, first unload the functions.
    Example: >
de: Um zu vermeiden, dass Ihre Funktionsnamen Funktionen beeinflussen, die Sie von
    anderen erhalten, benutzen Sie dieses Schema:
    
    - Stellen Sie jedem Funktionsnamen eine einzigartige Zeichenkette voran.  Ich
      benutze oft eine Abkürzung.  Zum Beispiel wird »OW_« für Funktionen des
    Optionsfensters verwandt.
    
    - Packen Sie die Definitionen Ihrer Funktionen in eine Datei.  Setzen Sie eine
      globale Variable, die anzeigt, dass die Funktionen geladen wurden.  Wenn die
      Datei erneut eingelesen wird, geben Sie erst die Funktionen frei.
    
    Beispiel: >

en: 	" This is the XXX package
de: 	" Dies ist das Paket XXX

en: *41.11*	Writing a plugin				*write-plugin*
de: *41.11*	Ein Plugin schreiben				*write-plugin*

en: You can write a Vim script in such a way that many people can use it.  This is called a plugin.  Vim users can drop your script in their plugin directory and use its features right away |add-plugin|.
de: Sie können ein Vim-Skript so schreiben, dass viele Leute es benutzen können.  Dies nennt sich Plugin.  Vim-Benutzer können Ihr Skript in ihr Plugin-Verzeichnis legen und seine Features auf der Stelle nutzen |add-plugin|.

en: There are actually two types of plugins:
de: Tatsächlich gibt es zwei Typen von Plugins:

en:   global plugins: For all types of files.
    filetype plugins: Only for files of a specific type.
de:  globale Plugins: Für alle Typen von Dateien.
    Dateityp-Plugins: Nur für Dateien eines bestimmten Typs.

en: In this section the first type is explained.  Most items are also relevant for writing filetype plugins.  The specifics for filetype plugins are in the next section |write-filetype-plugin|.
de: In diesem Abschnitt wird der erste Typ erklärt.  Die meisten Elemente sind auch relevant für das Schreiben von Dateityp-Plugins.  Die Spezifika für Dateityp-Plugins folgen im nächsten Abschnitt |write-filetype-plugin|.

en: First of all you must choose a name for your plugin.  The features provided by the plugin should be clear from its name.  And it should be unlikely that someone else writes a plugin with the same name but which does something different.  And please limit the name to 8 characters, to avoid problems on old Windows systems.
de: Zuallererst müssen Sie einen Namen für Ihr Plugin wählen.  Die Features, die von dem Plugin bereitgestellt werden werden, sollten anhand seines Namens klar sein.  Und es sollte unwahrscheinlich sein, dass jemand anderes ein Plugin mit demselben Namen schreibt, das etwas anderes tut.  Und bitte begrenzen Sie den Namen auf acht Zeichen, um Probleme auf alten Windows-Systemen zu vermeiden.

en: A script that corrects typing mistakes could be called "typecorr.vim".  We will use it here as an example.
de: Ein Skript, welches Tipp-Fehler korrigiert, könnte »typecorr.vim« genannt werden.  Wir benutzen es hier als Beispiel.

en: For the plugin to work for everybody, it should follow a few guidelines.  This will be explained step-by-step.  The complete example plugin is at the end.
de: Damit das Plugin für jeden funktioniert, sollte es einigen wenigen Richtlinien folgen.  Diese werden Schritt-für-Schritt erklärt.  Das komplette Beispiel-Plugin steht am Ende.

en: BODY
de: KÖRPER

en: Let's start with the body of the plugin, the lines that do the actual work: >
de: Lassen Sie uns mit dem Körper des Plugins beginnen, den Zeilen, die tatsächlich die Arbeit erledigen: >

en: The actual list should be much longer, of course.
de: Die tatsächliche Liste sollte selbstverständlich viel länger sein.

en: The line numbers have only been added to explain a few things, don't put them in your plugin file!
de: Die Zeilennummern wurden nur hinzugefügt, um ein Paar Dinge zu erläutern, übernehmen Sie sie nicht in Ihre Plugin-Datei!

en: HEADER
de: KOPF

en: You will probably add new corrections to the plugin and soon have several versions laying around.  And when distributing this file, people will want to know who wrote this wonderful plugin and where they can send remarks.  Therefore, put a header at the top of your plugin: >
de: Sie werden dem Plugin vermutlich neue Korrekturen hinzufügen, und bald haben Sie mehrere Versionen herumliegen.  Und wenn Sie die Datei verteilen, werden die Leute wissen wollen, wer dieses wundervolle Plugin schrieb und wohin sie Anmerkungen schicken können.  Deshalb stellen Sie Kopfzeilen an den Beginn Ihres Plugins: >

en: About copyright and licensing: Since plugins are very useful and it's hardly worth restricting their distribution, please consider making your plugin either public domain or use the Vim |license|.  A short note about this near the top of the plugin should be sufficient.  Example: >
de: Über Copyright und Lizensierung: Da Plugins sehr nützlich sind, und es kaum wert ist, ihre Verteilung zu begrenzen, erwägen Sie bitte, Ihr Plugin entweder in die Public-Domain oder unter die Vim-Lizenz |license| zu stellen.  Eine kurze Zeile hierüber nahe des Beginn des Plugins sollte ausreichend sein.  Beispiel: >

en: LINE CONTINUATION, AVOIDING SIDE EFFECTS		*use-cpo-save*
de: ZEILENFORTSETZUNG, SEITENEFFEKTE VERMEIDEN		*use-cpo-save*

en: In line 18 above, the line-continuation mechanism is used |line-continuation|.  Users with 'compatible' set will run into trouble here, they will get an error message.  We can't just reset 'compatible', because that has a lot of side effects.  To avoid this, we will set the 'cpoptions' option to its Vim default value and restore it later.  That will allow the use of line-continuation and make the script work for most people.  It is done like this: >
de: Oben in Zeile 18 wird der Mechanismus der Zeilen-Fortsetzung benutzt |line-continuation|.  Benutzer, bei denen 'compatible' gesetzt ist, werden hier Probleme, eine Fehlermeldung bekommen.  Wir können nicht einfach 'compatible' neu setzen, weil dies viele Seiteneffekte hat.  Um dies zu vermeiden, setzen wir die Option 'cpoptions' auf ihren Vim-Standardwert und stellen sie später wieder her.  Das erlaubt die Benutzung von Zeilen-Fortsetzung und lässt das Skript für die meisten Leute funktionieren.  Es wird so gemacht: >

en: We first store the old value of 'cpoptions' in the s:save_cpo variable.  At the end of the plugin this value is restored.
de: Wir speichern zunächst den alten Wert von 'cpoptions' in der Variablen s:save_cpo.  Am Ende des Plugins wird dieser Wert wiederhergestellt.

en: Notice that a script-local variable is used |s:var|.  A global variable could already be in use for something else.  Always use script-local variables for things that are only used in the script.
de: Beachten Sie, dass eine skript-lokale Variable benutzt wird |s:var|.  Eine globale Variable könnte bereits für etwas anderes in Gebrauch sein.  Benutzen Sie immer skript-lokale Variablen für Dinge, die nur in dem Skript benutzt werden.

en: NOT LOADING
de: NICHT LADEN

en: It's possible that a user doesn't always want to load this plugin.  Or the system administrator has dropped it in the system-wide plugin directory, but a user has his own plugin he wants to use.  Then the user must have a chance to disable loading this specific plugin.  This will make it possible: >
de: Es ist möglich, dass ein Nutzer nicht immer dieses Plugin laden möchte.  Oder der System-Administrator hat es in das system-weite Plugin-Verzeichnis gelegt, aber ein Nutzer hat sein eigenes Plugin, das er nutzen möchte.  Dann muss der Nutzer eine Möglichkeit haben, das Laden dieses bestimmten Plugins zu deaktivieren.  Dies macht es möglich: >

en: This also avoids that when the script is loaded twice it would cause error messages for redefining functions and cause trouble for autocommands that are added twice.
de: Dies vermeidet es auch, dass wenn das Skript zweimal geladen wird, dass es Fehlermeldungen für das Neudefinieren von Funktionen und Schwierigkeiten bei automatischen Befehlen, die zweimal hinzugefügt werden, verursacht.

en: MAPPING
de: BELEGUNGEN

en: Now let's make the plugin more interesting: We will add a mapping that adds a correction for the word under the cursor.  We could just pick a key sequence for this mapping, but the user might already use it for something else.  To allow the user to define which keys a mapping in a plugin uses, the <Leader> item can be used: >
de: Nun lassen Sie uns das Plugin interessanter machen: Wir fügen eine Belegung hinzu, die eine Korrektur für das Wort unter dem Cursor hinzufügt.  Um dem Nutzer zu erlauben, zu definieren, welche Tasten eine Belegung in einem Plugin benutzt, kann das Element <Leader> benutzt werden: >

en: The "<Plug>TypecorrAdd" thing will do the work, more about that further on.
de: Das »<Plug>TypecorrAdd« macht die Arbeit, mehr darüber weiter unten.

en: The user can set the "mapleader" variable to the key sequence that he wants this mapping to start with.  Thus if the user has done: >
de: Der Nutzer kann die Variable »mapleader« auf die Tastenfolge setzen, mit der er diese Belegung starten lassen möchte.  Falls der Nutzer also dies macht: >

en: the mapping will define "_a".  If the user didn't do this, the default value will be used, which is a backslash.  Then a map for "\a" will be defined.
de: definiert die Belegung »_a«.  Falls der Nutzer dies nicht tat, wird der Standardwert benutzt, was ein Backslash ist.  Dann wird eine Belegung für »\a« definiert.

en: Note that <unique> is used, this will cause an error message if the mapping already happened to exist. |:map-<unique>|
de: Beachten Sie, dass <unique> benutzt wird, dies verursacht eine Fehlermeldung, falls die Belegung der Tastenfolge bereits existiert. |:map-<unique>|

en: But what if the user wants to define his own key sequence? We can allow that with this mechanism: >
de: Aber was, falls der Nutzer seine eigene Tastenfolge definieren möchte? Wir können dies mit folgendem Mechanismus erlauben: >

en: This checks if a mapping to "<Plug>TypecorrAdd" already exists, and only defines the mapping from "<Leader>a" if it doesn't.  The user then has a chance of putting this in his vimrc file: >
de: Dies prüft, ob eine Belegung von »<Plug>TypecorrAdd« bereits existiert, und definiert die Belegung von »<Leader>a« nur dann, falls nicht.  Der Nutzer hat nun die Möglichkeit, dies in seine vimrc zu packen: >

en: Then the mapped key sequence will be ",c" instead of "_a" or "\a".
de: Dann ist die belegte Tastenfolge »,c« statt »_a« oder »\a«.

en: PIECES
de: STÜCKE

en: If a script gets longer, you often want to break up the work in pieces.  You can use functions or mappings for this.  But you don't want these functions and mappings to interfere with the ones from other scripts.  For example, you could define a function Add(), but another script could try to define the same function.  To avoid this, we define the function local to the script by prepending it with "s:".
de: Wenn ein Skript länger wird, möchte man oft die Arbeit in Portionen aufteilen.  Man kann hierfür Funktionen oder Belegungen benutzen.  Aber man will nicht, dass diese Funktionen oder Belegungen andere Skripte beeinflussen.  Man könnte zum Beispiel eine Funktion Add() definieren, aber ein anderes Skript könnte versuchen, dieselbe Funktion zu definieren.  Um dies zu vermeiden, definieren wir die Funktion lokal zum Skript, indem wir ihr »s:« voranstellen.

en: We will define a function that adds a new typing correction: >
de: Wir definieren eine Funktion, die eine neue Tipp-Korrektur hinzufügt: >

en: Now we can call the function s:Add() from within this script.  If another script also defines s:Add(), it will be local to that script and can only be called from the script it was defined in.  There can also be a global Add()  function (without the "s:"), which is again another function.
de: Jetzt können wir innerhalb des Skripts die Funktion s:Add() aufrufen.  Falls ein anderes Skript ebenfalls s:Add() definiert, ist sie lokal zu jenem Skript und kann nur von dem Skript aufgerufen werden, in dem sie definiert wurde.  Es kann auch eine globale Funktion Add() geben (ohne »s:«, die wieder eine andere Funktion ist.

en: <SID> can be used with mappings.  It generates a script ID, which identifies the current script.  In our typing correction plugin we use it like this: >
de: <SID> kann mit Belegungen verwandt werden.  Es generiert eine Skript-ID, die das aktuelle Skript identifiziert.  In unserem Tipp-Korrektur-Plugin verwenden wir es folgendermaßen: >

en: Thus when a user types "\a", this sequence is invoked: >
de: Wenn also ein Nutzer »\a« tippt, wird diese Folge aufgerufen: >

en: If another script would also map <SID>Add, it would get another script ID and thus define another mapping.
de: Falls ein anderes Skript auch <SID>Add belegen würde, würde es eine andere Skript-ID erhalten, also eine andere Belegung definieren.

en: Note that instead of s:Add() we use <SID>Add() here.  That is because the mapping is typed by the user, thus outside of the script.  The <SID> is translated to the script ID, so that Vim knows in which script to look for the Add() function.
de: Beachten Sie, dass wir hier <SID>Add() statt s:Add benutzen.  Das kommt daher, dass die Belegung vom Nutzer getippt wird, also außerhalb des Skripts.  Das <SID> wird in die Skript-ID übersetzt, so dass Vim weiß, in welchem Skript er nach der Funktion Add() schauen muss.

en: This is a bit complicated, but it's required for the plugin to work together with other plugins.  The basic rule is that you use <SID>Add() in mappings and s:Add() in other places (the script itself, autocommands, user commands).
de: Dies ist ein Bisschen kompliziert, aber es ist nötig, damit das Plugin mit anderen Skripten zusammenarbeitet.  Die Grundregel ist, dass Sie <SID>Add() in Belegungen verwenden, und s:Add() an anderen Stellen (dem Skript selbst, automatischen Befehlen, Benutzerbefehlen).

en: We can also add a menu entry to do the same as the mapping: >
de: Wir können auch einen Menü-Eintrag hinzufügen, der dasselbe tut wie die Belegung: >

en: The "Plugin" menu is recommended for adding menu items for plugins.  In this case only one item is used.  When adding more items, creating a submenu is recommended.  For example, "Plugin.CVS" could be used for a plugin that offers CVS operations "Plugin.CVS.checkin", "Plugin.CVS.checkout", etc.
de: Das Menü »Plugin« ist das empfohlene, um Menü-Element für Plugins hinzuzufügen.  In diesem Falle wird nur ein Element benutzt.  Wenn man mehrere Elemente hinzufügt, empfiehlt sich das Erzeugen eines Untermenüs.  Zum Beispiel könnte »Plugin.CVS« für ein Plugin verwendet werden, das CVS-Operationen anbietet: »Plugin.CVS.checkin«, »Plugin.CVS.checkout« usw.

en: Note that in line 28 ":noremap" is used to avoid that any other mappings cause trouble.  Someone may have remapped ":call", for example.  In line 24 we also use ":noremap", but we do want "<SID>Add" to be remapped.  This is why "<script>" is used here.  This only allows mappings which are local to the script. |:map-<script>| The same is done in line 26 for ":noremenu".  |:menu-<script>|
de: Beachten Sie, dass in Zeile 28 »:noremap« benutzt wird, um zu vermeiden, dass irgendwelche anderen Belegungen Probleme verursachen.  Jemand könnte zum Beispiel »:call« neu belegt haben.  In Zeile 24 benutzen wir auch »:noremap«, aber wir wollen »<SID>Add« neu belegt haben.  Deshalb wird hier »<script>« benutzt.  Dies erlaubt nur Belegungen, die lokal zum Skript sind |:map-<script>|.  Dasselbe passiert in Zeile 26 für »:noremenu« |:menu-<script>|.

en: <SID> AND <Plug>					*using-<Plug>*
de: <SID> UND <Plug>					*using-<Plug>*

en: Both <SID> and <Plug> are used to avoid that mappings of typed keys interfere with mappings that are only to be used from other mappings.  Note the difference between using <SID> and <Plug>:
de: Sowohl <SID> und <Plug> werden benutzt, um zu vermeiden, dass Belegungen von getippten Tasten Belegungen beeinflussen, die nur von anderen Belegungen zu verwenden sind.  Beachten Sie den Unterschied zwischen <SID> und <Plug>:

en: <Plug>	is visible outside of the script.  It is used for mappings which the
    	user might want to map a key sequence to.  <Plug> is a special code
    	that a typed key will never produce.
    	To make it very unlikely that other plugins use the same sequence of
    	characters, use this structure: <Plug> scriptname mapname
    	In our example the scriptname is "Typecorr" and the mapname is "Add".
    	This results in "<Plug>TypecorrAdd".  Only the first character of
    	scriptname and mapname is uppercase, so that we can see where mapname
    	starts.
de: <Plug>	ist außerhalb des Skripts sichtbar.  Es wird für Belegungen verwendet,
    	die der Nutzer möglicherweise mit einer Tastenfolge belegen will.
    	<Plug> ist ein besonderer Code, den eine getippte Taste nie
    	produzieren wird.
    	Um es sehr unwahrscheinlich zu machen, dass andere Plugins dieselbe
    	Zeichenfolge verwenden, benutze man diese Struktur:
    	<Plug> Skriptname Belegungsname.
    	In unserem Beispiel ist der Skriptname »Typecorr« und der
    	Belegungsname »Add«.  Dies ergibt »<Plug>TypecorrAdd«.  Nur das erste
    	Zeichen von Skriptname und Belegungsname ist groß, so dass wir sehen
    	können, wo der Belegungsname beginnt.

en: <SID>	is the script ID, a unique identifier for a script.
    	Internally Vim translates <SID> to "<SNR>123_", where "123" can be any
    	number.  Thus a function "<SID>Add()" will have a name "<SNR>11_Add()"
    	in one script, and "<SNR>22_Add()" in another.  You can see this if
    	you use the ":function" command to get a list of functions.  The
    	translation of <SID> in mappings is exactly the same, that's how you
    	can call a script-local function from a mapping.
de: <SID>	ist die Skript-ID, ein eindeutiger Identifikator für ein Skript.
    	Intern übersetzt Vim <SID> in »<SNR>123_«, wobei »123« jede Zahl sein
    	kann.  Also hat eine Funktion »<SID>Add()« einen Name »<SNR>11_Add()«
    	in einem Skript und »<SNR>22_Add()« in einem anderen.  Sie können dies
    	sehen, falls Sie den Befehl »:function« benutzen, um eine Liste von
    	Funktionen zu erhalten.  Die Übersetzung von <SID> in Belegungen ist
    	exakt dieselbe, deshalb können Sie eine skript-lokale Funktion von
    	einer Belegung aufrufen.

en: USER COMMAND
de: BENUTZERBEFEHLE

en: Now let's add a user command to add a correction: >
de: Nun lassen Sie uns einen Benutzerbefehl hinzufügen, um eine Korrektur hinzuzufügen: >

en: The user command is defined only if no command with the same name already exists.  Otherwise we would get an error here.  Overriding the existing user command with ":command!" is not a good idea, this would probably make the user wonder why the command he defined himself doesn't work.  |:command|
de: Der Benutzerbefehl wird nur definiert, falls kein Befehl desselben Namen bereits existiert.  Andernfalls würden wir hier einen Fehler bekommen.  Den existierenden Benutzerbefehl mit »:command!« nichtig machen, ist keine gute Idee, dies könnte den Nutzer sich fragen lassen, warum der Befehl, den er selbst definiert hat, nicht funktioniert |:command|.

en: SCRIPT VARIABLES
de: SKRIPT-VARIABLEN

en: When a variable starts with "s:" it is a script variable.  It can only be used inside a script.  Outside the script it's not visible.  This avoids trouble with using the same variable name in different scripts.  The variables will be kept as long as Vim is running.  And the same variables are used when sourcing the same script again. |s:var|
de: Wenn eine Variable mit »s:« beginnt, ist sie eine Skript-Variable.  Sie kann nur innerhalb eines Skripts verwendet werden.  Außerhalb des Skripts ist sie nicht sichtbar.  Dies vermeidet Probleme, wenn derselbe Variablenname in verschiedenen Skripten verwendet wird.  Die Variablen werden solange gehalten, wie Vim läuft.  Und dieselben Variablen werden verwandt, wenn dasselbe Skript wieder eingelesen wird |s:var|.

en: The fun is that these variables can also be used in functions, autocommands and user commands that are defined in the script.  In our example we can add a few lines to count the number of corrections: >
de: Der Spaß an der Sache ist, dass diese Variablen auch in Funktionen, automatischen Befehlen und Benutzerbefehlen, die in dem Skript definiert werden, verwendet werden können.  In unserem Beispiel können wir ein Paar Zeilen hinzufügen, um die Anzahl der Korrekturen zu zählen: >

en: First s:count is initialized to 4 in the script itself.  When later the s:Add() function is called, it increments s:count.  It doesn't matter from where the function was called, since it has been defined in the script, it will use the local variables from this script.
de: Zunächst wird s:count im Skript selbst auf 4 initialisiert.  Wenn später die Funktion s:Add() aufgerufen wird, inkremiert sie s:count.  Es ist nicht entscheidend von wo die Funktion aufgerufen wurde, weil sie im Skript definiert wurde, benutzt sie die lokalen Variablen dieses Skripts.

en: THE RESULT
de: DAS ERGEBNIS

en: Here is the resulting complete example: >
de: Hier ist das komplette sich ergebende Beispiel: >

en: Line 33 wasn't explained yet.  It applies the new correction to the word under the cursor.  The |:normal| command is used to use the new abbreviation.  Note that mappings and abbreviations are expanded here, even though the function was called from a mapping defined with ":noremap".
de: Zeile 33 wurde noch nicht erklärt.  Sie verbindet die neue Korrektur mit dem Wort unter dem Cursor.  Der Befehl |:normal| wird benutzt, um die neue Abkürzung zu benutzen.  Beachten Sie, das Belegungen und Abkürzungen hier expandiert werden, selbst wenn die Funktion von einer Belegung aufgerufen wurde, die mit »:noremap« definiert wurde.

en: Using "unix" for the 'fileformat' option is recommended.  The Vim scripts will then work everywhere.  Scripts with 'fileformat' set to "dos" do not work on Unix.  Also see |:source_crnl|.  To be sure it is set right, do this before writing the file: >
de: Es empfiehlt sich, für die Option 'fileformat' »unix« zu benutzen.  Die Vim-Skripte funktionieren dann überall.  Skripte, bei denen 'fileformat' auf »dos« gesetzt ist, funktionieren nicht unter Unix.  Siehe auch |:source_crnl|.  Um sicher zu sein, dass sie richtig gesetzt ist, tun Sie dies vor dem Schreiben der Datei: >

en: DOCUMENTATION						*write-local-help*
de: DOKUMENTATION						*write-local-help*

en: It's a good idea to also write some documentation for your plugin.  Especially when its behavior can be changed by the user.  See |add-local-help| for how they are installed.
de: Es ist eine gute Idee, auch etwas Dokumentation für das Plugin zu schreiben.  Besonders, wenn sein Verhalten von dem Nutzer geändert werden kann.  Für die Installation siehe |add-local-help|.

en: Here is a simple example for a plugin help file, called "typecorr.txt": >
de: Hier ist ein einfaches Beispiel für eine Plugin-Hilfe-Datei namens »typecorr.txt«

en: The first line is actually the only one for which the format matters.  It will be extracted from the help file to be put in the "LOCAL ADDITIONS:" section of help.txt |local-additions|.  The first "*" must be in the first column of the first line.  After adding your help file do ":help" and check that the entries line up nicely.
de: Die erste Zeile ist tatsächlich die einzige, bei der das Format zählt.  Sie wird aus der Hilfe-Datei extrahiert, um in den Abschnitt »LOKALE ERGÄNZUNGEN« von help.txt gepackt zu werden |local-additions|.  Der erste »*« muss in der ersten Spalte der ersten Zeile sein.  Nach dem Hinzufügen Ihrer Hilfe-Datei machen Sie »:help« und prüfen, ob sich die Einträge hübsch aufreihen.

en: You can add more tags inside ** in your help file.  But be careful not to use existing help tags.  You would probably use the name of your plugin in most of them, like "typecorr-settings" in the example.
de: Sie können weitere Tags in ** in Ihrer Hilfe-Datei hinzufügen.  Aber seien Sie vorsichtig, existierende Hilfe-Tags nicht zu verwenden.  In den meisten werden Sie wahrscheinlich den Namen Ihres Plugins verwenden, wie »typecorr-settings« im Beispiel.

en: Using references to other parts of the help in || is recommended.  This makes it easy for the user to find associated help.
de: Referenzen auf andere Teile der Hilfe in || zu verwenden empfiehlt sich.  Dies macht es dem Nutzer leicht, verwandte Hilfe zu finden.

en: FILETYPE DETECTION					*plugin-filetype*
de: DATEITYP-ERKENNUNG					*plugin-filetype*

en: If your filetype is not already detected by Vim, you should create a filetype detection snippet in a separate file.  It is usually in the form of an autocommand that sets the filetype when the file name matches a pattern.  Example: >
de: Falls Ihr Dateityp noch nicht von Vim erkannt wird, sollten Sie einen Schnipsel zur Dateityp-Erkennung in einer gesonderten Datei erstellen.  Es ist für gewöhnlich ein automatischer Befehl der den Dateityp setzt, wenn der Dateiname auf ein Muster passt.  Beispiel: >

en: Write this single-line file as "ftdetect/foofoo.vim" in the first directory that appears in 'runtimepath'.  For Unix that would be "~/.vim/ftdetect/foofoo.vim".  The convention is to use the name of the filetype for the script name.
de: Schreiben sie diese einzeilige Datei als »ftdetect/foofoo.vim« in das erste Verzeichnis, das in 'runtimepath' erscheint.  Unter Unix wäre dies »~/.vim/ftdetect/foofoo.vim«.  Konvention ist, dass der Name des Dateityps für den Skriptnamen verwandt wird.

en: You can make more complicated checks if you like, for example to inspect the contents of the file to recognize the language.  Also see |new-filetype|.
de: Sie können kompliziertere Tests machen, falls Sie mögen, zum Beispiel den Inhalt der Datei inspizieren, um die Sprache zu erkennen.  Siehe auch |new-filetyp|

en: SUMMARY							*plugin-special*
de: ZUSAMMENFASSUNG						*plugin-special*

en: Summary of special things to use in a plugin:
de: Zusammenfassung besonderer Dinge, die man in einem Plugin benutzen kann:

en: s:name			Variables local to the script.
de: s:name			Variablen lokal zum Skript.

en: <SID>			Script-ID, used for mappings and functions local to
    			the script.
de: <SID>			Skript-ID, benutzt für Belegungen und Funktionen lokal
    			zum Skript.

en: hasmapto()		Function to test if the user already defined a mapping
    			for functionality the script offers.
de: hasmapto()		Funktion, um zu testen, ob der Nutzer bereits eine
    			Belegung für Funktionalität, die das Skript bietet,
    			definiert hat.

en: <Leader>		Value of "mapleader", which the user defines as the
    			keys that plugin mappings start with.
de: <Leader>		Wert von »mapleader«, die der Nutzer als die Tasten
    			definiert, mit denen Plugin-Belegungen beginnen.

en: :map <unique>		Give a warning if a mapping already exists.
de: :map <unique>		Gibt eine Warnung, falls eine Belegung bereits
    			existiert

en: :noremap <script>	Use only mappings local to the script, not global
    			mappings.
de: :noremap <script>	Benutze nur Belegungen lokal zum Skript, nicht globale.

en: exists(":Cmd")		Check if a user command already exists.
de: exists(":Cmd")		Prüft, ob ein Benutzerbefehl bereits existiert.

en: *41.12*	Writing a filetype plugin	*write-filetype-plugin* *ftplugin*
de: *41.12*	Ein Dateityp-Plugin schreiben	*write-filetype-plugin* *ftplugin*

en: A filetype plugin is like a global plugin, except that it sets options and defines mappings for the current buffer only.  See |add-filetype-plugin| for how this type of plugin is used.
de: Ein Dateityp-Plugin ist wie ein globales, außer dass es nur für den aktuellen Puffer Optionen setzt und Belegungen definiert.  Siehe |add-filetype-plugin| für Informationen, wie dieser Plugin-Typ benutzt wird.

en: First read the section on global plugins above |41.11|.  All that is said there also applies to filetype plugins.  There are a few extras, which are explained here.  The essential thing is that a filetype plugin should only have an effect on the current buffer.
de: Zunächst lesen Sie den Abschnitt über globale Plugins oben |41.11|.  Alles dort gesagte gilt auch für Dateityp-Plugins.  Es gibt ein Paar Extras, die hier erklärt werden.  Essenziell ist, dass ein Dateityp-Plugin sich nur auf den aktuellen Puffer auswirken sollte.

en: DISABLING
de: DEAKTIVIEREN

en: If you are writing a filetype plugin to be used by many people, they need a chance to disable loading it.  Put this at the top of the plugin: >
de: Falls Sie ein Dateityp-Plugin schreiben, das von vielen Leuten genutzt werden soll, brauchen sie eine Möglichkeit, sein Laden zu deaktivieren.  Stellen Sie dies an den Anfang des Plugins: >

en: This also needs to be used to avoid that the same plugin is executed twice for the same buffer (happens when using an ":edit" command without arguments).
de: Dies muss auch verwandt werden, um zu vermeiden, dass dasselbe Plugin zweimal für denselben Puffer ausgeführt wird (passiert, wenn man den Befehl »:edit« ohne Argumente benutzt).

en: Now users can disable loading the default plugin completely by making a filetype plugin with only this line: >
de: Jetzt können Nutzer das Laden des Standard-Plugins komplett deaktivieren, indem sie ein Dateityp-Plugin mit nur dieser Zeile machen: >

en: This does require that the filetype plugin directory comes before $VIMRUNTIME in 'runtimepath'!
de: Dies erfordert, dass das Verzeichnis für das Dateityp-Plugin in 'runtimepath' vor $VIMRUNTIME kommt!

en: If you do want to use the default plugin, but overrule one of the settings, you can write the different setting in a script: >
de: Falls Sie das Standard-Plugin benutzen möchten, aber eine der Einstellungen aufheben möchten, können sie die unterschiedliche Einstellung in ein Skript schreiben: >

en: Now write this in the "after" directory, so that it gets sourced after the distributed "vim.vim" ftplugin |after-directory|.  For Unix this would be "~/.vim/after/ftplugin/vim.vim".  Note that the default plugin will have set "b:did_ftplugin", but it is ignored here.
de: Nun schreiben Sie dies in das Verzeichnis »after«, so dass es nach dem verteilten Dateityp-Plugin »vim.vim« eingelesen wird |after-directory|.  Unter Unix wäre dies »~/.vim/after/ftplugin/vim.vim«.  Beachten Sie, dass das Standard-Plugin »b:did_ftplugin« setzt, dies wird hier aber nicht beachtet.

en: OPTIONS
de: OPTIONEN

en: To make sure the filetype plugin only affects the current buffer use the >
de: Um sicherzustellen, dass das Dateityp-Plugin nur den aktuellen Puffer beeinflusst, benutzen Sie den Befehl >

en: command to set options.  And only set options which are local to a buffer (see the help for the option to check that).  When using |:setlocal| for global options or options local to a window, the value will change for many buffers, and that is not what a filetype plugin should do.
de: um Optionen zu setzen.  Und setzen Sie nur Optionen, die lokal zu einem Puffer sind (siehe die Hilfe zu der Option, um dies zu prüfen).  Wenn |:setlocal| für globale Optionen oder Optionen, die lokal zu einem Fenster sind, benutzt wird, ändert sich der Wert für viele Puffer, und das ist nicht, was ein Dateityp-Plugin tun sollte.

en: When an option has a value that is a list of flags or items, consider using "+=" and "-=" to keep the existing value.  Be aware that the user may have changed an option value already.  First resetting to the default value and then changing it often a good idea.  Example: >
de: Wenn eine Option einen Wert hat, der eine Liste von Flags oder Elementen ist, erwägen Sie »+=« und »-=« zu nutzen, um den existierenden Wert zu behalten.  Seien Sie sich bewusst, dass der Nutzer einen Optionswert bereits verändert haben kann.  Zuerst auf den Standardwert setzen und dann ändern ist oft eine gute Sache.  Beispiel: >

en: MAPPINGS
de: BELEGUNGEN

en: To make sure mappings will only work in the current buffer use the >
de: Um sicherzustellen, dass Belegungen nur in dem aktuellen Puffer funktionieren, benutzen Sie den Befehl >

en: command.  This needs to be combined with the two-step mapping explained above.  An example of how to define functionality in a filetype plugin: >
de: Dies muss mit der zweischrittigen Belegung, wie oben erklärt, kombiniert werden.  Ein Beispiel wie man Funktionalität in einem Dateityp-Plugin definiert: >

en: |hasmapto()| is used to check if the user has already defined a map to <Plug>JavaImport.  If not, then the filetype plugin defines the default mapping.  This starts with |<LocalLeader>|, which allows the user to select the key(s) he wants filetype plugin mappings to start with.  The default is a backslash.  "<unique>" is used to give an error message if the mapping already exists or overlaps with an existing mapping.  |:noremap| is used to avoid that any other mappings that the user has defined interferes.  You might want to use ":noremap <script>" to allow remapping mappings defined in this script that start with <SID>.
de: |hasmapto()| wird benutzt um zu prüfen, ob der Nutzer bereits eine Belegung auf <Plug>JavaImport definiert hat.  Falls nicht, definiert das Dateityp-Plugin die Standard-Belegung.  Diese beginnt mit |<LocalLeader>|, was dem Nutzer erlaubt, die Taste(n), mit denen Belegungen aus Dateityp-Plugins beginnen, zu wählen.  Der Standard ist ein Backslash.  »<unique>« wird benutzt, um eine Fehlermeldung auszugeben, falls die Belegung bereits existiert oder mit anderen Belegungen überlappt.  |:noremap| wird benutzt, um zu vermeiden, dass jegliche anderen Belegungen, die der Nutzer definiert hat,Einfluss nehmen.  Man will möglicherweise »:noremap <script>« verwenden, um das Neubelegen von Belegungen, die in diesem Skript definiert wurden und mit <SID> beginnen, zu erlauben.

en: The user must have a chance to disable the mappings in a filetype plugin, without disabling everything.  Here is an example of how this is done for a plugin for the mail filetype: >
de: Der Nutzer muss die Möglichkeit haben, die Belegungen in einem Dateityp-Plugin zu deaktivieren, ohne alles zu deaktivieren.  Hier ein Beispiel, wie dies in einem Plugin für den Dateityp Email gemacht wird: >

en: Two global variables are used: no_plugin_maps		disables mappings for all filetype plugins no_mail_maps		disables mappings for a specific filetype
de: Zwei globale Variablen werden benutzt:
    no_plugin_maps		deaktiviert Belegungen für alle Dateityp-Plugins
    no_mail_maps		deaktiviert Belegungen für einen bestimmten Dateityp

en: USER COMMANDS
de: BENUTZERBEFEHLE

en: To add a user command for a specific file type, so that it can only be used in one buffer, use the "-buffer" argument to |:command|.  Example: >
de: Um einen Benutzerbefehl für einen bestimmten Dateityp hinzufügen, so dass er nur in einem Puffer benutzt werden kann, benutzen Sie das Argument »-buffer« von |:command|.  Beispiel: >

en: VARIABLES
de: VARIABLEN

en: A filetype plugin will be sourced for each buffer of the type it's for.  Local script variables |s:var| will be shared between all invocations.  Use local buffer variables |b:var| if you want a variable specifically for one buffer.
de: Ein Dateityp-Plugin wird für jeden Puffer seines Typs eingelesen.  Lokale Skript-Variablen |s:var| werden zwischen allen Aufrufen geteilt.  Benutzen Sie lokale Puffer-Variablen |b:var|, falls Sie eine Variable für einen bestimmten Puffer wollen.

en: FUNCTIONS
de: FUNKTIONEN

en: When defining a function, this only needs to be done once.  But the filetype plugin will be sourced every time a file with this filetype will be opened.  This construct make sure the function is only defined once: >
de: Wenn eine Funktion definiert wird, braucht dies nur einmal getan werden.  Aber das Dateityp-Plugin wird jedesmal eingelesen, wenn eine Datei dieses Dateityps geöffnet wird.  Dieses Konstrukt stellt sicher, dass die Funktion nur einmal definiert wird: >

en: When the user does ":setfiletype xyz" the effect of the previous filetype should be undone.  Set the b:undo_ftplugin variable to the commands that will undo the settings in your filetype plugin.  Example: >
de: Wenn der Benutzer »:setfiletype xyz« eingibt, sollte der Effekt des vorigen Dateityps zurückgenommen werden.  Setzen Sie die Variable b:undo_ftplugin auf die Befehle, die die Einstellungen in Ihrem Dateityp-Plugin zurücknehmen.  Beispiel: >

en: Using ":setlocal" with "<" after the option name resets the option to its global value.  That is mostly the best way to reset the option value.
de: Das Benutzen von »:setlocal« mit »<« nach dem Optionsnamen setzt die Option auf ihren globalen Wert.  Das ist meistens das Beste, um den Optionswert neu zu setzen.

en: This does require removing the "C" flag from 'cpoptions' to allow line continuation, as mentioned above |use-cpo-save|.
de: Dies erfordert das Entfernen des Flags »C« von 'cpoptions' um Zeilenfortsetzung zu erlauben, wie oben erwähnt |use-cpo-save|.

en: FILE NAME
de: DATEINAME

en: The filetype must be included in the file name |ftplugin-name|.  Use one of these three forms:
de: Der Dateityp muss in den Dateinamen einbezogen werden |ftplugin-name|.  Benutzen Sie eine von diesen drei Formen:

en: "stuff" is the filetype, "foo" and "bar" are arbitrary names.
de: »stuff« ist der Dateityp, »foo« und »bar« sind beliebige Namen.

en: SUMMARY							*ftplugin-special*
de: ZUSAMMENFASSUNG						*ftplugin-special*

en: Summary of special things to use in a filetype plugin:
de: Zusammenfassung besonderer Dinge, die man in einem Dateityp-Plugin nutzen kann:

en: <LocalLeader>		Value of "maplocalleader", which the user defines as
    			the keys that filetype plugin mappings start with.
de: <LocalLeader>		Wert von »maplocalleader«, welche der Nutzer als die
    			Tasten definiert, mit denen Dateityp-Plugin-Belegungen
    			beginnen.

en: :map <buffer>		Define a mapping local to the buffer.
de: :map <buffer>		Definiere eine Belegung lokal zum Puffer.

en: :noremap <script>	Only remap mappings defined in this script that start
    			with <SID>.
de: :noremap <script>	Belege nur Belegungen neu, die in diesem Skript
    			definiert wurden und mit <SID> beginnen.

en: :setlocal		Set an option for the current buffer only.
de: :setlocal		Setze eine Option nur für den aktuellen Puffer.

en: :command -buffer	Define a user command local to the buffer.
de: :command -buffer	Definiere einen Benutzerbefehl lokal zum Puffer.

en: exists("*s:Func")	Check if a function was already defined.
de: exists("*s:Func")	Prüfe ob eine Funktion bereits definiert wurde.

en: Also see |plugin-special|, the special things used for all plugins.
de: Siehe auch |plugin-special|, die besonderen Dinge, die für alle Plugins verwendet werden.

en: *41.13*	Writing a compiler plugin		*write-compiler-plugin*
de: *41.13*	Ein Kompiler-Plugin schreiben		*write-compiler-plugin*

en: A compiler plugin sets options for use with a specific compiler.  The user can load it with the |:compiler| command.  The main use is to set the 'errorformat' and 'makeprg' options.
de: Ein Kompiler-Plugin setzt Optionen zum Gebrauch mit einem bestimmten Kompiler.  Der Nutzer kann es mit dem Befehl |:compiler| laden.  Hauptsächlicher Gebrauch ist es, die Optionen 'errorformat' und 'makeprg' zu setzen.

en: Easiest is to have a look at examples.  This command will edit all the default compiler plugins: >
de: Am einfachsten ist es, auf Beispiele zu schauen.  Dieser Befehl editiert alle Standard-Kompiler-Plugins: >

en: Use |:next| to go to the next plugin file.
de: Benutzen Sie |:next|, um zur nächsten Plugin-Datei zu gelangen.

en: There are two special items about these files.  First is a mechanism to allow a user to overrule or add to the default file.  The default files start with: >
de: Es gibt zwei besondere Elemente bei diesen Dateien.  Das erste ist ein Mechanismus, um einem Benutzer zu erlauben, die Standard-Datei zu überstimmen oder ihr hinzuzufügen.  Die Standard-Dateien beginnen mit: >

en: When you write a compiler file and put it in your personal runtime directory
    (e.g., ~/.vim/compiler for Unix), you set the "current_compiler" variable to
    make the default file skip the settings.
    							*:CompilerSet*
    The second mechanism is to use ":set" for ":compiler!" and ":setlocal" for
    ":compiler".  Vim defines the ":CompilerSet" user command for this.  However,
    older Vim versions don't, thus your plugin should define it then.  This is an
    example: >
de: Wenn Sie eine Kompiler-Datei schreiben und in Ihr persönliches
    Laufzeit-Verzeichnis legen (z.B. ~/.vim/compiler für Unix), setzen Sie die
    Variable »current_compiler«, um die Standard-Datei die Einstellungen
    überspringen zu lassen.
    							*:CompilerSet*
    Der zweite Mechanismus ist, »:set« für »:compiler!« und »:setlocal« für
    »:compiler« zu benutzen.  Vim definiert hierfür den Benutzerbefehl
    »:CompilerSet«.  Ältere Vim-Versionen tun dies jedoch nicht, also sollte Ihr
    Plugin ihn dann definieren.  Dies ist ein Beispiel: >

en: When you write a compiler plugin for the Vim distribution or for a system-wide runtime directory, use the mechanism mentioned above.  When "current_compiler" was already set by a user plugin nothing will be done.
de: Wenn Sie ein Kompiler-Plugin für die Vim-Distribution oder für ein system-weites Laufzeit-Verzeichnis schreiben, benutzen Sie den oben erwähnten Mechanismus.  Wenn »current_compiler« bereits von einem Nutzer-Plugin gesetzt wurde, wird nichts getan.

en: When you write a compiler plugin to overrule settings from a default plugin, don't check "current_compiler".  This plugin is supposed to be loaded last, thus it should be in a directory at the end of 'runtimepath'.  For Unix that could be ~/.vim/after/compiler.
de: Wenn Sie ein Kompiler-Plugin schreiben, um Einstellungen eines Standard-Plugins zu überstimmen, prüfen Sie nicht »current_compiler«.  Dieses Plugin soll als letztes geladen werden, also sollte es in einem Verzeichnis am Ende von 'runtimepath' stehen.  Für Unix könnte dies ~/.vim/after/compiler sein.

en: *41.14*	Writing a plugin that loads quickly	*write-plugin-quickload*
de: *41.14*	Ein Plugin so schreiben, dass es schnell lädt *write-plugin-quickload*

en: A plugin may grow and become quite long.  The startup delay may become noticeable, while you hardly ever use the plugin.  Then it's time for a quickload plugin.
de: Ein Plugin kann wachsen und ziemlich lang werden.  Die Start-Verzögerung kann merkbar werden, während Sie das Plugin kaum benutzen.  Dann ist es Zeit für ein Schnelllade-Plugin.

en: The basic idea is that the plugin is loaded twice.  The first time user commands and mappings are defined that offer the functionality.  The second time the functions that implement the functionality are defined.
de: Die Grundidee ist, dass das Plugin zweimal geladen wird.  Beim ersten Mal werden Benutzerbefehle und Belegungen definiert, die die Funktionalität anbieten.  Beim zweiten Mal werden die Funktion, die die Funktionalität implementieren, definiert.

en: It may sound surprising that quickload means loading a script twice.  What we mean is that it loads quickly the first time, postponing the bulk of the script to the second time, which only happens when you actually use it.  When you always use the functionality it actually gets slower!
de: Es mag überraschend klingen, dass Schnellladen bedeutet, ein Skript zweimal zu laden.  Was wir meinen ist, dass es beim ersten Mal schnell lädt, die Masse des Skripts auf das zweite Mal verschiebend, was nur passiert, wenn man es tatsächlich benutzt.  Wenn Sie immer die Funktionalität benutzen, wird es tatsächlich langsamer!

en: Note that since Vim 7 there is an alternative: use the |autoload| functionality |41.15|.
de: Beachten Sie, dass es seit Vim 7 eine Alternative gibt: benutzen Sie die Funktionalität |autoload| |41.15|.

en: The following example shows how it's done: >
de: Das folgende Beispiel zeigt, wie es gemacht wird: >

en: When the script is first loaded "s:did_load" is not set.  The commands between the "if" and "endif" will be executed.  This ends in a |:finish| command, thus the rest of the script is not executed.
de: Wenn das Skript zum ersten Mal geladen wird, ist »s:did_load« nicht gesetzt.  Die Befehle zwischen »if« und »endif« werden ausgeführt.  Dies endet in einem Befehl |:finish|, also wird der Rest des Skripts nicht ausgeführt.

en: The second time the script is loaded "s:did_load" exists and the commands after the "endif" are executed.  This defines the (possible long)  BufNetRead() and BufNetWrite() functions.
de: Beim zweiten Mal, wenn das Skript geladen wird, existiert »s:did_load« und die Befehle nach dem »endif« werden ausgeführt.  Dies definiert die (möglicherweise langen) Funktionen BufNetRead() und BufNetWrite().

en: If you drop this script in your plugin directory Vim will execute it on startup.  This is the sequence of events that happens:
de: Falls Sie dieses Skript in Ihr Plugin-Verzeichnis legen, führt Vim es beim Starten aus.  Dies ist die Folge von Ereignissen, die geschieht:

en: The "BNRead" command is defined and the <F19> key is mapped when the script is sourced at startup.  A |FuncUndefined| autocommand is defined.  The ":finish" command causes the script to terminate early.
de: Der Befehl »BNRead« Befehl wird definiert und die Taste <F19> wird belegt, wenn das Skript beim Start eingelesen wird.  Ein automatischer Befehl |FuncUndefined| wird definiert. Der Befehl »:finish« lässt das Skript frühzeitig terminieren.

en: The user types the BNRead command or presses the <F19> key.  The BufNetRead() or BufNetWrite() function will be called.
de: Der Nutzer tippt den Befehl BNRead oder drückt die Taste <F19>.  Die Funktion BufNetRead() oder BufNetWrite() wird aufgerufen.

en: Vim can't find the function and triggers the |FuncUndefined| autocommand event.  Since the pattern "BufNet*" matches the invoked function, the command "source fname" will be executed.  "fname" will be equal to the name of the script, no matter where it is located, because it comes from expanding "<sfile>" (see |expand()|).
de: Vim kann die Funktion nicht finden und löst den automatischen Befehl |FucUndefined| aus.  Weil das Muster »BufNet*« auf die aufgerufene Funktion passt, wird der Befehl »source fname«.  »fname« ist gleich dem Namen der Funktion, egal wo es liegt, weil es vom Expandieren von »<sfile>« kommt (siehe |expand()|).

en: The script is sourced again, the "s:did_load" variable exists and the functions are defined.
de: Das Skript wird erneut eingelesen, die Variable »s:did_load« existiert, und die Funktionen werden definiert.

en: Notice that the functions that are loaded afterwards match the pattern in the |FuncUndefined| autocommand.  You must make sure that no other plugin defines functions that match this pattern.
de: Beachten Sie, dass die Funktionen, die im Nachhinein geladen werden, auf das Muster in dem automatischen Befehl |FuncUndefined| passen.  Sie müssen sicherstellen, dass kein anderes Plugin Funktionen definiert, die auf dieses Muster passen.

en: *41.15*	Writing library scripts			*write-library-script*
de: *41.15*	Bibliotheksskripte schreiben		*write-library-script*

en: Some functionality will be required in several places.  When this becomes more than a few lines you will want to put it in one script and use it from many scripts.  We will call that one script a library script.
de: Einige Funktionalität wird an mehreren Stellen benötigt.  Wenn dies mehr als ein Paar Zeilen werden, möchten Sie sie in ein Skript packen und es von vielen Skripten aus benutzen.  Wir nennen dies eine Skript ein Bibliotheksskript.

en: Manually loading a library script is possible, so long as you avoid loading it when it's already done.  You can do this with the |exists()| function.  Example: >
de: Ein Bibliotheksskript von Hand laden ist möglich, so lange wie Sie vermeiden, es zu laden, wenn dies bereits getan wurde.  Sie können dies mit der Funktion |exists()| machen.  Beispiel: >

en: Here you need to know that MyLibFunction() is defined in a script "library/mylibscript.vim" in one of the directories in 'runtimepath'.
de: Hier müssen Sie wissen, dass MyLibFunction() in einem Skript »library/mylibscript.vim« in einem der Verzeichnisse in 'runtimepath' definiert ist.

en: To make this a bit simpler Vim offers the autoload mechanism.  Then the example looks like this: >
de: Um dies ein Bisschen einfacher zu machen, bietet Vim den Mechanismus autoload an.  Dann sieht das Beispiel so aus: >

en: That's a lot simpler, isn't it? Vim will recognize the function name and when it's not defined search for the script "autoload/mylib.vim" in 'runtimepath'.  That script must define the "mylib#myfunction()" function.
de: Das ist viel einfacher, oder nicht? Vim erkennt den Funktionsnamen und wenn sie nicht definiert ist, sucht er nach dem Skript »autoload/mylib.vim« im 'runtimepath'.  Dieses Skript muss die Funktion »mylib#myfunction()« definieren.

en: You can put many other functions in the mylib.vim script, you are free to organize your functions in library scripts.  But you must use function names where the part before the '#' matches the script name.  Otherwise Vim would not know what script to load.
de: Sie können viele andere Funktionen in das Skript mylib.vim packen, Sie sind frei, Ihre Funktionen in Bibliotheksskripten zu organisieren.  Aber Sie müssen Funktionsnamen benutzen, bei denen der Teil vor dem '#' mit dem Skriptnamen übereinstimmt.  Andernfalls wüsste Vim nicht, welches Skript er laden muss.

en: If you get really enthusiastic and write lots of library scripts, you may want to use subdirectories.  Example: >
de: Falls Sie wirklich enthusiastisch werden und viele Bibliotheksskripte schreiben, mögen Sie Unterverzeichnisse verwenden wollen.  Beispiel: >

en: For Unix the library script used for this could be:
de: Für Unix könnte das Bibliotheksskript, das für dies benutzt wird, sein:

en: Where the function is defined like this: >
de: Wo die Funktion wie folgt definiert wird: >

en: Notice that the name the function is defined with is exactly the same as the name used for calling the function.  And the part before the last '#' exactly matches the subdirectory and script name.
de: Beachten Sie, dass der Name, mit dem die Funktion definiert wird, exakt derselbe ist, wie der Name für das Aufrufen der Funktion.  Und der Teil vor dem letzten '#' stimmt genau mit dem Unterverzeichnis und Skriptnamen überein.

en: You can use the same mechanism for variables: >
de: Sie können denselben Mechanismus für Variablen verwenden: >

en: This will load the script "autoload/dutch.vim", which should contain something like: >
de: Die lädt das Skript »autoload/dutch.vim«, welches etwas enthalten sollte wie: >

en: Further reading: |autoload|.
de: Zum Weiterlesen: |autoload|.

en: *41.16*	Distributing Vim scripts			*distribute-script*
de: *41.16*	Vim-Skripte verteilen			*distribute-script*

en: Vim users will look for scripts on the Vim website: http://www.vim.org.  If you made something that is useful for others, share it!
de: Vim-Nutzer schauen auf der Vim-Webseite (http://www.vim.org/) nach Skripten.  Falls Sie etwas gemacht haben, das nützlich für andere ist, teilen Sie es!

en: Vim scripts can be used on any system.  There might not be a tar or gzip command.  If you want to pack files together and/or compress them the "zip" utility is recommended.
de: Vim-Skripte können auf jedem System benutzt werden.  Es könnte keinen Befehl tar oder gzip geben.  Falls Sie Dateien zusammen packen und/oder komprimieren möchten, empfiehlt sich das Werkzeug »zip«.

en: For utmost portability use Vim itself to pack scripts together.  This can be done with the Vimball utility.  See |vimball|.
de: Für äußerste Portabilität benutzen Sie Vim selbst, um Skript zusammen zu packen.  Dies kann mit dem Werkzeug Vimball gemacht werden.  Siehe |vimball|.

en: It's good if you add a line to allow automatic updating.  See |glvs-plugins|.
de: Es ist gut, falls Sie eine Zeile hinzufügen, um automatisches Aktualisieren zu erlauben.  Siehe |glvs-plugins|.

en: Next chapter: |usr_42.txt| Add new menus
de: Nächstes Kapitel: |usr_42.txt| Neue Menüs hinzufügen

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:
