vimhelp-de 8.2.0017 - en to de translation catalogue (460 entries)

note: type: Plain text
en: *usr_41.txt*	For Vim version 8.2.  Last change: 2019 Dec 17
de: *usr_41.txt*	Für Vim Version 8.2.  Letzte Änderung: 17. Dez. 2019

note: type: Plain text
en: 		     VIM USER MANUAL - by Bram Moolenaar
de: 		     VIM BENUTZERHANDBUCH - von Bram Moolenaar

note: type: Plain text
en: 			      Write a Vim script
de: 			      Ein Vim-Skript schreiben

note: type: Plain text
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 Initialisierungsdatei vimrc, Syntax-Dateien und viele andere Dinge verwendet. Dieses Kapitel erklärt die Elemente, die in  einem Vim-Skript verwendet werden können. Davon gibt es eine Menge, daher ist dies ein langes Kapitel.

note: type: Plain text
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 verwenden
    |41.7|	Eine Funktion definieren
    |41.8|	Listen und Wörterbücher
    |41.9|	Ausnahmen
    |41.10|	Verschiedene Anmerkungen
    |41.11|	Eine Erweiterung (Plugin) schreiben
    |41.12|	Eine Dateityperweiterung (FTPlugin) schreiben
    |41.13|	Eine Compiler-Erweiterung schreiben
    |41.14|	Eine Erweiterung so schreiben, dass sie schnell lädt
    |41.15|	Bibliotheksskripte schreiben
    |41.16|	Vim-Skripte verteilen

note: type: Plain text
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|

note: type: Plain text
en: *41.1*	Introduction				*vim-script-intro* *script*
de: *41.1*	Einführung				*vim-script-intro* *script*

note: type: Plain text
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 ein und führt die Befehle aus. Sie können Optionen auf Werte setzen, die
    Sie bevorzugen. Und Sie können jeden Doppelpunktbefehl in ihr benutzen
    (Befehle, die mit »:« beginnen, diese werden manchmal Ex-Befehle oder
    Befehlszeilenbefehle 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.

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

note: type: Plain text
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-Skriptdatei können
    	sie weggelassen werden. Wir verwenden Sie hier dennoch, um klar zu
    	machen, dass dies Doppelpunktbefehle 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.

note: type: Plain text
en: The output of the example code is:
de: Die Ausgabe des Beispielcodes ist:

note: type: Plain text
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 ~

note: type: Plain text
en: In the first line the ":let" command assigns a value to a variable.  The generic form is: >
de: In der ersten Zeile weist der Befehl »:let« einen Wert einer Variablen zu. Die generische Form ist: >

note: type: Plain text
en: 	:let {variable} = {expression}
de: 	:let {Variable} = {Ausdruck}

note: type: Plain text
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: >

note: type: Plain text
en: 	:while {condition}
    	:  {statements}
    	:endwhile
de: 	:while {Bedingung}
    	:  {Anweisungen}
    	:endwhile

note: type: Plain text
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 verwendete 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.

note: type: Plain text
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:

note: type: Plain text
en: 	count is 1 ~
de: 	Zähler ist 1 ~

note: type: Plain text
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.

note: type: Plain text
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: >

note: type: Plain text
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

note: type: Plain text
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()| erst später. Folgen Sie den Verweisen, wenn Sie ungeduldig sind.

note: type: Plain text
en: FOUR KINDS OF NUMBERS
de: VIER ARTEN VON ZAHLEN

note: type: Plain text
en: Numbers can be decimal, hexadecimal, octal or binary.  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.  A binary number starts with "0b" or
    "0B".  For example "0b101" is decimal 5.  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, oktal oder binär 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. Eine binäre Zahl
    beginnt mit »0b« oder »0B«. Zum Beispiel ist »0x101« dezimal 5.
    Achtung: setzen Sie keine Null vor eine dezimale Zahl, sie würde dann als
    oktale Zahl interpretiert!
       Der Befehl »:echo« gibt immer dezimale Zahlen aus. Beispiel: >

note: type: Plain text
en: A number is made negative with a minus sign.  This also works for hexadecimal, octal and binary numbers.  A minus sign is also used for subtraction.  Compare this with the previous example: >
de: Eine Zahl wird mit einem Minuszeichen negativ gemacht. Dies funktioniert
    auch für hexadezimale, oktale und binäre Zahlen. Das Minuszeichen wird auch
    für die Substraktion verwendet. Vergleichen Sie dies mit dem vorigen
    Beispiel: >

note: type: Plain text
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: Leerraum in einem Ausdruck wird ignoriert. Dennoch empfiehlt es sich, ihn zu verwenden 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 Minuszeichen und die darauf folgende Zahl: >

note: type: Plain text
en: *41.2*	Variables
de: *41.2*	Variablen

note: type: Plain text
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:

note: type: Plain text
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, verwenden Sie diesen Befehl: >

note: type: Plain text
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 »count« in einer Skriptdatei verwendet wird, sie auch in einer anderen Datei verwendet 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: >

note: type: Plain text
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 zu Variablen, die lokal zu einem Skript sind, unter: |script-variable|

note: type: Plain text
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 verwendeten sind:

note: type: Plain text
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

note: type: Plain text
en: DELETING VARIABLES
de: VARIABLEN LöSCHEN

note: type: Plain text
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, verwenden Sie den Befehl »:unlet«.  Beispiel: >

note: type: Plain text
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 zum 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: >

note: type: Plain text
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 sich ein Skript beendet, werden die in ihm benutzten lokalen Variablen nicht automatisch freigegeben. Das nächste Mal, wenn das Skript ausgeführt wird, kann es immer noch den alten Wert verwenden. Beispiel: >

note: type: Plain text
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"

note: type: Plain text
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: >

note: type: Plain text
en: 	:if !exists(s:call_count)
de: 	:if !exists(s:aufruf_zaehler)

note: type: Plain text
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 in eine 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 interpretiert, also als falsch!

note: type: Plain text
en: STRING VARIABLES AND CONSTANTS
de: ZEICHENKETTENVARIABLEN UND -KONSTANTEN

note: type: Plain text
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: Bis hier wurden nur Zahlen für den Variablenwert verwendet. Zeichenketten
    können auch verwendet 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 Anführungszeichen: >

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

note: type: Plain text
en: 	:let name = "\"peter\""
    	:echo name
    <	"peter" ~
de: 	:let name = "\"Peter\""
    	:echo name
    <	"Peter" ~

note: type: Plain text
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 Anführungszeichen verwenden: >

note: type: Plain text
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 Anführungszeichen sind alle Zeichen wie
    sie sind. Nur das einzelne Anführungszeichen 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 verwenden, um die Bedeutung des Zeichens
    danach zu verändern.
       In Zeichenketten mit doppelten Anführungszeichen ist es möglich, besondere
    Zeichen zu verwenden. Hier sind ein Paar nützliche:

note: type: Plain text
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

note: type: Plain text
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 verwendet
    werden, um die Sondertaste »name« einzubeziehen.
       Siehe |expr-quote| für die volle Liste besonderer Elemente in einer
    Zeichenkette.

note: type: Plain text
en: *41.3*	Expressions
de: *41.3*	Ausdrücke

note: type: Plain text
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:

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

note: type: Plain text
en: Examples: >
de: Beispiele: >

note: type: Plain text
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

note: type: Plain text
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 verwendet 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: >

note: type: Plain text
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

note: type: Plain text
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' verwendet wird. Jedoch erhä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|.)

note: type: Plain text
en: MATHEMATICS
de: MATHEMATIK

note: type: Plain text
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

note: type: Plain text
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

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

note: type: Plain text
en: Grouping is done with parentheses.  No surprises here.  Example: >
de: Gruppierung mit Klammern. Keine Überraschungen hier. Beispiel: >

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

note: type: Plain text
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.

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

note: type: Plain text
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: >

note: type: Plain text
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:

note: type: Plain text
en: *41.4*	Conditionals
de: *41.4*	Bedingungen

note: type: Plain text
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 nur aus, bis zum übereinstimmenden »:endif«, wenn eine Bedingung erfüllt ist. Die generische Form ist:

note: type: Plain text
en: 	:if {condition}
    	   {statements}
    	:endif
de: 	:if {Bedingung}
    	   {Anweisungen}
    	:endif

note: type: Plain text
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. Diese müssen immer noch gültige Befehle sein. Falls
    sie Unsinn enthalten, ist es Vim nicht möglich, das »:endif« zu finden.
       Sie können auch »:else« verwenden. Die generische Form hierfür ist:

note: type: Plain text
en: 	:if {condition}
    	   {statements}
    	:else
    	   {statements}
    	:endif
de: 	:if {Bedingung}
    	   {Anweisungen}
    	:else
    	   {Anweisungen}
    	:endif

note: type: Plain text
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 es der erste nicht
    wird.
       Schließlich gibt es »:elseif«:

note: type: Plain text
en: 	:if {condition}
    	   {statements}
    	:elseif {condition}
    	   {statements}
    	:endif
de: 	:if {Bedingung}
    	   {Anweisungen}
    	:elseif {Bedingung}
    	   {Anweisungen}
    	:endif

note: type: Plain text
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 verwenden.
       Ein nützliches Beispiel für Ihre vimrc ist, die Option 'term' zu prüfen,
    und abhängig von ihrem Wert etwas zu tun: >

note: type: Plain text
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

note: type: Plain text
en: LOGIC OPERATIONS
de: LOGISCHE OPERATIONEN

note: type: Plain text
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 verwendet. Dies sind die am häufigsten verwendeten:

note: type: Plain text
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

note: type: Plain text
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: >

note: type: Plain text
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

note: type: Plain text
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|

note: type: Plain text
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 verwendet. 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: >

note: type: Plain text
en: 	:if 0 == "one"
    	:  echo "yes"
    	:endif
de: 	;if 0 == "eins"
    	:  echo "ja"
    	:endif

note: type: Plain text
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.

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

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

note: type: Plain text
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 verwendet. Das rechte Element »b« wird als Muster verwendet, wie beim Suchen. Beispiel: >

note: type: Plain text
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

note: type: Plain text
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 das Verwenden 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.

note: type: Plain text
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 verwendet. 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-==|.

note: type: Plain text
en: MORE LOOPING
de: MEHR ÜBER SCHLEIFEN

note: type: Plain text
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« verwendet werden:

note: type: Plain text
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.

note: type: Plain text
en: Example: >
de: Beispiel: >

note: type: Plain text
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

note: type: Plain text
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.

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

note: type: Plain text
en: *41.5*	Executing an expression
de: *41.5*	Einen Ausdruck ausführen

note: type: Plain text
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: >

note: type: Plain text
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 verwendet, 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: >

note: type: Plain text
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 Doppelpunktbefehle ausführen. Der Befehl »:normal« führt Befehl des Normalmodus aus. Jedoch ist sein Argument kein Ausdruck, sondern die wörtlichen Befehlszeichen. Beispiel: >

note: type: Plain text
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: >

note: type: Plain text
en: 	:execute "normal " . normal_commands
de: 	:execute "normal " . normal_befehle

note: type: Plain text
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 Normalmodusbefehle enthalten.
       Stellen Sie sicher, dass das Argument für »:normal« ein vollständiger
    Befehl ist. Ansonsten stößt Vim auf das Ende des Arguments und führt den
    Befehl nicht aus. Falls Sie zum Beispiel den Einfügemodus starten, müssen
    Sie auch den Einfügemodus verlassen. Dies funktioniert: >

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

note: type: Plain text
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 die Verwendung der Sondersequenz »\<Esc>«. Dies vermeidet, dass sie ein wirkliches <Esc>-Zeichen in Ihr Skript einfügen müssen.

note: type: Plain text
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: >

note: type: Plain text
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

note: type: Plain text
en: *41.6*	Using functions
de: *41.6*	Funktionen benutzen

note: type: Plain text
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 Umfang an Funktionalität. Einige wenige Beispiele werden in diesem Abschnitt angegeben. Sie können die ganze Liste hier finden: |functions|.

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

note: type: Plain text
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 Marker. Das Kennzeichen »W« bedeutet, dass die Suche am Ende der Datei nicht an ihrem Beginn fortgesetzt werden soll (wrap around).

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

note: type: Plain text
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)

note: type: Plain text
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 ».« verwendet,
    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 Marker.
       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: >

note: type: Plain text
en: Using the functions becomes more interesting when you do more work before and after the substitute() call.
de: Die Funktionen verwenden wird interessanter, wenn Sie mehrere Dinge vor und nach dem Aufruf von substitute() erledigen.

note: type: Plain text
en: FUNCTIONS						*function-list*
de: FUNKTIONEN						*function-list*

note: type: Plain text
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|. Verwenden Sie CTRL-] auf dem Funktionsnamen, um zu einer detailierten Hilfe zu ihr zu springen.

note: type: Plain text
en: String manipulation:					*string-functions*
    	nr2char()		get a character by its number value
    	list2str()		get a character string from a list of numbers
    	char2nr()		get number value of a character
    	str2list()		get list of numbers from a string
    	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
    	matchstrpos()		match and positions 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 in bytes
    	strchars()		length of a string in characters
    	strwidth()		size of string when displayed
    	strdisplaywidth()	size of string when displayed, deals with tabs
    	substitute()		substitute a pattern match with a string
    	submatch()		get a specific match in ":s" and substitute()
    	strpart()		get part of a string using byte index
    	strcharpart()		get part of a string using char index
    	strgetchar()		get character from a string using char index
    	expand()		expand special keywords
    	expandcmd()		expand a command like done for `:edit`
    	iconv()			convert text from one encoding to another
    	byteidx()		byte index of a character in a string
    	byteidxcomp()		like byteidx() but count composing characters
    	repeat()		repeat a string multiple times
    	eval()			evaluate a string expression
    	execute()		execute an Ex command and get the output
    	win_execute()		like execute() but in a specified window
    	trim()			trim characters from a string
de: Zeichenketten-Manipulation:				*string-functions*
    	nr2char()		liefert ein Zeichen anhand seines nummerischen
    				Werts
    	list2str()		liefert eine Zeichenkette anhand einer
    				Liste von Zahlen
    	char2nr()		liefert den nummerischen Wert eines Zeichens
    	str2nr()		konvertiert eine Zeichenkette in eine Zahl
    	str2float()		konvertiert eine Zeichenkette in eine
    				Gleitpunktzahl
    	printf()		formatiert eine Zeichenkette nach %-Elementen
    	escape()		maskiert Zeichen in einer Zeichenkette mit
    				einem »\«
    	shellescape()		maskiert eine Zeichenkette zum Verwenden mit
    				einem Shell-Befehl
    	fnameescape()		maskiert einen Dateinamen zum Verwenden 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
    	matchstrpos()		Übereinstimmung und Position 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 in Bytes
    	strchars()		Länge einer Zeichenkette in Zeichen
    	substitute()		ersetzt eine Musterübereinstimmung durch eine
    				Zeichenkette
    	submatch		liefert eine bestimmte Übereinstimmung in
    				einem »:s« oder bei substitute()
    	strpart()		liefert Teil einer Zeichenkette
    				unter Verwendung des Byte-Index
    	strcharpart()		liefert Teil einer Zeichenkette
    				unter Verwendung des Zeichenindex
    	expand()		expandiert besondere Schlüsselwörter
    	expandcmd()		expandiert einen Befehl, wie es
    				für »:edit« getan wird
    	iconv()			konvertiert Text von einer Kodierung
    				in eine andere
    	byteidx()		Byte-Index eines Zeichens in einer
    				Zeichenkette
    	byteidxcomp()		wie byteidx(), zählt aber Composing-Zeichen
    	repeat()		wiederholt eine Zeichenkette mehrere Male
    	eval()			wertet einen Zeichenkettenausdruck aus
    	execute()		führt einen Ex-Befehl aus und liefert das
    				Ergebnis
    	win_execute()		wie execute(), aber in einem angegebenen
    				Fenster
    	trim()			entfernt Zeichen aus einer Zeichenkette

note: type: Plain text
en: List manipulation:					*list-functions*
    	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
    	uniq()			remove copies of repeated adjacent items
    	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:					*list-functions*
    	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
    	uniq()			entfernt Kopien sich wiederholender
    				benachbarter Elemente
    	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

note: type: Plain text
en: Dictionary manipulation:				*dict-functions*
    	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:				*dict-functions*
    	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

note: type: Plain text
en: Floating point computation:				*float-functions*
    	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
    	fmod()			remainder of division
    	exp()			exponential
    	log()			natural logarithm (logarithm to base e)
    	log10()			logarithm to base 10
    	pow()			value of x to the exponent y
    	sqrt()			square root
    	sin()			sine
    	cos()			cosine
    	tan()			tangent
    	asin()			arc sine
    	acos()			arc cosine
    	atan()			arc tangent
    	atan2()			arc tangent
    	sinh()			hyperbolic sine
    	cosh()			hyperbolic cosine
    	tanh()			hyperbolic tangent
    	isnan()			check for not a number
de: Gleitpunktberechnung:				*float-functions*
    	float2nr()		konvertiert Gleitpunktzahl zu Ganzzahl
    	abs()			Absolut-Wert (funktioniert auch für Ganzzahl)
    	round()			rundet
    	ceil()			rundet auf
    	floor()			rundet ab
    	trunc()			entfernt Wert nach Dezimalpunkt
    	fmod()			Rest der Division
    	exp()			Exponentialwert zur Basis e
    	log()			natürlicher Logarithmus (Logarithmus
    				zur Basis e)
    	log10()			Logarithmus zur Basis 10
    	pow()			Wert von x hoch y
    	sqrt()			Quadratwurzel
    	sin()			Sinus
    	cos()			Cosinus
    	asin()			Arkussinus
    	acos()			Arkuscosinus
    	atan()			Arkustangens
    	atan2()			Arkustangens
    	sinh()			Sinus hyperbolicus
    	cosh()			Cosinus hyperbolicus
    	tanh()			Tangens hyperbolicus
    	isnan()			Überprüfung, ob kein Wert vorliegt

note: type: Plain text
en: Other computation:					*bitwise-function*
    	and()			bitwise AND
    	invert()		bitwise invert
    	or()			bitwise OR
    	xor()			bitwise XOR
    	sha256()		SHA-256 hash
de: Andere Berechnungen:				*bitwise-function*
    	and()			bitweises AND
    	invert()		bitweises Inverteren
    	or()			bitweises OR
    	xor()			bitweises XOR
    	sha256()		SHA-256-Prüfsumme

note: type: Plain text
en: Variables:						*var-functions*
    	type()			type of a variable
    	islocked()		check if a variable is locked
    	funcref()		get a Funcref for a function reference
    	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
    	gettabvar()		get a variable from specific tab page
    	gettabwinvar()		get a variable from specific window & tab page
    	setwinvar()		set a variable in a specific window
    	settabvar()		set a variable in a specific tab page
    	settabwinvar()		set a variable in a specific window & tab page
    	garbagecollect()	possibly free memory
de: Variablen:						*var-functions*
    	type()			Typ einer Variablen
    	islocked()		prüft, ob eine Variable gelockt ist
    	funcref()		liefert ein Funcref für eine Funktionsreferenz
    	function()		liefert ein Funcref 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
    	gettabvar()		liefert eine Variable für eine bestimmte
    				Reiterseite
    	gettabwinvar()		liefert eine Variable für bestimmtes Fenster
    				und Reiterseite
    	setwinvar()		setzt eine Variable in einem bestimmten
    				Fenster
    	settabvar()		setzt eine Variable für eine bestimmte
    				Reiterseite
    	settabwinvar()		setzt eine Variable für bestimmtes Fenster und
    				Reiterseite
    	garbagecollect()	gibt möglicherweise Speicher frei

note: type: Plain text
en: Cursor and mark position:		*cursor-functions* *mark-functions*
    	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
    	screencol()		get screen column of the cursor
    	screenrow()		get screen row of the cursor
    	screenpos()		screen row and col of a text character
    	getcurpos()		get position of the cursor
    	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
    	screenattr()		get attribute at a screen line/row
    	screenchar()		get character code at a screen line/row
    	screenchars()		get character codes at a screen line/row
    	screenstring()		get string of characters at a screen line/row
de: Cursor- und Markierungsposition:	*cursor-functions* *mark-functions*
    	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
    	screencol()		liefert Bildschirmspalte des Cursors
    	screenrow()		liefert Bildschirmzeile des Cursors
    	screenpos()		Bildschirmreihe und -spalte eines Textzeichens
    	getcurpos()		liefert Position des Cursors
    	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
    	screenattr()		liefert Attribut an einer
    				Bildschirmzeile/-reihe
    	screenchar()		liefert Zeichencode an einer
    				Bildschirmzeile/-reihe
    	screenchars()		liefert Zeichencodes an einer
    				Bildschirmzeile/-reihe
    	screenstring()		liefert Zeichenkette an einer
    				Bildschirmzeile/-reihe

note: type: Plain text
en: Working with text in the current buffer:		*text-functions*
    	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
    	getcharsearch()		return character search information
    	setcharsearch()		set character search information
de: Arbeiten mit dem Text im aktuellen Puffer:		*text-functions*
    	getline()		liefert eine Zeile oder Liste von Zeilen aus
    				dem 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 nichtleere Zeile
    	prevnonblank()		findet vorige nichtleere 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
    	getcharsearch()		liefert Informationen zur Zeichensuche
    				zurück
    	setcharsearch()		setzt Informationen zur Zeichensuche

note: type: Plain text
en: Working with text in another buffer:
    	getbufline()		get a list of lines from the specified buffer
    	setbufline()		replace a line in the specified buffer
    	appendbufline()		append a list of lines in the specified buffer
    	deletebufline()		delete lines from a specified buffer
de: Arbeiten mit Text in einem anderen Puffer:
    	getbufline()		liefert eine Liste von Zeile des angegebenen
    				Puffers
    	setbufline()		ersetzt eine Zeile im angegebenen Puffer
    	appendbufline()		fügt eine Liste von Zeilen im angegebenen
    				Puffer an
    	deletebufline()		löscht Zeilen aus einem angegebenen Puffer

note: type: Plain text
en: 					*system-functions* *file-functions*
    System functions and manipulation of files:
    	glob()			expand wildcards
    	globpath()		expand wildcards in a number of directories
    	glob2regpat()		convert a glob pattern into a search pattern
    	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
    	exepath()		full path of an executable program
    	filereadable()		check if a file can be read
    	filewritable()		check if a file can be written to
    	getfperm()		get the permissions of a file
    	setfperm()		set 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| or |:tcd|
    	tempname()		get the name of a temporary file
    	mkdir()			create a new directory
    	chdir()			change current working directory
    	delete()		delete a file
    	rename()		rename a file
    	system()		get the result of a shell command as a string
    	systemlist()		get the result of a shell command as a list
    	environ()		get all environment variables
    	getenv()		get one environment variable
    	setenv()		set an environment variable
    	hostname()		name of the system
    	readfile()		read a file into a List of lines
    	readdir()		get a List of file names in a directory
    	writefile()		write a List of lines or Blob into a file
de: 					*system-functions* *file-functions*
    Systemfunktionen und Manipulation von Dateien:
    	glob()			expandiert Wildcards
    	globpath()		expandiert Wildcards in einer Reihe von
    				Verzeichnissen
    	glob2regpat()		konvertiert ein Wildcard-Muster in ein
    				(Vim-)Suchmuster
    	findfile()		findet eine Datei in einer Liste von
    				Verzeichnissen
    	finddir()		findet ein Verzeichnis in einer Liste von
    				Verzeichnissen
    	resolve()		findet heraus, wohin ein Verweis 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
    	exepath()		vollständiger Pfad eines ausführbaren Programms
    	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
    	setfperm()		setzt 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| oder
    				|:tcd| verwendet hat
    	tempname()		liefert den Namen einer temporären Datei
    	mkdir()			erzeugt ein neues Verzeichnis
    	chdir()			wechselt das aktuelle Arbeitsverzeichnis
    	delete()		löscht eine Datei
    	rename()		benennt eine Datei um
    	system()		liefert das Ergebnis eines Shell-Befehls als
    				Zeichenkette
    	systemlist()		liefert das Ergebnis eines Shell-Befehls als
    				Liste
    	hostname()		Rechnername
    	readfile()		lese eine Datei in eine Liste von Zeilen
    	readdir()		liefert eine Liste von Dateinamen in einem
    				Verzeichnis
    	writefile()		schreibe eine Liste von Zeilen in eine Datei

note: type: Plain text
en: Date and Time:				*date-functions* *time-functions*
    	getftime()		get last modification time of a file
    	localtime()		get current time in seconds
    	strftime()		convert time to a string
    	strptime()		convert a date/time string to time
    	reltime()		get the current or elapsed time accurately
    	reltimestr()		convert reltime() result to a string
    	reltimefloat()		convert reltime() result to a Float
de: Datum und Uhrzeit:			*date-functions* *time-functions*
    	getftime()		liefert Zeit der letzten Modifikation
    				einer Datei
    	localtime()		liefert aktuelle Zeit in Sekunden
    	strftime()		konvertiert Zeit in eine Zeichenkette
    	strptime()		konvertiert Zeichenkette aus Datum/Uhrzeit in
    				eine (Unix-)Zeit
    	reltime()		liefert die aktuelle oder vergangene Zeit
    				akkurat
    	reltimestr()		konvertiert Ergebnis von reltime() in eine
    				Zeichenkette
    	reltimefloat()		konvertiert Ergebnis von reltime() in eine
    				Gleitpunktzahl (Float)

note: type: Plain text
en: 			*buffer-functions* *window-functions* *arg-functions*
    Buffers, windows and the argument list:
    	argc()			number of entries in the argument list
    	argidx()		current position in the argument list
    	arglistid()		get id of the argument list
    	argv()			get one entry from the argument list
    	bufadd()		add a file to the list of buffers
    	bufexists()		check if a buffer exists
    	buflisted()		check if a buffer exists and is listed
    	bufload()		ensure a buffer is loaded
    	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
    	bufwinid()		get the window ID of a specific buffer
    	bufwinnr()		get the window number of a specific buffer
    	winbufnr()		get the buffer number of a specific window
    	listener_add()		add a callback to listen to changes
    	listener_flush()	invoke listener callbacks
    	listener_remove()	remove a listener callback
    	win_findbuf()		find windows containing a buffer
    	win_getid()		get window ID of a window
    	win_gotoid()		go to window with ID
    	win_id2tabwin()		get tab and window nr from window ID
    	win_id2win()		get window nr from window ID
    	getbufinfo()		get a list with buffer information
    	gettabinfo()		get a list with tab page information
    	getwininfo()		get a list with window information
    	getchangelist()		get a list of change list entries
    	getjumplist()		get a list of jump list entries
    	swapinfo()		information about a swap file
    	swapname()		get the swap file path of a buffer
de: 			*buffer-functions* *window-functions* *arg-functions*
    Puffer, Fenster und die Argumentenliste:
    	argc()			Anzahl von Einträgen in der Argumentenliste
    	argidx()		aktuelle Position in der Argumentenliste
    	arglistid()		liefert ID der Argumentenliste
    	argv()			liefert einen Eintrag aus der Argumentenliste
    	bufadd()		fügt eine Datei der Liste von Puffern hinzu
    	bufexists()		prüft, ob ein Puffer existiert
    	buflisted()		prüft, ob ein Puffer existiert und gelistet ist
    	bufload()		stellt sicher dass ein Puffer geladen 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
    	bufwinid()		liefert die Fenster-ID eines angegebenen
    				Puffers
    	bufwinnr()		liefert die Fensternummer eines bestimmten
    				Puffers
    	winbufnr()		liefert die Puffernummer eines bestimmten
    				Fensters
    	listener_add()		fügt einen Callback hinzu, um Änderungen zu
    				verfolgen
    	listener_flush()	ruft Listener-Callbacks auf
    	listener_remove()	entfernt einen Listener-Callback
    	win_findbuf()		findet Fenster, die einen Puffer enthalten
    	win_getid()		liefert die Fenster-ID eines Fensters
    	win_gotoid()		geht zum Fenster mit der angegebenen ID
    	win_id2tabwin()		liefert Reiter und Fenster-Nr von Fenster-ID
    	getbufinfo()		liefert eine Liste mit Pufferinformationen
    	gettabinfo()		liefert eine Liste mit
    				Reiterseiteninformationen
    	getwininfo()		liefert eine Liste mit Fensterinformationen
    	getchangelist()		liefert eine Liste von
    				Änderungslisteneinträgen
    	getjumplist()		liefert eine Liste von Sprunglisteneinträgen
    	swapinfo()		Informationen über eine Auslagerungsdatei
    	swapname()		liefert den Auslagerungsdateipfad eines Puffers

note: type: Plain text
en: Command line:					*command-line-functions*
    	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
    	getcmdwintype()		return the current command-line window type
    	getcompletion()		list of command-line completion matches
de: Befehlszeile:					*command-line-functions*
    	getcmdline()		liefert die aktuelle Befehlszeile
    	getcmdpos()		liefert Position des Cursors in der
    				Befehlszeile
    	setcmdpos()		setzt Position des Cursors in der Befehlszeile
    	getcmdtype()		gibt den aktuellen Befehlszeilentyp zurück
    	getcmdwintype()		gibt den aktuellen Befehlszeilenfenstertyp
    				zurück
    	getcompletion()		Liste von Übereinstimmungen der
    				Befehlszeilenvervollständigung

note: type: Plain text
en: Quickfix and location lists:			*quickfix-functions*
    	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:			*quickfix-functions*
    	getqflist()		Liste von Quickfix-Fehlern
    	setqflist()		modifiziert eine Quickfix-Liste
    	getloclist()		Liste von Lokationslisten-Elementen
    	setloclist()		modifiziert eine Lokationsliste

note: type: Plain text
en: Insert mode completion:				*completion-functions*
    	complete()		set found matches
    	complete_add()		add to found matches
    	complete_check()	check if completion should be aborted
    	complete_info()		get current completion information
    	pumvisible()		check if the popup menu is displayed
    	pum_getpos()		position and size of popup menu if visible
de: Vervollständigung im Einfügemodus:			*completion-functions*
    	complete()		setzt gefundene Übereinstimmungen
    	complete_add()		fügt zu gefundenen Übereinstimmungen hinzu
    	complete_check()	prüft, ob Vervollständigung abgebrochen werden
    				sollte
    	complete_info()		liefert Informationen zur aktuellen
    				Vervollständigung
    	pumvisible()		prüft ob das Aufklappmenü angezeigt wird
    	pum_getpos()		Position und Größe des Aufklappmenüs
    				falls sichtbar

note: type: Plain text
en: Folding:					*folding-functions*
    	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:						*folding-functions*
    	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

note: type: Plain text
en: Syntax and highlighting:	  *syntax-functions* *highlighting-functions*
    	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
    	synstack()		get list of syntax IDs at a specific position
    	synconcealed()		get info about concealing
    	diff_hlID()		get highlight ID for diff mode at a position
    	matchadd()		define a pattern to highlight (a "match")
    	matchaddpos()		define a list of positions to highlight
    	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:	  *syntax-functions* *highlighting-functions*
    	clearmatches()		löscht alle von |matchadd()| und den |:match|-
    				Befehlen definierte Übereinstimmungen
    	getmatches()		liefert 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
    	synstack()		liefert Liste von Syntax-IDs an bestimmter
    				Position
    	synconcealed()		liefert Infos über Verschleierung
    	diff_hlID()		liefert Hervorhebungs-ID für den Diff-Modus
    				an einer Position
    	match()			definiert ein Hervorhebungsmuster (»match«,
    				Übereinstimmung)
    	matchpos()		definiert eine Liste hervorzuhebender Positionen
    	matcharg()		liefert Informationen über Argumente
    				von |:match|
    	matchdelete()		löscht eine von |matchadd()| oder den |:match|-
    				Befehlen definierte Übereinstimmung
    	setmatches()		stellt eine von |getmatches()| gespeicherte
    				Liste von Übereinstimmungen wieder her

note: type: Plain text
en: Spelling:					*spell-functions*
    	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:				*spell-functions*
    	spellbadword()		findet falsch geschriebenes Wort am
    				oder nach dem Cursor
    	spellsuggest()		liefert vorgeschlagene Schreibungskorrekturen
    				zurück
    	soundfold()		liefert die ähnlich klingende Entsprechung
    				eines Wortes zurück

note: type: Plain text
en: History:					*history-functions*
    	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:					*history-functions*
    	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

note: type: Plain text
en: Interactive:					*interactive-functions*
    	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
    	getmousepos()		get last known mouse position
    	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:					*interactive-functions*
    	browse()		öffnet eine Dateiabfrage
    	browsedir()		öffnet eine Verzeichnisabfrage
    	confirm()		lässt den Anwender eine Auswahl machen
    	getchar()		holt ein Zeichen vom Anwender
    	getcharmod()		liefert die Modifikatoren für das letzte
    				eingegebene Zeichen
    	getmousepos()		liefert letzte bekannte Mausposition
    	feedkeys()		setzt Zeichen in die Vorauseingabeschleife
    				(typeahead)
    	input()			holt eine Zeile vom Anwender
    	inputlist()		lässt den Anwender einen Eintrag aus einer
    				Liste auswählen
    	inputsecret()		holt eine Zeile vom Anwender ohne sie
    				anzuzeigen
    	inputdialog()		holt eine Zeile vom Anwender in einem Dialog
    	inputsave()		speichert und löscht Vorauseingabe
    	inputrestore()		stellt die Vorauseingabe wieder her

note: type: Plain text
en: GUI:						*gui-functions*
    	getfontname()		get name of current font being used
    	getwinpos()		position of the Vim window
    	getwinposx()		X position of the Vim window
    	getwinposy()		Y position of the Vim window
    	balloon_show()		set the balloon content
    	balloon_split()		split a message for a balloon
    	balloon_gettext()	get the text in the balloon
de: GUI:						*gui-functions*
    	getfontname()		liefert den Namen der aktuell benutzten
    				Schriftart
    	getwinposx()		X-Position des Vim-Fensters
    	getwinposy()		Y-Position des Vim-Fensters
    	balloon_show()		setzt Inhalt der Sprechblase
    	balloon_split()		teilt eine Nachricht für eine Sprechblase auf
    	balloon_gettext()	liefert den Text in der Sprechblase

note: type: Plain text
en: Vim server:					*server-functions*
    	serverlist()		return the list of server names
    	remote_startserver()	run a server
    	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:					*server-functions*
    	serverlist()		gibt Liste von Server-Namen zurück
    	remote_startserver()	lässt Vim als Server laufen
    	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

note: type: Plain text
en: Window size and position:			*window-size-functions*
    	winheight()		get height of a specific window
    	winwidth()		get width of a specific window
    	win_screenpos()		get screen position of a window
    	winlayout()		get layout of windows in a tab page
    	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:			*window-size-functions*
    	winheight()		liefert die Höhe eines bestimmten Fensters
    	winwidth()		liefert die Breite eines bestimmten Fensters
    	win_screenpos()		liefert Bildschirmposition eines Fensters
    	winlayout()		liefert Fensterlayout in Reiterseite
    	winrestcmd()		gibt Befehl zurück, um Fenstergrößen
    				wiederherzustellen
    	winsaveview()		liefert Ansicht des aktuellen Fensters
    	winrestview()		stellt gespeicherte Ansicht des aktuellen
    				Fensters wieder her

note: type: Plain text
en: Mappings:				    *mapping-functions*
    	hasmapto()		check if a mapping exists
    	mapcheck()		check if a matching mapping exists
    	maparg()		get rhs of a mapping
    	wildmenumode()		check if the wildmode is active
de: Tastenbelegungen:		    *mapping-functions*
    	hasmapto()		prüft ob eine Belegung existiert
    	mapcheck()		prüft ob eine übereinstimmende Belegung
    				existiert
    	maparg()		liefert rechte Seite einer Tastenbelegung
    	wildmenumode()		prüft ob 'wildmenu'/'wildmode' aktiv ist

note: type: Plain text
en: Testing:				    *test-functions*
    	assert_equal()		assert that two expressions values are equal
    	assert_equalfile()	assert that two file contents are equal
    	assert_notequal()	assert that two expressions values are not equal
    	assert_inrange()	assert that an expression is inside a range
    	assert_match()		assert that a pattern matches the value
    	assert_notmatch()	assert that a pattern does not match the value
    	assert_false()		assert that an expression is false
    	assert_true()		assert that an expression is true
    	assert_exception()	assert that a command throws an exception
    	assert_beeps()		assert that a command beeps
    	assert_fails()		assert that a command fails
    	assert_report()		report a test failure
    	test_alloc_fail()	make memory allocation fail
    	test_autochdir()	enable 'autochdir' during startup
    	test_override()		test with Vim internal overrides
    	test_garbagecollect_now()   free memory right now
    	test_getvalue()		get value of an internal variable
    	test_ignore_error()	ignore a specific error message
    	test_null_blob()	return a null Blob
    	test_null_channel()	return a null Channel
    	test_null_dict()	return a null Dict
    	test_null_job()		return a null Job
    	test_null_list()	return a null List
    	test_null_partial()	return a null Partial function
    	test_null_string()	return a null String
    	test_settime()		set the time Vim uses internally
    	test_setmouse()		set the mouse position
    	test_feedinput()	add key sequence to input buffer
    	test_option_not_set()	reset flag indicating option was set
    	test_scrollbar()	simulate scrollbar movement in the GUI
de: Testen:				    *test-functions*
    	assert_equal		verknüpft dass zwei Ausdruckswerte gleich sind
    	assert_equalfile	verknüpft dass zwei Dateiinhalte gleich sind
    	assert_notequal	verknüpft dass zwei Ausdruckswerte nicht gleich sind
    	assert_inrange()	verknüpft dass ein Ausdruck in einem Bereich ist
    	assert_match()		verknüpft dass ein Muster mit dem Wert
    				übereinstimmt
    	assert_notmatch()	verknüpft dass ein Muster nicht mit dem Wert
    				übereinstimmt
    	assert_false()		verknüpft dass ein Ausdruck falsch ist
    	assert_true()		verknüpft dass ein Ausdruck wahr ist
    	assert_exception()	verknüpft dass ein Befehl eine Ausnahme auslöst
    	assert_beeps()		verknüpft dass ein Befehl einen Signalton
    				ausgibt
    	assert_fails()		verknüpft dass ein Befehl scheitert
    	assert_report()		berichtet das Scheitern des Tests
    	test_alloc_fail()	lässt das Allozieren von Speicher scheitern
    	test_autochdir()	aktiviert 'autochdir' während des Startens
    	test_override()		testet mit Vim-internen Außerkraftsetzungen
    	test_garbagecollect_now()	gibt sofort Speicher frei
    	test_getvalue()		liefert Wert einer internen Variablen
    	test_ignore_error()	ignoriert eine bestimmte Fehlermeldung
    	test_null_blob()	gibt ein Blob, das null ist, zurück
    	test_null_channel()	gibt einen Channel, der null ist, zurück
    	test_null_dict()	gibt ein Dict, das null ist, zurück
    	test_null_job()		gibt einen Job, der null ist, zurück
    	test_null_list()	gibt eine Liste, die null ist, zurück
    	test_null_partial()	gibt eine partielle Funktion, die null ist,
    				zurück
    	test_null_string()	gibt eine Zeichenkette, die null ist, zurück
    	test_settime()		setzt Zeit, die Vim intern verwendet
    	test_setmouse()		setzt die Mausposition
    	test_feedinput()	fügt Tastenfolge zu Eingabepuffer hinzu
    	test_option_not_set()	löscht Marker, der anzeigt,
    				dass eine Option gesetzt wurde
    	test_scrollbar()	simuliert Rollleistenbewegung in der GUI

note: type: Plain text
en: Inter-process communication:		    *channel-functions*
    	ch_canread()		check if there is something to read
    	ch_open()		open a channel
    	ch_close()		close a channel
    	ch_close_in()		close the in part of a channel
    	ch_read()		read a message from a channel
    	ch_readblob()		read a Blob from a channel
    	ch_readraw()		read a raw message from a channel
    	ch_sendexpr()		send a JSON message over a channel
    	ch_sendraw()		send a raw message over a channel
    	ch_evalexpr()		evaluates an expression over channel
    	ch_evalraw()		evaluates a raw string over channel
    	ch_status()		get status of a channel
    	ch_getbufnr()		get the buffer number of a channel
    	ch_getjob()		get the job associated with a channel
    	ch_info()		get channel information
    	ch_log()		write a message in the channel log file
    	ch_logfile()		set the channel log file
    	ch_setoptions()		set the options for a channel
    	json_encode()		encode an expression to a JSON string
    	json_decode()		decode a JSON string to Vim types
    	js_encode()		encode an expression to a JSON string
    	js_decode()		decode a JSON string to Vim types
de: Interprocesskommunikation:		    *channel-functions*
    	ch_canread()		prüft ob es etwas zu lesen gibt
    	ch_open()		öffnet einen Kanal
    	ch_close()		schließt einen Kanal
    	ch_close_in()		schließt den Eingabeteil eines Kanals
    	ch_read()		liest eine Nachricht aus einem Kanal
    	ch_readblob()		liest ein Blob aus einem Kanal
    	ch_readraw()		liest eine Rohnachricht aus einem Kanal
    	ch_sendexpr()		verschickt eine JSON-Nachricht über einen Kanal
    	ch_sendraw()		verschickt eine Rohnachricht über einen Kanal
    	ch_evalexpr()		wertet einen Ausdruck über einen Kanal aus
    	ch_evalraw()		wertet eine Rohzeichenkette über einen Kanal aus
    	ch_status()		liefert Zustand eines Kanals
    	ch_getbufnr()		liefert Puffernummer eines Kanals
    	ch_getjob()		lieftert mit einem Kanal verknüpften Job
    	ch_info()		liefert Kanalinformationen
    	ch_log()		schreibt eine Nachricht in die Protokoldatei
    				von Kanal
    	ch_logfile()		setzt Protokoldatei von Kanal
    	ch_setoptions()		setzt die Optionen für einen Kanal
    	json_encode()		kodiert einen Ausdruck in JSON-Zeichenkette
    	json_decode()		dekodiert JSON-Zeichenkette in Vim-Typen
    	js_encode()		kodiert einen Ausdruck in JSON-Zeichenkette
    	js_decode()		dekodiert JSON-Zeichenkette in Vim-Typen

note: type: Plain text
en: Jobs:		    			        *job-functions*
    	job_start()		start a job
    	job_stop()		stop a job
    	job_status()		get the status of a job
    	job_getchannel()	get the channel used by a job
    	job_info()		get information about a job
    	job_setoptions()	set options for a job
de: Jobs:					        *job-functions*
    	job_start()		startet einen Job
    	job_stop()		beendet einen Job
    	job_status()		liefert den Zustand eines Jobs
    	job_getchannel()	liefert den von einem Job verwendeten Kanal
    	job_info()		liefert Informationen über einen Job
    	job_setoptions()	setzt Optionen für einen Job

note: type: Plain text
en: Signs:						*sign-functions*
    	sign_define()		define or update a sign
    	sign_getdefined()	get a list of defined signs
    	sign_getplaced()	get a list of placed signs
    	sign_jump()		jump to a sign
    	sign_place()		place a sign
    	sign_placelist()	place a list of signs
    	sign_undefine()		undefine a sign
    	sign_unplace()		unplace a sign
    	sign_unplacelist()	unplace a list of signs
de: Zeichen:						*sign-functions*
    	sign_define()		definiert oder aktualisiert ein Zeichen
    	sign_getdefined()	liefert Liste definierter Zeichen
    	sign_getplaced()	liefert Liste platzierter Zeichen
    	sign_jump()		springt zu einem Zeichen
    	sign_place()		platziert ein Zeichen
    	sign_placelist()	platziert Liste von Zeichen
    	sign_undefine()		entfernt Definition eines Zeichens
    	sign_unplace()		entfernt ein Zeichen von seinem Ort
    	sign_unplacelist()	entfernt Liste von Zeichen von ihrem Ort

note: type: Plain text
en: Terminal window:				*terminal-functions*
    	term_start()		open a terminal window and run a job
    	term_list()		get the list of terminal buffers
    	term_sendkeys()		send keystrokes to a terminal
    	term_wait()		wait for screen to be updated
    	term_getjob()		get the job associated with a terminal
    	term_scrape()		get row of a terminal screen
    	term_getline()		get a line of text from a terminal
    	term_getattr()		get the value of attribute {what}
    	term_getcursor()	get the cursor position of a terminal
    	term_getscrolled()	get the scroll count of a terminal
    	term_getaltscreen()	get the alternate screen flag
    	term_getsize()		get the size of a terminal
    	term_getstatus()	get the status of a terminal
    	term_gettitle()		get the title of a terminal
    	term_gettty()		get the tty name of a terminal
    	term_setansicolors()	set 16 ANSI colors, used for GUI
    	term_getansicolors()	get 16 ANSI colors, used for GUI
    	term_dumpdiff()		display difference between two screen dumps
    	term_dumpload()		load a terminal screen dump in a window
    	term_dumpwrite()	dump contents of a terminal screen to a file
    	term_setkill()		set signal to stop job in a terminal
    	term_setrestore()	set command to restore a terminal
    	term_setsize()		set the size of a terminal
de: Terminal-Fenster:				*terminal-functions*
    	term_start()		öffnet ein Terminal-Fenster und führt einen
    				Job aus
    	term_list()		liefert Liste von Terminal-Puffern
    	term_sendkeys()		sendet Tastendrucke an ein Terminal
    	term_wait()		wartet dass Bildschirm aktualisiert wird
    	term_getjob()		liefert den zugehörigen Job zu einem Terminal
    	term_scrape()		liefert Reihe eines Terminal-Bildschirms
    	term_getline()		liefert Textzeile aus einem Terminal
    	term_getattr()		liefert Wert von Attribut {was}
    	term_getcursor()	liefert Cursor-Position eines Terminals
    	term_getscrolled()	liefert Rollanzahl eines Terminals
    	term_getaltscreen()	liefert Marker alternativer Bildschirm
    	term_getsize()		liefert Größe eines Terminals
    	term_getstatus()	liefert Zustand eines Terminals
    	term_gettitle()		liefert Titel eines Terminals
    	term_gettty()		liefert TTY-Namen eines Terminals
    	term_setansicolors()	setzt 16-ANSI-Farben, verwendet für GUI
    	term_getansicolors()	liefert 16-ANSI-Farben, verwendet für GUI
    	term_dumpdiff()		zeigt Unterschiede zwischen zwei
    				Bildschirmabzügen an
    	term_dumpload()		lädt einen Bildschirmabzug in ein Fenster
    	term_dumpwrite()	schreibt Inhalt eines Terminal-Bildschirm
    				in eine Datei
    	term_setkill()		setzt Signal um Job in einem Terminal zu beenden
    	term_setrestore()	setzt Befehl um ein Terminal wiederherzustellen
    	term_setsize()		setzt die Größe eines Terminals

note: type: Plain text
en: Popup window:					*popup-window-functions*
    	popup_create()		create popup centered in the screen
    	popup_atcursor()	create popup just above the cursor position,
    				closes when the cursor moves away
    	popup_beval()		at the position indicated by v:beval_
    				variables, closes when the mouse moves away
    	popup_notification()	show a notification for three seconds
    	popup_dialog()		create popup centered with padding and border
    	popup_menu()		prompt for selecting an item from a list
    	popup_hide()		hide a popup temporarily
    	popup_show()		show a previously hidden popup
    	popup_move()		change the position and size of a popup
    	popup_setoptions()	override options of a popup
    	popup_settext()		replace the popup buffer contents
    	popup_close()		close one popup
    	popup_clear()		close all popups
    	popup_filter_menu()	select from a list of items
    	popup_filter_yesno()	blocks until 'y' or 'n' is pressed
    	popup_getoptions()	get current options for a popup
    	popup_getpos()		get actual position and size of a popup
de: Popup-Fenster:					*popup-window-functions*
    	popup_create()		erzeugt Popup mittig auf dem Bildschirm
    	popup_atcursor()	erzeugt Popup direkt über der Cursor-Position,
    				schließt wenn sich der Cursor weiter bewegt
    	popup_beval()		an Position die von v:beval_-Variablen
    				angezeigt wird, schließt wenn sich die Maus
    				weiter bewegt
    	popup_notification()	zeigt Benachrichtigung für drei Sekunden
    	popup_dialog()		erzeugt mittigen Popup mit Auffüllung und
    				Umrandung
    	popup_menu()		Auswahlaufforderung eines Elements
    				aus einer Liste
    	popup_hide()		versteckt ein Popup zeitweise
    	popup_show()		zeigt ein zuvor verstecktes Popup an
    	popup_move()		ändert Position und Größe eines Popups
    	popup_setoptions()	überstimmt Optionen eines Popups
    	popup_settext()		ersetzt Inhalt von Popup-Puffer
    	popup_close()		schließt ein Popup
    	popup_clear()		schließt alle Popups
    	popup_filter_menu()	wählt aus Liste von Elementen aus
    	popup_filter_yesno()	blockiert bis 'y' oder 'n' gedrückt werden
    	popup_getoptions()	liefert aktuelle Optionen eines Popups
    	popup_getpos()		liefert tatsächliche Position und Größe
    				eines Popups

note: type: Plain text
en: Timers:						*timer-functions*
    	timer_start()		create a timer
    	timer_pause()		pause or unpause a timer
    	timer_stop()		stop a timer
    	timer_stopall()		stop all timers
    	timer_info()		get information about timers
de: Zeitgeber:						*timer-functions*
    	timer_start()		erzeugt einen Zeitgeber
    	timer_pause()		hält einen Zeitgeber an oder lässt weiter laufen
    	timer_stop()		beendet einen Zeitgeber
    	timer_stopall()		beendet alle Zeitgeber
    	timer_info()		liefert Informationen über Zeitgeber

note: type: Plain text
en: Tags:						*tag-functions*
    	taglist()		get list of matching tags
    	tagfiles()		get a list of tags files
    	gettagstack()		get the tag stack of a window
    	settagstack()		modify the tag stack of a window
de: Tags:						*tag-functions*
    	taglist()		liefert Liste übereinstimmender Tags
    	tagfiles()		liefert Liste von Tag-Dateien
    	gettagstack()		liefert den Tag-Stack eines Fensters
    	settagstack()		verändert den Tag-Stack eines Fensters

note: type: Plain text
en: Prompt Buffer:					*promptbuffer-functions*
    	prompt_setcallback()	set prompt callback for a buffer
    	prompt_setinterrupt()	set interrupt callback for a buffer
    	prompt_setprompt()	set the prompt text for a buffer
de: Eingabepuffer:					*promptbuffer-functions*
    	prompt_setcallback()	setzt Prompt-Callback für einen Puffer
    	prompt_setinterrupt()	setzt Interrupt-Callback für einen Puffer
    	prompt_setprompt()	setzt Text für Eingabeaufforderung
    				für einen Puffer

note: type: Plain text
en: Various:					*various-functions*
    	mode()			get current editing mode
    	visualmode()		last visual mode used
    	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:					*various-functions*
    	mode()			liefert aktuellen Editiermodus
    	visualmode()		der letzte benutzte visuelle Modus
    	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

note: type: Plain text
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

note: type: Plain text
en: 	undofile()		get the name of the undo file
    	undotree()		return the state of the undo tree
de: 	undofile()		liefert den Namen der Rücknahmedatei
    	undotree()		gibt den Zustand des Rücknahmebaums zurück

note: type: Plain text
en: 	getreg()		get contents of a register
    	getregtype()		get type of a register
    	setreg()		set contents and type of a register
    	reg_executing()		return the name of the register being executed
    	reg_recording()		return the name of the register being recorded
de: 	getreg()		liefert Inhalt eines Registers
    	getregtype()		liefert Typ eines Registers
    	setreg()		setzt Inhalt und Typ eines Registers
    	reg_executing()		gibt den Namen des gerade ausgeführten
    				Registers zurück
    	reg_recording()		gibt den Namen des Registers, in das
    				gerade aufgezeichnet wird, zurück

note: type: Plain text
en: 	shiftwidth()		effective value of 'shiftwidth'
de: 	shiftwidth()		effektiver Wert von 'shiftwidth

note: type: Plain text
en: 	wordcount()		get byte/word/char count of buffer
de: 	wordcount()		liefert Byte/Wort/Zeichen-Anzahl von Puffer

note: type: Plain text
en: 	luaeval()		evaluate Lua expression
    	mzeval()		evaluate |MzScheme| expression
    	perleval()		evaluate Perl expression (|+perl|)
    	py3eval()		evaluate Python expression (|+python3|)
    	pyeval()		evaluate Python expression (|+python|)
    	pyxeval()		evaluate |python_x| expression
    	debugbreak()		interrupt a program being debugged
de: 	luaeval()		wertet Lua-Ausdruck aus
    	mzeval()		wertet |MzScheme|-Ausdruck aus
    	perleval()		wertet Perl-Ausdruck aus (|+perl|)
    	py3eval()		wertet Python-Ausdruck aus (|+python3|)
    	pyeval()		wertet Python-Ausdruck aus (|+python|)
    	pyxeval()		wertet |python_x|-Ausdruck aus
    	debugbreak()		unterbricht ein Programm,
    				das gerade zur Fehlersuche läuft

note: type: Plain text
en: *41.7*	Defining a function
de: *41.7*	Eine Funktion definieren

note: type: Plain text
en: Vim enables you to define your own functions.  The basic function declaration begins as follows: >
de: Vim lässt Sie eigene Funktionen definieren. Die grundlegende Funktionsdeklaration beginnt wie folgt: >

note: type: Plain text
en: 	:function {name}({var1}, {var2}, ...)
    	:  {body}
    	:endfunction
    <
    	Note:
    	Function names must begin with a capital letter.
de: 	:function {Name}({var1}, {var2}, ...)
    	:  {Rumpf}
    	:endfunction
    <
    	Anmerkung:
    	Funktionsnamen müssen mit einem Großbuchstaben beginnen.

note: type: Plain text
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, welche die kleinere von zwei Zahlen zurückgibt. Sie beginnt mit dieser Zeile: >

note: type: Plain text
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 annimmt,
    »num1«
     und »num2«.
       Als erstes müssen wir überprüfen, welche Zahl kleiner ist:
       >
    	:  if a:num1 < a:num2

note: type: Plain text
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 Funktionsargument ist. Weisen wir nun der Variablen »kleiner« den Wert der kleineren Zahl zu: >

note: type: Plain text
en: 	:  if a:num1 < a:num2
    	:    let smaller = a:num1
    	:  else
    	:    let smaller = a:num2
    	:  endif
de: 	:  if a:num1 < a:num2
    	:    let kleiner = a:num1
    	:  else
    	:    let kleiner = a:num2
    	:  endif

note: type: Plain text
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 »kleiner« ist eine lokale Variable. In einer Funktion verwendete Variablen sind lokal, solange ihnen nicht »g:«, »a:«, oder »s:« vorangestellt wird.

note: type: Plain text
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. Somit wird innerhalb einer Funktion
    	»g:heute« für die globale Variable »heute« verwendet, und »heute« ist	eine andere, zur Funktion lokale Variable.

note: type: Plain text
en: You now use the ":return" statement to return the smallest number to the user.  Finally, you end the function: >
de: Nun verwenden wir die Anweisung »:return« um die kleinere Zahl an den Anwender zurückzugeben. Sie beenden die Funktion schließlich mit: >

note: type: Plain text
en: 	:  return smaller
    	:endfunction
de: 	:  return kleiner
    	:endfunction

note: type: Plain text
en: The complete function definition is as follows: >
de: Die vollständige Funktionsdefinition ist wie folgt: >

note: type: Plain text
en: 	:function Min(num1, num2)
    	:  if a:num1 < a:num2
    	:    let smaller = a:num1
    	:  else
    	:    let smaller = a:num2
    	:  endif
    	:  return smaller
    	:endfunction
de: 	:function Min(num1, num2)
    	:  if a:num1 < a:num2
    	:    let kleiner = a:num1
    	:  else
    	:    let kleiner = a:num2
    	:  endif
    	:  return kleiner
    	:endfunction

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

note: type: Plain text
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 unterschiedlich. Die Funktion Min kann wie folgt verwendet werden: >

note: type: Plain text
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: Nun erst wird die Funktion ausgeführt und die Zeilen werden von Vim interpretiert. Falls es Fehler gibt, wie das Verwenden einer undefinierten Variablen oder Funktion, erhalten Sie nun eine Fehlermeldung. Beim Definieren der Funktion werden diese Fehler nicht erkannt.

note: type: Plain text
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« ohne Argument verwendet wird, gibt die Funktion Null zurück.

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

note: type: Plain text
en: USING A RANGE
de: EINEN BEREICH BENUTZEN

note: type: Plain text
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 übergeben werden. Dies hat zwei
    mögliche Bedeutungen. 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: >

note: type: Plain text
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

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

note: type: Plain text
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 Wörtern 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 im Bereich aufgerufen, mit dem Cursor in dieser Zeile.
    Beispiel: >

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

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

note: type: Plain text
en: VARIABLE NUMBER OF ARGUMENTS
de: VARIABLE ANZAHL VON ARGUMENTEN

note: type: Plain text
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 lässt Sie Funktionen definieren, die eine veränderliche Anzahl von Argumenten haben. Der folgende Befehl zum Beispiel definiert eine Funktion, die ein Argument haben muss (start) und bis zu 20 zusätzliche Argumente haben kann: >

note: type: Plain text
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: >

note: type: Plain text
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 verwendet den Befehl »:echohl«, um die für den nächsten »:echo«-Befehl verwendete Hervorhebung anzugeben. »:echohl None« deaktiviert dies. Der Befehl »:echon« funktioniert wie »:echo«, gibt aber keinen Zeilenumbruch aus.

note: type: Plain text
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|.

note: type: Plain text
en: LISTING FUNCTIONS
de: FUNKTIONEN AUFLISTEN

note: type: Plain text
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: >

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

note: type: Plain text
en: DEBUGGING
de: FEHLERSUCHE

note: type: Plain text
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.

note: type: Plain text
en: DELETING A FUNCTION
de: EINE FUNKTION LÖSCHEN

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

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

note: type: Plain text
en: FUNCTION REFERENCES
de: FUNKTIONSREFERENZEN

note: type: Plain text
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() erledigen. Sie verwandelt den Namen einer Funktion in eine Referenz: >

note: type: Plain text
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.
       Um eine per Variable referenzierte Funktion aufzurufen, wird die Funktion
    call() verwendet. Ihr erstes Argument ist die Funktionsreferenz, das zweite
    Argument ist ein List-Element mit den Argumenten.

note: type: Plain text
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.

note: type: Plain text
en: *41.8*	Lists and Dictionaries
de: *41.8*	Listen und Wörterbücher

note: type: Plain text
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: List und Dictionary (Wörterbuch).

note: type: Plain text
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 Dingen. Die Dinge können beliebige Art von Wert sein, somit können Sie eine Liste von Zahlen anlegen, eine Liste von Listen, und sogar eine Liste von gemischten Elementen. Dies erzeugt eine Liste mit drei Zeichenketten: >

note: type: Plain text
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: >

note: type: Plain text
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: >

note: type: Plain text
en: List concatenation is done with +: >
de: Listen werden mit »+« aneinander gehängt: >

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

note: type: Plain text
en: Notice that using add() will have a different effect: >
de: Beachten Sie, dass das Verwenden von add() eine andere Auswirkung hat: >

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

note: type: Plain text
en: FOR LOOP
de: FOR-SCHLEIFE

note: type: Plain text
en: One of the nice things you can do with a List is iterate over it: >
de: Etwas schönes, das Sie mit einer Liste machen können, ist über sie zu iterieren: >

note: type: Plain text
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: >

note: type: Plain text
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 eine bestimmte Anzahl von Schritten zu durchlaufen, benötigen Sie eine Liste einer bestimmten Länge. Die Funktion range() erzeugt Ihnen eine: >

note: type: Plain text
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() ausgibt, Null
    ist, somit ist das letzte Element eins weniger als die Länge der Liste.
       Sie können auch den Maximalwert angeben, die Schrittweite, und sogar
    rückwärts laufen: >

note: type: Plain text
en: A more useful example, looping over lines in the buffer: >
de: Ein nützlicheres Beispiel, das Zeilen im Puffer durchläuft: >

note: type: Plain text
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.

note: type: Plain text
en: DICTIONARIES
de: WÖRTERBÜCHER

note: type: Plain text
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 hält Paare aus Schlüssel und Wert. Man kann schnell einen Wert nachschlagen, wenn man den Schlüssel kennt. Ein Wörterbuch wird mit geschwungenen Klammern erzeugt: >

note: type: Plain text
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: >

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

note: type: Plain text
en: 	{<key> : <value>, ...}
de: 	{<Schlüssel> : <Wert>, ...}

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

note: type: Plain text
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: Wörterbücher haben zahlreiche Anwendungen. Ebenso gibt es für sie verschiedene Funktionen. Zum Beispiel kann man eine Liste der Schlüssel holen und sie durchlaufen: >

note: type: Plain text
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: >

note: type: Plain text
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.

note: type: Plain text
en: DICTIONARY FUNCTIONS
de: WÖRTERBUCHFUNKTIONEN

note: type: Plain text
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 geholt werden: >

note: type: Plain text
en: A method that does the same, but without so many punctuation characters: >
de: Eine Methode mit weniger Satzzeichen, die dasselbe tut: >

note: type: Plain text
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. So kann man auch einen neuen Wert zuweisen: >

note: type: Plain text
en: And now for something special: you can directly define a function and store a reference to it in the dictionary: >
de: Und nun eine Besonderheit: man kann direkt eine Funktion definieren und eine Referenz auf diese im Wörterbuch speichern: >

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

note: type: Plain text
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: Die erste Besonderheit, das Sie bemerken, ist das »dict« am Ende der Zeile
    mit »:function«. Dies markiert die Funktion als eine, die aus einem Wörterbuch
    zu verwenden ist.
    Die Variable »self« referenziert dann dieses Wörterbuch.
       Schauen wir uns den komplizierten Rückgabebefehl nun Stück für Stück an: >

note: type: Plain text
en: The split() function takes a string, chops it into whitespace separated words and returns a list with these words.  Thus in the example it returns: >
de: Die Funktion split() nimmt eine Zeichenkette, trennt sie in durch Leerraum getrennte Wörter, und gibt eine Liste mit diesen Wörtern zurück. Im Beispiel somit: >

note: type: Plain text
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 der Funktion map(). Diese geht durch die Liste und wertet dabei ihr zweites Argument aus, wobei »v:val« auf den Wert jedes Elements gesetzt wird. Dies ist eine Abkürzung gegenüber dem Verwenden einer For-Schleife. Dieser Befehl: >

note: type: Plain text
en: Is equivalent to: >
de: ist gleichbedeutend mit: >

note: type: Plain text
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 angenehme Weise Situationen zu behandeln, in denen ein Schlüssel möglicherweise nicht vorhanden ist und man keine Fehlermeldung möchte.

note: type: Plain text
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 dazwischen setzt.
      Diese Kombination von split(), map() und join() ist eine schöne Weise,
    eine Zeile von Wörtern auf eine sehr kompakte Weise zu filtern.

note: type: Plain text
en: OBJECT ORIENTED PROGRAMMING
de: OBJEKT-ORIENTIERTE PROGRAMMIERUNG

note: type: Plain text
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 legen können,
    können Sie ein Wörterbuch tatsächlich wie ein Objekt benutzen.
       Oben haben wir ein Wörterbuch verwendet, um Niederländisch in Englisch zu
    übersetzen. Vielleicht wollen wir dasselbe für andere Sprachen tun. Legen wir
    zunächst ein Objekt (also Wörterbuch) an, das die Übersetzungsfunktion hat,
    aber keine zu übersetzenden Wörter: >

note: type: Plain text
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: Sie unterscheidet sich ein wenig von der Funktion oben, indem wir 'self.words' verwenden, um Wortübersetzungen nachzuschlagen. Aber wir haben kein self.words. Somit könnte man dies eine abstrakte Klasse nennen.

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

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

note: type: Plain text
en: 	:let uk2de = copy(transdict)
    	:let uk2de.words = {'one': 'eins', 'two': 'zwei', 'three': 'drei'}
    	:echo uk2de.translate('three one')
    <	drei eins ~
de: 	:let uk2de = copy(transdict)
    	:let uk2de.words = {'one': 'eins', 'two': 'zwei', 'three': 'drei'}
    	:echo uk2de.translate('three one')
    <	drei ein ~

note: type: Plain text
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: Wie Sie sehen, wird die Funktion copy() verwendet, um eine Kopie des Wörterbuchs »transdict« anzulegen, und dann diese Kopie verändert, um die Worte aufzunehmen. Das Original bleibt natürlich dasselbe.

note: type: Plain text
en: Now you can go one step further, and use your preferred translator: >
de: Nun können Sie einen Schritt weiter gehen, und Ihren bevorzugten Übersetzer verwenden: >

note: type: Plain text
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 angelegt. Weiteres über die Identität einer List und eines Wörterbuches kann unter |list-identity| und |dict-identity| gefunden werden.

note: type: Plain text
en: Now you might use a language that isn't supported.  You can overrule the translate() function to do nothing: >
de: Nun könnten Sie eine nicht unterstützte Sprache verwendeni. So können Sie die Funktion translate() außer Kraft setzten:

note: type: Plain text
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 ! verwendet wurde, um die bestehende Funktionsreferenz zu überschreiben. Nun verwenden Sie »uk2uk«, falls keine erkannte Sprache gefunden wird: >

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

note: type: Plain text
en: *41.9*	Exceptions
de: *41.9*	Ausnahmen

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

note: type: Plain text
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.
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 eine schöne Meldung.

note: type: Plain text
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 Fehlerfall 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).

note: type: Plain text
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, stimmt das Muster »E484:« nicht überein. Somit wird diese Ausnahme nicht aufgefangen und ergibt die übliche Fehlermeldung.

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

note: type: Plain text
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«.

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

note: type: Plain text
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 zwischen »:try« und »:finally« fehlschlägt, oder der Benutzer das Filtern abbricht, indem er CTRL-C drückt, »call delete(tmp)« wird jederzeit ausgeführt. Dies stellt sicher, dass die temporäre Datei nicht zurück belassen wird.

note: type: Plain text
en: More information about exception handling can be found in the reference manual: |exception-handling|.
de: Weitere Informationen über Ausnahmenbehandlung können im Referenzhandbuch gefunden werden: |exception-handling|.

note: type: Plain text
en: *41.10*	Various remarks
de: *41.10*	Verschiedene Anmerkungen

note: type: Plain text
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-Skripts zutreffen. Sie werden auch anderswo erwähnt, aber bilden eine schöne Prüfliste.

note: type: Plain text
en: The end-of-line character depends on the system.  For Unix a single <NL> character is used.  For MS-Windows 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 Windows und anderen wird <CR><LF> verwendet. Dies ist wichtig, wenn Belegungen verwendet werden, die in einem <CR> enden. Siehe |:source_crnl|.

note: type: Plain text
en: WHITE SPACE
de: LEERRAUM

note: type: Plain text
en: Blank lines are allowed and ignored.
de: Leerzeilen sind erlaubt und werden ignoriert.

note: type: Plain text
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ührender Leerraum (Leerzeichen und Tabulatoren) wird immer ignoriert. Der Leerraum 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 Leerraum nach dem letzten (sichtbaren) Zeichen kann situationsabhängig ignoriert werden oder auch nicht, siehe unten.

note: type: Plain text
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: >

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

note: type: Plain text
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 Leerraumzeichen im Wert einer Option zu verwenden, muss es durch einen »\« (Backslash) geschützt werden, wie im folgenden Beispiel: >

note: type: Plain text
en: The same example written as: >
de: Dasselbe Beispiel geschrieben als: >

note: type: Plain text
en: will issue an error, because it is interpreted as: >
de: ergibt einen Fehler, weil es interpretiert wird als: >

note: type: Plain text
en: COMMENTS
de: KOMMENTARE

note: type: Plain text
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 Zeichenposition auf der Zeile beginnen.

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

note: type: Plain text
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 des '" insert include'. Der »execute«-Befehl ergibt einen
    Fehler. Der »!«-Befehl schickt alles nach ihm stehende an die Shell, was
    einen Fehler wegen eines nicht übereinstimmenden »"«-Zeichens verursacht.
       Nach den Befehlen »:map«, »:abbreviate«, »:execute« und »!« kann kein
    Kommentar stehen (es gibt ein paar weitere Befehle mit dieser Einschränkung).
    Für die Befehle »:map«, »:abbreviate« und »:execute« gibt es einen Trick: >

note: type: Plain text
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 dieser nächste
    Befehl ist nur ein Kommentar. Für den letzten Befehl müssen Sie zwei Dinge
    tun: |:execute| und '|' benutzen: >
    
    	:exe '!ls *.c'			|" list C files

note: type: Plain text
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: Beachten Sie, dass hier kein Leerraum vor dem '|' in der Abkürzung und der Belegung steht. Bei diesen Befehlen wird jedes Zeichen bis zum Zeilenende oder dem '|' einbezogen. Als Konsequenz dieses Verhaltens sieht man nicht immer, dass nachstehender Leerraum einbezogen wird: >

note: type: Plain text
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.

note: type: Plain text
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

note: type: Plain text
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|

note: type: Plain text
en: PITFALLS
de: FALLEN

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

note: type: Plain text
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 nicht, 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.

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

note: type: Plain text
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 Kommentarteil ignoriert. Vim versucht allerdings
    »,ab     «, freizugeben, was nicht existiert. Wir schreiben es um als: >

note: type: Plain text
en: RESTORING THE VIEW
de: DIE ANSICHT WIEDERHERSTELLEN

note: type: Plain text
en: Sometimes you want to make a change and go back to where the 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ückgehen, wo der Cursor
    war. Die relative Position wiederherstellen wäre auch schön, 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: >

note: type: Plain text
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			setzt Markierung a bei Cursor-Position
    	  "aY			kopiert aktuelle Zeile in Register a
    	     Hmb		geht zur obersten Zeile im Fenster und setze
    				dort Markierung b
    		gg		geht zur ersten Zeile der Datei
    		  "aP		setzt kopierte Zeile über sie
    		     `b		geht zurück zur obersten Zeile der Anzeige
    		       zt	positioniert den Text im Fenster wie vorher
    			 `a	geht zurück zur gespeicherten Cursor-Position

note: type: Plain text
en: PACKAGING
de: PAKETIERUNG

note: type: Plain text
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 verwendet.
    
    - Platzieren Sie die Definitionen Ihrer Funktionen gemeinsam in eine Datei.
      Setzen Sie eine globale Variable, die anzeigt, dass die Funktionen   geladen
      wurden. Wenn die Datei erneut eingelesen wird, geben Sie zuerst die
      Funktionen frei.
    
    Beispiel: >

note: type: Plain text
en: 	" This is the XXX package
de: 	" Dies ist das Paket XXX

note: type: Plain text
en: *41.11*	Writing a plugin				*write-plugin*
de: *41.11*	Eine Erweiterung (Plugin) schreiben		*write-plugin*

note: type: Plain text
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 verwenden können. Dies nennt sich Plugin (Erweiterung). Vim-Anwender können Ihr Skript in ihrem Plugin-Verzeichnis ablegen und seine Features auf der Stelle nutzen |add-plugin|.

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

note: type: Plain text
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.

note: type: Plain text
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 Besonderheiten für Dateityp-Plugins folgen im nächsten Abschnitt |write-filetype-plugin|.

note: type: Plain text
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 MS-Windows systems.
de: Zuerst 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 MS-Windows-Systemen zu vermeiden.

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

note: type: Plain text
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 vollständige Beispiel-Plugin steht am Ende.

note: type: Plain text
en: BODY
de: TEXTKÖRPER

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

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

note: type: Plain text
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!

note: type: Plain text
en: HEADER
de: KOPF

note: type: Plain text
en: You will probably add new corrections to the plugin and soon have several versions lying 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: >

note: type: Plain text
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 Lizenzierung: 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 am Beginn des Plugins sollte ausreichend sein. Beispiel: >

note: type: Plain text
en: LINE CONTINUATION, AVOIDING SIDE EFFECTS		*use-cpo-save*
de: ZEILENFORTSETZUNG, NEBENWIRKUNGEN VERMEIDEN		*use-cpo-save*

note: type: Plain text
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 Zeilenfortsetzung benutzt |line-continuation|. Anwender, bei denen 'compatible' gesetzt ist, werden hier Probleme, eine Fehlermeldung bekommen. Wir können nicht einfach 'compatible' zurücksetzen, weil dies viele Nebenwirkungen hat. Um dies zu vermeiden, setzen wir die Option 'cpoptions' auf ihren Vim-Standardwert und stellen sie später wieder her. Das erlaubt das Verwenden von Zeilenfortsetzung und lässt das Skript für die meisten Leute funktionieren. So wird's gemacht: >

note: type: Plain text
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.

note: type: Plain text
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 skriptlokale Variable verwendet wird |s:var|. Eine globale Variable könnte bereits für etwas anderes in Gebrauch sein. Verwenden Sie immer skriptlokale Variablen für Dinge, die nur in dem Skript benutzt werden.

note: type: Plain text
en: NOT LOADING
de: NICHT LADEN

note: type: Plain text
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 Anwender nicht immer dieses Plugin laden möchte. Oder der Systemadministrator hat es in das systemweite Plugin-Verzeichnis gelegt, aber ein Anwender hat sein eigenes Plugin, das er verwenden möchte. Dann muss der Anwender eine Möglichkeit haben, das Laden dieses bestimmten Plugins zu deaktivieren. Dies macht es möglich: >

note: type: Plain text
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, Fehlermeldungen für das Neudefinieren von Funktionen und Schwierigkeiten bei automatischen Befehlen, die zweimal hinzugefügt werden, verursacht werden.

note: type: Plain text
en: The name is recommended to start with "loaded_" and then the file name of the plugin, literally.  The "g:" is prepended just to avoid mistakes when using the variable in a function (without "g:" it would be a variable local to the function).
de: Es empfiehlt sich, dass der Name mit »loaded_« und dann wortwörtlich mit dem Namen des Plugins beginnt. »g:« wird nur vorangestellt, um Fehler zu vermeiden, wenn die Variable in einer Funktion benutzt wird (ohne »g:« wäre sie eine Variable lokal zu dieser Funktion).

note: type: Plain text
en: Using "finish" stops Vim from reading the rest of the file, it's much quicker than using if-endif around the whole file.
de: Das Verwenden von »finish« verhindert, das Vim den Rest der Datei liest, es ist viel schneller als if-endif um die ganze Datei.

note: type: Plain text
en: MAPPING
de: ZUORDNUNGEN

note: type: Plain text
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 Zuordnung hinzu, die eine Korrektur für das Wort unter dem Cursor hinzufügt. Um dem Anwender zu erlauben zu definieren, welche Tasten eine Zuordnung in einem Plugin benutzt, kann das Element <Leader> benutzt werden: >

note: type: Plain text
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.

note: type: Plain text
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 Anwender kann die Variable »mapleader« auf die Tastenfolge setzen, mit der er diese Zuordnung starten lassen möchte. Falls der Anwender also dies macht: >

note: type: Plain text
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 Zuordnung »_a«.  Falls der Nutzer dies nicht tut, wird der Standardwert verwendet, was ein umgekehrter Schrägstrich ist. Dann wird eine Zuordnung für »\a« definiert.

note: type: Plain text
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 Zuordnung der Tastenfolge bereits existiert. |:map-<unique>|

note: type: Plain text
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 Anwender seine eigene Tastenfolge definieren möchte? Wir können dies mit folgendem Mechanismus erlauben: >

note: type: Plain text
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 Zuordnung von »<Plug>TypecorrAdd« bereits existiert, und definiert die Zuordnung von »<Leader>a« nur ansonsten. Der Anwender hat nun die Möglichkeit, dies in seine Vimrc zu packen: >

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

note: type: Plain text
en: PIECES
de: PORTIONEN

note: type: Plain text
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 Zuordnungen verwenden. Aber man will nicht, dass diese Funktionen oder Zuordnungen 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.

note: type: Plain text
en: We will define a function that adds a new typing correction: >
de: Wir definieren eine Funktion, die eine neue Tippkorrektur hinzufügt: >

note: type: Plain text
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.

note: type: Plain text
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 Tippkorrektur-Plugin verwenden wir es folgendermaßen: >

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

note: type: Plain text
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 zuordnen würde, würde es eine andere Skript-ID erhalten, also eine andere Zuordnung definieren.

note: type: Plain text
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 Zuordnung vom Anwender 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.

note: type: Plain text
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 Zuordnungen verwenden, und s:Add() an anderen Stellen (dem Skript selbst, in automatischen Befehlen, Benutzerbefehlen).

note: type: Plain text
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 Zuordnung: >

note: type: Plain text
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üelemente für Plugins hinzuzufügen. In diesem Falle wird nur ein Element verwendet. 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.

note: type: Plain text
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« verwendet wird, um zu vermeiden, dass irgendwelche anderen Zuordnungen Probleme verursachen. Jemand könnte zum Beispiel »:call« neu zugeordnet haben. In Zeile 24 benutzen wir auch »:noremap«, aber wir wollen »<SID>Add« neu zugeordnet haben. Deshalb wird hier »<script>« verwendet. Dies erlaubt nur Zuordnungen, die lokal zum Skript sind |:map-<script>|. Dasselbe passiert in Zeile 26 für »:noremenu« |:menu-<script>|.

note: type: Plain text
en: <SID> AND <Plug>					*using-<Plug>*
de: <SID> UND <Plug>					*using-<Plug>*

note: type: Plain text
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 verwendet, um zu vermeiden, dass Zuordnungen von getippten Tasten Zuordnungen beeinflussen, die nur von anderen Zuordnungen zu verwenden sind. Beachten Sie den Unterschied zwischen <SID> und <Plug>:

note: type: Plain text
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 Zuordnungen
    	verwendet, die der Nutzer möglicherweise mit einer Tastenfolge
    	zuordnen 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, verwende man diese Struktur:
    	<Plug> Skriptname Zuordnungsname.
    	In unserem Beispiel ist der Skriptname »Typecorr« und der
    	Zuordnungsname »Add«. Dies ergibt »<Plug>TypecorrAdd«. Nur das erste
    	Zeichen von Skriptname und Zuordnungsname sind groß, so dass wir
    	sehen können, wo der Zuordnungsname beginnt.

note: type: Plain text
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 Zuordnungen ist
    	exakt dieselbe, deshalb können Sie eine skriptlokale Funktion von
    	einer Zuordnung aufrufen.

note: type: Plain text
en: USER COMMAND
de: ANWENDERBEFEHL

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

note: type: Plain text
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 Anwenderbefehl wird nur definiert, falls noch kein Befehl desselben Namens existiert. Andernfalls würden wir hier einen Fehler bekommen.  Den existierenden Anwenderbefehl mit »:command!« übersteuern, ist keine gute Idee, dies könnte den Nutzer sich fragen lassen, warum der Befehl, den er selbst definiert hat, nicht funktioniert |:command|.

note: type: Plain text
en: SCRIPT VARIABLES
de: SKRIPTVARIABLEN

note: type: Plain text
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 Skriptvariable. 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 verwendet, wenn dasselbe Skript wieder eingelesen wird |s:var|.

note: type: Plain text
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, Autobefehlen und Anwenderbefehlen, 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: >

note: type: Plain text
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, inkrementiert sie s:count. Es ist nicht entscheidend von wo die Funktion aufgerufen wurde, weil sie im Skript definiert wurde, verwendet sie die lokalen Variablen dieses Skripts.

note: type: Plain text
en: THE RESULT
de: DAS ERGEBNIS

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

note: type: Plain text
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 Zuordnungen und Abkürzungen hier expandiert werden, selbst wenn die Funktion von einer Zuordnung aufgerufen wurde, die mit »:noremap« definiert wurde.

note: type: Plain text
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: >

note: type: Plain text
en: DOCUMENTATION						*write-local-help*
de: DOKUMENTATION						*write-local-help*

note: type: Plain text
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|.

note: type: Plain text
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«

note: type: Plain text
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 Hilfedatei extrahiert, um in den Abschnitt »LOCAL ADDITIONS« 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.

note: type: Plain text
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 Hilfedatei 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.

note: type: Plain text
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.

note: type: Plain text
en: FILETYPE DETECTION					*plugin-filetype*
de: DATEITYP-ERKENNUNG					*plugin-filetype*

note: type: Plain text
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: >

note: type: Plain text
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 verwendet wird.

note: type: Plain text
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|

note: type: Plain text
en: SUMMARY							*plugin-special*
de: ZUSAMMENFASSUNG						*plugin-special*

note: type: Plain text
en: Summary of special things to use in a plugin:
de: Zusammenfassung von Besonderheiten, die man in einem Plugin verwenden kann:

note: type: Plain text
en: s:name			Variables local to the script.
de: s:name			Variablen lokal zum Skript.

note: type: Plain text
en: <SID>			Script-ID, used for mappings and functions local to
    			the script.
de: <SID>			Skript-ID, verwendet für Zuordnungen und Funktionen
    			lokal zum Skript.

note: type: Plain text
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.

note: type: Plain text
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-Zuordnungen beginnen.

note: type: Plain text
en: :map <unique>		Give a warning if a mapping already exists.
de: :map <unique>		Gibt eine Warnung, falls eine Zuordnung bereits
    			existiert

note: type: Plain text
en: :noremap <script>	Use only mappings local to the script, not global
    			mappings.
de: :noremap <script>	Verwendet Zuordnungen nur lokal zum Skript, nicht
    			global.

note: type: Plain text
en: exists(":Cmd")		Check if a user command already exists.
de: exists(":Cmd")		Prüft, ob ein Anwenderbefehl bereits existiert.

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

note: type: Plain text
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 Zuordnungen definiert. Siehe |add-filetype-plugin| für Informationen, wie dieser Plugin-Typ verwendet wird.

note: type: Plain text
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 Besonderheiten, die hier erklärt werden. Essenziell ist, dass ein Dateityp-Plugin sich nur auf den aktuellen Puffer auswirken sollte.

note: type: Plain text
en: DISABLING
de: DEAKTIVIEREN

note: type: Plain text
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: >

note: type: Plain text
en: 	" Only do this when not done yet for this buffer
    	if exists("b:did_ftplugin")
    	  finish
    	endif
    	let b:did_ftplugin = 1
de: 	" Dies nur ausführen, wenn es für diesen Puffer noch nicht wurde
    	if exists("b:did_ftplugin")
    	  finish
    	endif
    	let b:did_ftplugin = 1

note: type: Plain text
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 verwendet werden, um zu vermeiden, dass dasselbe Plugin zweimal für denselben Puffer ausgeführt wird (geschieht, wenn man den Befehl »:edit« ohne Argumente benutzt).

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

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

note: type: Plain text
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: >

note: type: Plain text
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, siehe |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.

note: type: Plain text
en: OPTIONS
de: OPTIONEN

note: type: Plain text
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, verwenden Sie zum Setzen von Optionen den Befehl >

note: type: Plain text
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: 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, verwendet wird, ändert sich der Wert für viele Puffer, und das sollte ein Dateityp-Plugin nicht tun.

note: type: Plain text
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 is often a good idea.  Example: >
de: Wenn eine Option einen Wert hat, der eine Liste von Merkmalen oder Elementen ist, erwägen Sie »+=« und »-=« zu nutzen, um den vorhandenen Wert zu behalten. Seien Sie sich bewusst, dass der Nutzer den Wert einer Option bereits verändert haben kann. Zuerst auf den Standardwert setzen und dann ändern ist oft eine gute Sache. Beispiel: >

note: type: Plain text
en: MAPPINGS
de: ZUORDNUNGEN

note: type: Plain text
en: To make sure mappings will only work in the current buffer use the >
de: Um sicherzustellen, dass Zuordnungen nur im aktuellen Puffer operieren, benutzen Sie den Befehl >

note: type: Plain text
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 Zuordnung in zwei Schritten, wie oben erklärt, kombiniert werden. Ein Beispiel wie man Funktionalität in einem Dateityp-Plugin definiert: >

note: type: Plain text
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 verwendet um zu prüfen, ob der Anwender bereits eine Zuordnung auf <Plug>JavaImport definiert hat. Falls nicht, definiert das Dateityp-Plugin die Standardzuordnung. Diese beginnt mit |<LocalLeader>|, was dem Anwender erlaubt, die Taste(n), mit denen Zuordnungen aus Dateityp-Plugins beginnen, zu wählen. Der Standardwert ist ein umgekehrter Schrägstrich. »<unique>« wird verwendet, um eine Fehlermeldung auszugeben, falls die Zuordnung bereits existiert oder mit anderen Zuordnungen überlappt. |:noremap| wird benutzt, um zu vermeiden, dass jegliche anderen Zuordnungen, die der Anwender definiert hat, Einfluss nehmen. Man will möglicherweise »:noremap <script>« verwenden, um das erneute Zuordnen von Zuordnungen, die in diesem Skript definiert wurden und mit <SID> beginnen, zu erlauben.

note: type: Plain text
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 Anwender 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: >

note: type: Plain text
en: 	" Add mappings, unless the user didn't want this.
    	if !exists("no_plugin_maps") && !exists("no_mail_maps")
    	  " Quote text by inserting "> "
    	  if !hasmapto('<Plug>MailQuote')
    	    vmap <buffer> <LocalLeader>q <Plug>MailQuote
    	    nmap <buffer> <LocalLeader>q <Plug>MailQuote
    	  endif
    	  vnoremap <buffer> <Plug>MailQuote :s/^/> /<CR>
    	  nnoremap <buffer> <Plug>MailQuote :.,$s/^/> /<CR>
    	endif
de: 	" Fügt Zuordnungen hinzu, außer der Anwender wünscht dies nicht.
    	if !exists("no_plugin_maps") && !exists("no_mail_maps")
    	  " Zitiere Text durch Einfügen von "> "
    	  if !hasmapto('<Plug>MailQuote')
    	    vmap <buffer> <LocalLeader>q <Plug>MailQuote
    	    nmap <buffer> <LocalLeader>q <Plug>MailQuote
    	  endif
    	  vnoremap <buffer> <Plug>MailQuote :s/^/> /<CR>
    	  nnoremap <buffer> <Plug>MailQuote :.,$s/^/> /<CR>
    	endif

note: type: Plain text
en: Two global variables are used: |no_plugin_maps|	disables mappings for all filetype plugins |no_mail_maps|		disables mappings for the "mail" filetype
de: Zwei globale Variablen werden verwendet
    |no_plugin_maps|	deaktiviert Zuordnungen für alle Dateityp-Plugins
    |no_mail_maps|		deaktiviert Zuordnungen für einen bestimmten Dateityp

note: type: Plain text
en: USER COMMANDS
de: ANWENDERBEFEHLE

note: type: Plain text
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 Anwenderbefehl für einen bestimmten Dateityp hinzufügen, so dass er nur in einem Puffer benutzt werden kann, verwenden Sie das Argument »-buffer« von |:command|. Beispiel: >

note: type: Plain text
en: VARIABLES
de: VARIABLEN

note: type: Plain text
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 Puffervariablen |b:var|, falls Sie eine Variable für einen bestimmten Puffer wollen.

note: type: Plain text
en: FUNCTIONS
de: FUNKTIONEN

note: type: Plain text
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 makes 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: >

note: type: Plain text
en: UNDO						*undo_indent* *undo_ftplugin*
de: ZURÜCKNEHMEN				*undo_indent* *undo_ftplugin*

note: type: Plain text
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: >

note: type: Plain text
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 Verwenden von »:setlocal« mit »<« nach dem Namen der Option setzt die Option auf ihren globalen Wert. Das ist meistens das Beste, um den Wert der Option zurückzusetzen.

note: type: Plain text
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 Merkmals »C« aus 'cpoptions' um Zeilenfortsetzung zu erlauben, wie oben erwähnt |use-cpo-save|.

note: type: Plain text
en: For undoing the effect of an indent script, the b:undo_indent variable should be set accordingly.
de: Um die Wirkung eines Einrückungsskripts zurückzunehmen, sollte die Variable b:undo_indent entsprechend gesetzt werden.

note: type: Plain text
en: FILE NAME
de: DATEINAME

note: type: Plain text
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|. Verwenden Sie eine von diesen drei Formen:

note: type: Plain text
en: 	.../ftplugin/stuff.vim
    	.../ftplugin/stuff_foo.vim
    	.../ftplugin/stuff/bar.vim
de: 	.../ftplugin/etwas.vim
    	.../ftplugin/etwas.vim
    	.../ftplugin/etwas/bar.vim

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

note: type: Plain text
en: SUMMARY							*ftplugin-special*
de: ZUSAMMENFASSUNG						*ftplugin-special*

note: type: Plain text
en: Summary of special things to use in a filetype plugin:
de: Zusammenfassung von Besonderheiten, die man in einem Dateityp-Plugin verwenden kann:

note: type: Plain text
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 Anwender als die
    			Tasten definiert, mit denen Dateityp-Plugin-Zuordnungen
    			beginnen.

note: type: Plain text
en: :map <buffer>		Define a mapping local to the buffer.
de: :map <buffer>		Definiert eine Belegung lokal zum Puffer.

note: type: Plain text
en: :noremap <script>	Only remap mappings defined in this script that start
    			with <SID>.
de: :noremap <script>	Neuzuordnung nur von Zuordnungen, die in diesem Skript
    			definiert wurden und mit <SID> beginnen.

note: type: Plain text
en: :setlocal		Set an option for the current buffer only.
de: :setlocal		Setzt eine Option nur für den aktuellen Puffer.

note: type: Plain text
en: :command -buffer	Define a user command local to the buffer.
de: :command -buffer	Definiert einen Anwenderbefehl lokal zum Puffer.

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

note: type: Plain text
en: Also see |plugin-special|, the special things used for all plugins.
de: Siehe auch |plugin-special|, die Besonderheiten, die für alle Plugins verwendet werden.

note: type: Plain text
en: *41.13*	Writing a compiler plugin		*write-compiler-plugin*
de: *41.13*	Ein Compilerplugin schreiben		*write-compiler-plugin*

note: type: Plain text
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 Compilerplugin setzt Optionen zur Verwendung mit einem bestimmten Compiler. Der Anwender kann es mit dem Befehl |:compiler| laden. Wird hauptsächlich verwendet, um die Optionen 'errorformat' und 'makeprg' zu setzen.

note: type: Plain text
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 bearbeitet alle Standard-Compilerplugins: >

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

note: type: Plain text
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 Anwender zu erlauben, die Standarddatei zu überstimmen oder zu ihr hinzuzufügen. Die Standarddateien beginnen mit: >

note: type: Plain text
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 Compiler-Datei schreiben und in Ihr persönliches
    Laufzeitverzeichnis legen (z. B. ~/.vim/compiler für Unix), setzen Sie die
    Variable »current_compiler«, um die Standarddatei die Einstellungen
    überspringen zu lassen.
    							*:CompilerSet*
    Der zweite Mechanismus ist, »:set« für »:compiler!« und »:setlocal« für
    »:compiler« zu verwenden. Vim definiert hierfür den Anwenderbefehl
    »:CompilerSet«. Ältere Vim-Versionen tun dies jedoch nicht, also sollte Ihr
    Plugin ihn dann definieren. Dies ist ein Beispiel: >

note: type: Plain text
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 Compilerplugin für die Vim-Distribution oder für ein systemweites Laufzeitverzeichnis schreiben, verwenden Sie den oben erwähnten Mechanismus. Wenn »current_compiler« bereits von einem Anwender-Plugin gesetzt wurde, wird nichts getan.

note: type: Plain text
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 Compilerplugin 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.

note: type: Plain text
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*

note: type: Plain text
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 Startverzögerung kann merkbar werden, während Sie das Plugin kaum verwenden. Dann ist es Zeit für ein Schnelllade-Plugin.

note: type: Plain text
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 Anwenderbefehle und Zuordnungen definiert, die die Funktionalität anbieten. Beim zweiten Mal werden die Funktionen, die die Funktionalität implementieren, definiert.

note: type: Plain text
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 verwendet. Wenn Sie immer die Funktionalität benutzen, wird es tatsächlich langsamer!

note: type: Plain text
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: verwenden Sie die Funktionalität |autoload| |41.15|.

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

note: type: Plain text
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 mit einem Befehl |:finish|, also wird der Rest des Skripts nicht ausgeführt.

note: type: Plain text
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().

note: type: Plain text
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:

note: type: Bullet: '1. '
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 Autobefehl |FuncUndefined| wird definiert. Der Befehl »:finish« beendet die Ausführung des Skripts frühzeitig.

note: type: Bullet: '2. '
en: The user types the BNRead command or presses the <F19> key.  The BufNetRead() or BufNetWrite() function will be called.
de: Der Anwendet gibt den Befehl BNRead ein oder drückt die Taste <F19>. Die Funktion BufNetRead() oder BufNetWrite() wird aufgerufen.

note: type: Bullet: '3. '
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 Autobefehl |FuncUndefined| aus. Weil das Muster »BufNet*« auf die aufgerufene Funktion passt, wird der Befehl »source fname« ausgeführt. »fname« ist gleich dem Namen des Skripts, egal wo es liegt, weil es vom Expandieren von »<sfile>« kommt (siehe |expand()|).

note: type: Bullet: '4. '
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.

note: type: Plain text
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.

note: type: Plain text
en: *41.15*	Writing library scripts			*write-library-script*
de: *41.15*	Bibliotheksskripte schreiben		*write-library-script*

note: type: Plain text
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 verwenden. Wir nennen dies eine Skript ein Bibliotheksskript.

note: type: Plain text
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: >

note: type: Plain text
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.

note: type: Plain text
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: >

note: type: Plain text
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.

note: type: Plain text
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.

note: type: Plain text
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: >

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

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

note: type: Plain text
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.

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

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

note: type: Plain text
en: Further reading: |autoload|.
de: Zum Weiterlesen: |autoload|.

note: type: Plain text
en: *41.16*	Distributing Vim scripts			*distribute-script*
de: *41.16*	Vim-Skripte verteilen			*distribute-script*

note: type: Plain text
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-Anwender schauen auf der Vim-Website (http://www.vim.org/) nach Skripten. Falls Sie etwas gemacht haben, das nützlich für andere ist, teilen Sie es!

note: type: Plain text
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«.

note: type: Plain text
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 verwenden Sie Vim selbst, um Skripte zusammen zu packen. Dies kann mit dem Werkzeug Vimball gemacht werden. Siehe |vimball|.

note: type: Plain text
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|.

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

note: type: Plain text
en: Copyright: see |manual-copyright| vim:tw=78:ts=8:noet:ft=help:norl:
de: Copyright: siehe |manual-copyright| vim:tw=78:ts=8:noet:ft=help:norl:
