{"id":55000128,"date":"2003-10-01T00:00:00","date_gmt":"2020-05-06T15:17:32","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=128"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Effektiver_programmieren_mit_der_ungarischen_Notation","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/","title":{"rendered":"Effektiver programmieren mit der ungarischen Notation"},"content":{"rendered":"

\"\"<\/p>\n

Jörg Schumacher, Stöckse; André Minhorst, Duisburg<\/b><\/p>\n

Bei der Entwicklung von Applikationen steht der Entwickler oft vor der Frage, wie Variablen, Konstanten, Objekte und so weiter heißen sollen. Vor allem dann, wenn Anwendungen im Team entstehen, ist die Standardisierung von Bezeichnungen wichtig. So entstehen Namenskonventionen, die festlegen, welche Klassen oder Kategorien von Objekten mit welchen Namenskürzeln identifiziert und gruppiert werden. Dies ist notwendig, damit andere Team-Mitarbeiter den geschaffenen Programmcode schneller verstehen, erleichtert aber ebenso die Wartung von Anwendungen in Zukunft durch die Entwickler selbst oder Drittpersonen. Dieser Artikel vermittelt Informationen über eine in der Programmierung weit verbreitete Konvention – die ungarische Notation.<\/b><\/p>\n

Der Bezeichner von Variablen, Konstanten oder anderen Objekten sollte möglichst aussagekräftig sein, damit ein Programmierer auch nach längerer Zeit noch die Bedeutung der Objekte in einem Programm erkennen kann. Oft wird versucht, den Verwendungszweck der Variablen in ihren Namen auszudrücken. Bei geschickter Namensvergabe lassen sich jedoch noch weitere Informationen in die Variablenbezeichnung aufnehmen.<\/p>\n

Der Ursprung der dafür am meisten verbreiteten Namenskonvention liegt in den 70er Jahren und geht auf Charles Simony zurück. Charles Simony, einer der berühmten Programmierer von Microsoft, war maßgeblich an der Entwicklung von Microsoft Word und Microsoft Multiplan beteiligt. Er entwickelte eine Namenskonvention, die von ihm als „ungarische Namenskonvention“ bezeichnet wurde. Der Begriff, so Charles Simony in einem Interview, hat eine doppelte Bedeutung.<\/p>\n

Zum einen rührt er aus der Tatsache her, dass Charles Simony in Ungarn geboren wurde und er diese Konvention selber entwickelt hat. Zum anderen ist es eine Replik auf die Redensart „das sind für mich böhmische Dörfer“, die ursprünglich meint, dass man etwas nicht versteht. Populär wurde dieser Ausdruck im Dreißigjährigen Krieg. Soldaten, die in Böhmen kämpften, verstanden die tschechischen Namen der dortigen Dörfer nicht. Im Gegensatz dazu soll also der Begriff „ungarische Notation“ signalisieren, dass selbst komplizierte Namen verständlich bleiben. <\/p>\n

Die Grundidee der ungarischen Namenskonvention war die Aufnahme des benutzten Datentyps in den Namen einer Variablen. Zu diesem Zweck wird dem eigentlichen Namen eine Folge von Kleinbuchstaben vorangestellt (Präfix), die den Typ der Variablen beschreiben. Einige Beispiele zur Variablendeklaration in Visual Basic sollen das verdeutlichen (s. Tab. 1).<\/p>\n

In Visual Basic werden dem Variablennamen in der Regel drei Buchstaben vorangestellt. Dabei handelt es sich optimalerweise um die ersten drei Buchstaben der Bezeichnung des jeweiligen Variablentyps.<\/p>\n

Welche Präfixe verwendet werden, hängt davon ab, welche Elemente die Programmiersprache bietet. Das ist zwar je nach Programmiersprache unterschiedlich, prinzipiell hat sich aber die Art der Benennung durchgesetzt und findet auch in VBA Anwendung, also zum Beispiel in der Access-Programmierung. <\/p>\n\n\n\n\n\n\n\n\n
\n

Präfix<\/b><\/p>\n<\/td>\n

\n

Variablentyp<\/b><\/p>\n<\/td>\n

\n

Beispiel<\/b><\/p>\n<\/td>\n<\/tr>\n

\n

int<\/p>\n<\/td>\n

\n

Integer<\/p>\n<\/td>\n

\n

intAnzahl<\/p>\n<\/td>\n<\/tr>\n

\n

str<\/p>\n<\/td>\n

\n

String<\/p>\n<\/td>\n

\n

strVorname<\/p>\n<\/td>\n<\/tr>\n

\n

cur<\/p>\n<\/td>\n

\n

Currency<\/p>\n<\/td>\n

\n

curEinnahmen<\/p>\n<\/td>\n<\/tr>\n

\n

tbl<\/p>\n<\/td>\n

\n

Table<\/p>\n<\/td>\n

\n

tblAdressen<\/p>\n<\/td>\n<\/tr>\n

\n

rep<\/p>\n<\/td>\n

\n

Report<\/p>\n<\/td>\n

\n

repAdressenliste<\/p>\n<\/td>\n<\/tr>\n

\n

cmd<\/p>\n<\/td>\n

\n

Commandbar<\/p>\n<\/td>\n

\n

cmdOK<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

Tab. 1: Variablenpräfixe nach ungarischer Notation<\/b><\/p>\n

Auch wenn die Verwendung der ungarischen Namenskonvention auf den ersten Blick ein wenig merkwürdig erscheint, hilft sie doch sehr, ein umfangreiches Programm verständlicher zu machen.<\/p>\n

Obwohl das Prinzip recht simpel ist, leistet es schon während der Programmierung gute Dienste und hilft unter Umständen, Fehlern vorzubeugen. Wie das funktioniert, zeigt folgendes Beispiel. <\/p>\n

Angenommen, dass in einem Programm zwei Variablen definiert werden, eine vom Datentyp Integer und eine vom Datentyp Single.<\/p>\n

Hinweis<\/h3>\n

Der Datentyp Integer hat zwei Bytes Speicherbedarf und kann ganzzahlige Werte von -32768 bis 32767 darstellen. Der Datentyp Single hat vier Bytes Speicherbedarf und kann nicht nur ganzzahlige, sondern auch Gleitkommazahlen speichern. Weitere Informationen zum Thema Datentypen finden Sie in der Onlinehilfe von Access unter dem Stichwort Datentypen (Zusammenfassung). <\/p>\n

Später im Programm findet eine Zuweisung statt. In den folgenden Zeilen werden die beiden Variablen deklariert. Der Variablen Zahl1 wird der Wert 1,34 zugewiesen. Anschließend wird der Inhalt von Zahl1 der Variablen Zahl2 zugewiesen. Das anschließend aufgerufene Meldungsfenster gibt schließlich den Wert der Variablen Zahl2 aus. Und hier folgt die böse überraschung: Die Variable enthält nicht die Zahl 1,34 als Wert, sondern die 1.<\/p>\n

Dim Zahl1 As Single\r\nDim Zahl2 As Integer\r\nZahl1 = 1.34\r\nZahl2 = Zahl1\r\nMsgBox \"Zahl2 = \" & Zahl2<\/pre>\n
Dieses Beispiel zeigt einen Fehler, der bei Zuweisungen häufig auftritt: Die Wertebereiche der Variablen sind nicht identisch. So lange der Wert von Zahl1 den Wertebereich von Zahl2 nicht überschreitet und keine Nachkommastellen vorkommen, ist die Zuweisung unproblematisch.<\/p>\n
Ein weiterer Fehler, der aus dieser Konstellation entstehen kann, ist folgender: Beträgt der Wert von Zahl1 zum Beispiel 100.000 und liegt damit außerhalb des möglichen Wertebereiches der Variablen Zahl2, führt diese Zuweisung zu einem Programmfehler.<\/p>\n
Im Vergleich zum oben beschriebenen Fehler wird dieser Fehler immerhin von der Anwendung angezeigt, sodass die Berechnung nicht unbemerkt mit falschen Werten fortgesetzt wird.<\/p>\n
Bei Verwendung der ungarischen Namenskonvention fällt dem Programmierer das Problem dagegen sofort ins Auge:<\/p>\n
Dim sngZahl1 As Single\r\nDim intZahl2 As Integer\r\nsngZahl1 = 1.34\r\nintZahl2 = sngZahl1\r\nMsgBox \"Zahl2 = \" & sngZahl2<\/pre>\n
In diesem Beispiel wird schon beim Schreiben der Programmzeile deutlich, dass hier ein Fehler bei der Zuweisung auftreten kann, auch wenn die Definitionen der Variablen und damit die Festlegung der Datentypen weit entfernt von der Zuweisung im Programmtext stehen könnten. <\/p>\n
Standards und Konventionen werden oft als einschränkend empfunden. Es ist mitunter eher lästig, sich an die Vorgaben zur Bezeichnung der verwendeten Elemente zu halten. Aber Konventionen haben unbestreitbare Vorteile: <\/p>\n
  • Konventionen machen die Benennung einfacher: Wenn ein bestimmtes Muster für die Erstellung von Namen einmal festgelegt ist, kann nach einiger übung nahezu blind danach verfahren werden.  <\/li>\n
  • Konventionen erleichtern das Verständnis. Wenn ähnliche Namen für ähnliche Zusammenhänge stehen, muss sich der Entwickler auf weniger Details konzentrieren. <\/li>\n
  • Es ist viel einfacher, fremde Quelltexte zu analysieren. <\/li>\n
    über Konventionen beim Programmieren lässt sich trefflich streiten. Jeder Programmierer entwickelt mit der Zeit eigene Konventionen. Eine änderung dieser Gewohnheiten ist eher lästig. Oft wird über Konventionen sogar gestritten als ginge es um Religion.<\/p>\n
    Dabei ist es letztlich beim Programmieren egal, welche Konventionen zugrunde liegen. Alles wird einfacher, je mehr sich die Entwickler an relativ einheitliche Regeln halten. Und die ungarische Notation hat sich über die Jahre als Quasi-Standard herausgebildet, nicht zuletzt natürlich auch durch die Verwendung der Prinzipien in den Programmiersprachen von Microsoft. <\/p>\n
    Ungarische Namen bestehen aus drei Teilen: Basistyp, Präfix und Bezeichner. Diese drei Teile müssen aber nicht immer alle vorhanden sein. Meist bestehen ungarische Namen nur aus dem Präfix und dem Bezeichner.<\/p>\n
    Präfix und Basistyp sind zusammen der kleingeschriebene Teil, mit dem jeder Variablenname beginnt. Es gibt auch nicht für alle Fälle standardisierte  Bezeichner, sodass entweder die Phantasie des Entwicklers beim Erstellen eigener Programme oder beim Lesen von Fremdprogrammen gefordert ist. <\/p>\n
    Basistypen bezeichnen den Datentyp der Variablen. Dabei werden sowohl die Standardtypen als auch abstrakte Datentypen durch Kürzel repräsentiert. So steht üblicherweise der Buchstabe obj als Basistyp für Objekte, ohne diese weiter zu kennzeichnen. Im Allgemeinen wird ein Basistyp nur dann verwendet, wenn eine detailliertere Bezeichnung nicht möglich oder notwendig ist.<\/p>\n
    <\/p>\n
    Die Abkürzung der Basistypen ist nicht immer eindeutig. Das liegt zum Beispiel bei den Standardvariablentypen daran, dass der Typ (beispielsweise numerisch) selbst äußerst wenig über den Verwendungszweck der Variablen aussagt. Bei den abstrakten Datentypen wie beispielsweise wnd für Fenster ist der Verwendungszweck meistens klar. Es ist aber problematisch, eine geeignete Abkürzung zu finden. In der Praxis kommt es selten vor, dass zwei gleiche Abkürzungen im selben Abschnitt des Codes verwendet werden. In diesem Fall spielt dann der Bezeichner selbst eine größere Rolle als sonst. <\/p>\n
    Präfixe gehen über den Basistyp hinaus und beschreiben den Zweck einer Variablen. Im Gegensatz zu den Basistypen sind Präfixe eindeutig – was in der Programmierpraxis auch nicht immer gewährleistet ist. Die Präfixe sind das Charakteristikum der ungarischen Notation. Sie beschreiben die Bedeutung einer Variablen im Programmkontext. Präfixe erscheinen im Namen vor dem Basistyp.<\/p>\n
    Sie können beliebig mit weiteren Präfixen oder Basistypen kombiniert werden. Häufig verwendet wird beispielsweise der Buchstabe h für Handle: Objekte des Betriebssystems werden häufig durch Handles repräsentiert. In der Kombination mit dem Basistyp Fenster entsteht so hwnd als Vorspann für den Bezeichner des Handles eines Fensters.<\/p>\n
    Hinweis<\/h3>\n
    Eine übersicht über die üblichen Präfixe innerhalb von VB für allgemeine Steuerelemente und Objekte finden Sie in der englischen Microsoft Knowledge Base,  Artikelnummer 173738. Verwenden Sie den Suchbegriff KB173738. <\/p>\n
    Function IsLoaded(ByVal strFormName As String) As Boolean\r\n    Dim objAccessObject As AccessObject\r\n    Set objAccessObject = CurrentProject.AllForms(strFormName)\r\n    If objAccessObject.IsLoaded Then\r\n        If objAccessObject.CurrentView <> acCurViewDesign Then\r\n            IsLoaded = True\r\n        End If\r\n    End If\r\nEnd Function<\/pre>\n
    Quellcode 1<\/b><\/p>\n
    Der dritte Bestandteil eines „ungarischen“ Namens ist der Bezeichner. Außerhalb der ungarischen Notation bestehen Objektnamen nur aus dem Bezeichner. Der Bezeichner ist der eigentliche Name, aus dem der Sinn und Zweck der Variablen im Kontext des Codes hervorgehen sollte.<\/p>\n
    Die Frage, ob zur Bezeichnung englische oder deutsche Namen Verwendung finden, ist beinahe wieder eine Glaubensfrage. Während viele Entwickler auf durchgängig englische Bezeichner setzen, heben andere den Vorteil deutscher Bezeichner für selbst definierte Programmelemente hervor.<\/p>\n
    Hinweis<\/h3>\n
    Unter Windows ist es üblich, Bezeichner mit einem Großbuchstaben zu beginnen und durch Groß-\/Kleinschreibung zu unterteilen. Dabei beginnt jeder Bezeichner mit einem großen Buchstaben, wie zum Beispiel intAnzahlPersonen. <\/p>\n
    Nachteile der ungarischen Notation<\/h3>\n
    Bei allen beschriebenen Vorteilen der ungarischen Notation sollen die Nachteile nicht verschwiegen werden. <\/p>\n
    In der Praxis wird manchmal der Bezeichner komplett weggelassen und nur noch die Typbeschreibung verwendet. Viele derartige Beispiele finden sich in der Onlinehilfe von Microsoft Access. Ein Fenster heißt dann zum Beispiel nur  hwnd, eine Zeichenkette str oder eine Datensatzgruppe rst. Diese Namen vermitteln den Verwendungszweck nicht mehr: hwnd könnte ein Eingabefenster, das Hauptfenster oder ein Kontrollelement sein, was dann erst aus dem Kontext hervorgeht. <\/p>\n
    Es sind viele verschiedene Versionen der ungarischen Notation im Umlauf, die sich geringfügig voneinander unterscheiden und mehr oder weniger streng gehandhabt werden. Allen gemeinsam ist aber die Verwendung von Präfixen.<\/p>\n
    Ein Beispiel aus der Datenbank Nordwind soll die Verwendung der ungarischen Notation in Access veranschaulichen. Die Funktion gibt den Wert True zurück, wenn das angegebene Formular in Formularansicht oder Datenblattansicht geöffnet ist. Dazu reicht es in diesem Fall aus, die Entwurfsansicht auszuschließen, da ein Formular nur eine dieser drei Ansichten annehmen kann (s. Quellcode 1).<\/p>\n
    Hinweis<\/h3>\n
    Leider zeigt dieses Beispiel, dass es auch im Hause Microsoft Inkonsistenzen bezüglich der Verwendung von Präfixen bei der Variablenbenennung gibt: Während im weiter oben erwähnten Knowledgebase-Artikel das Präfix obj für Objekte vorgesehen ist, findet sich im Original dieses Beispiels aus der Nordwind-Datenbank von Access XP das Präfix o wieder. <\/p>\n
    Konstanten<\/h3>\n
    Im Beispielcode wird für die Prüfung der Ansicht auf eine benannte Konstante zurückgegriffen, die im Beispiel für einen Zahlenwert steht. Diese Verwendung benannter Konstanten wird von Microsoft als zukunftssicher propagiert. In zukünftigen Versionen von Microsoft  Access könnten sich zwar die tatsächlichen Werte der Konstanten, nicht aber deren Bezeichner verändern.<\/p>\n
    Eingebaute Konstanten verfügen – wie es die ungarische Namenskonvention empfiehlt –  über ein aus zwei Buchstaben bestehendes Präfix. Es  bezeichnet die Objektbibliothek, die die Konstante definiert.<\/p>\n
    Konstanten aus der Microsoft Access-Bibliothek führen zum Beispiel das Präfix ac, aus der ADO-Bibliothek das Präfix ad und aus der Visual Basic-Bibliothek das Präfix vb. <\/p>\n
    Das macht vor allem die Suche nach den verfügbaren Konstanten leichter:<\/p>\n
    Das im Beispiel verwendete acCurViewDesign lässt sich aufgrund der verwendeten Konvention durch das Präfix ac leicht als eingebaute Accesskonstante identifizieren, die zu CurrentView gehört (zweiter Bestandteil CurView) und die Designansicht repräsentiert (eigentlicher Bezeichner Design).<\/p>\n
    Ein Blick in den Objektkatalog bestätigt diese überlegung (siehe Bild 1) und verrät dabei sogar noch, dass der zugehörige, tatsächliche Wert dieser Konstante Null ist.<\/p>\n
    <\/p>\n
    <\/b><\/p>\n
    Bild 1:  Konstanten im Objektkatalog<\/span><\/b><\/p>\n
    Ebenso der Konvention entsprechend deutet  strFormName auf eine Variable für eine Zeichenfolge.<\/p>\n
    Die ungarische Notation kann und sollte bei der Arbeit mit Access konsequent verwendet werden. In den folgenden Abschnitten finden Sie die Präfixe für die wichtigsten Objekte und Variablentypen unter Access. Außerdem erfahren Sie, in welchen Fällen diese Konvention in der Regel nicht verwendet wird.<\/p>\n
    Variablentypen<\/h2>\n
    In Tab. 2 finden Sie eine Auflistung der meistgebrauchten Variablentypen in Access und den entsprechenden Präfixen.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    \n
    Variablentyp<\/b><\/p>\n<\/td>\n
    		\n
    Präfix<\/b><\/p>\n<\/td>\n<\/tr>\n
    \n
    Byte<\/p>\n<\/td>\n
    		\n
    byt<\/p>\n<\/td>\n<\/tr>\n
    \n
    Boolean<\/p>\n<\/td>\n
    		\n
    f<\/p>\n<\/td>\n<\/tr>\n
    \n
    Integer<\/p>\n<\/td>\n
    		\n
    int<\/p>\n<\/td>\n<\/tr>\n
    \n
    Long<\/p>\n<\/td>\n
    		\n
    lng<\/p>\n<\/td>\n<\/tr>\n
    \n
    Single<\/p>\n<\/td>\n
    		\n
    sng<\/p>\n<\/td>\n<\/tr>\n
    \n
    Double<\/p>\n<\/td>\n
    		\n
    dbl<\/p>\n<\/td>\n<\/tr>\n
    \n
    Currency<\/p>\n<\/td>\n
    		\n
    cur<\/p>\n<\/td>\n<\/tr>\n
    \n
    Date<\/p>\n<\/td>\n
    		\n
    dat<\/p>\n<\/td>\n<\/tr>\n
    \n
    Object<\/p>\n<\/td>\n
    		\n
    obj<\/p>\n<\/td>\n<\/tr>\n
    \n
    String<\/p>\n<\/td>\n
    		\n
    str<\/p>\n<\/td>\n<\/tr>\n
    \n
    Variant<\/p>\n<\/td>\n
    		\n
    var<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
    Tab. 2: Variablentypen und deren Präfixe<\/b><\/p>\n
    Datenbankobjekte<\/h2>\n
    Datenbankobjekte sind alle Objekte, die Sie in den unterschiedlichen Registern des Datenbankfensters von Access finden. Gerade hier ist die Verwendung entsprechender Präfixe besonders zu empfehlen.<\/p>\n
    Im VBA-Code wird es kaum Verwechslungen oder Fehler geben, da die meisten Operationen mit diesen Objekten in einem speziellen Kontext durchgeführt werden und ohnehin auf die entsprechenden Auflistungen zugegriffen wird.<\/p>\n
    Allerdings sehen im Datenbankfenster alle Registerseiten gleich aus – und wenn Sie dort keine Präfixe vergeben und es beispielsweise je eine Tabelle, ein Formular und einen Bericht namens Adressen gibt, haben Sie schnell mal den Bericht statt des gewünschten Formulars geöffnet.<\/p>\n
    In Tab. 3 finden Sie eine Auflistung der Datenbankobjekte und der entsprechenden Präfixe.<\/p>\n\n\n\n\n\n\n\n\n\n\n
    \n
    Datenbankobjekt<\/b><\/p>\n<\/td>\n
    		\n
    Präfix<\/b><\/p>\n<\/td>\n<\/tr>\n
    \n
    Tabelle<\/p>\n<\/td>\n
    		\n
    tbl<\/p>\n<\/td>\n<\/tr>\n
    \n
    Abfrage<\/p>\n<\/td>\n
    		\n
    qry<\/p>\n<\/td>\n<\/tr>\n
    \n
    Formular<\/p>\n<\/td>\n
    		\n
    frm<\/p>\n<\/td>\n<\/tr>\n
    \n
    Unterformular<\/p>\n<\/td>\n
    		\n
    sfm<\/p>\n<\/td>\n<\/tr>\n
    \n
    Bericht<\/p>\n<\/td>\n
    		\n
    rpt<\/p>\n<\/td>\n<\/tr>\n
    \n
    Unterbericht<\/p>\n<\/td>\n
    		\n
    srp<\/p>\n<\/td>\n<\/tr>\n
    \n
    Makro<\/p>\n<\/td>\n
    		\n
    mak<\/p>\n<\/td>\n<\/tr>\n
    \n
    Modul<\/p>\n<\/td>\n
    		\n
    mdl<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
    Tab. 3: Datenbankobjekte und deren Präfixe<\/b><\/p>\n
    Hinweis<\/h3>\n
    Möglicherweise vermissen Sie in der Auflistung die seit Access 2000 enthaltenen Datenzugriffsseiten. Da deren Akzeptanz relativ gering ist, werden hier weder Präfixe für Datenzugriffsseiten noch für die eventuell enthaltenen speziellen Steuerelemente vorgestellt. <\/p>\n
    Steuerelemente<\/h2>\n
    Die dritte wichtige Gruppe von Objekten, die nach der ungarischen Notation benannt werden sollten, sind die Steuerelemente innerhalb von Formularen und Berichten.<\/p>\n
    Da es hier durch die Möglichkeit des Einsatzes von ActiveX-Steuerelementen und ähnlichen eine enorme Vielfalt gibt, finden Sie in Tab. 4 lediglich die Präfixe für die eingebauten Steuerelemente von Access. Informationen über Präfixe für weitere Steuerelemente finden Sie unter 5.5.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    \n
    Steuerelement<\/b><\/p>\n<\/td>\n
    		\n
    Engl. Bezeichnung<\/b><\/p>\n<\/td>\n
    		\n
    Präfix<\/b><\/p>\n<\/td>\n<\/tr>\n
    \n
    Bezeichnungsfeld<\/p>\n<\/td>\n
    		\n
    Label<\/p>\n<\/td>\n
    		\n
    lbl<\/p>\n<\/td>\n<\/tr>\n
    \n
    Textfeld<\/p>\n<\/td>\n
    		\n
    Textbox<\/p>\n<\/td>\n
    		\n
    txt<\/p>\n<\/td>\n<\/tr>\n
    \n
    Optionsgruppe<\/p>\n<\/td>\n
    		\n
    OptionGroup<\/p>\n<\/td>\n
    		\n
    fra<\/p>\n<\/td>\n<\/tr>\n
    \n
    Umschaltfläche<\/p>\n<\/td>\n
    		\n
    ToggleButton<\/p>\n<\/td>\n
    		\n
    tgl<\/p>\n<\/td>\n<\/tr>\n
    \n
    Optionsfeld<\/p>\n<\/td>\n
    		\n
    OptionButton<\/p>\n<\/td>\n
    		\n
    opt<\/p>\n<\/td>\n<\/tr>\n
    \n
    Kontrollkästchen<\/p>\n<\/td>\n
    		\n
    CheckBox<\/p>\n<\/td>\n
    		\n
    chk<\/p>\n<\/td>\n<\/tr>\n
    \n
    Kombinationsfeld<\/p>\n<\/td>\n
    		\n
    ComboBox<\/p>\n<\/td>\n
    		\n
    cbo<\/p>\n<\/td>\n<\/tr>\n
    \n
    Listenfeld<\/p>\n<\/td>\n
    		\n
    ListBox<\/p>\n<\/td>\n
    		\n
    lst<\/p>\n<\/td>\n<\/tr>\n
    \n
    Schaltfläche<\/p>\n<\/td>\n
    		\n
    CommandButton<\/p>\n<\/td>\n
    		\n
    cmd<\/p>\n<\/td>\n<\/tr>\n
    \n
    Bildsteuerelement<\/p>\n<\/td>\n
    		\n
    Image<\/p>\n<\/td>\n
    		\n
    img<\/p>\n<\/td>\n<\/tr>\n
    \n
    Objektfeld<\/p>\n<\/td>\n
    		\n
    ObjectFrame<\/p>\n<\/td>\n
    		\n
    ole<\/p>\n<\/td>\n<\/tr>\n
    \n
    Gebundenes Objektfeld<\/p>\n<\/td>\n
    		\n
    BoundObjectFrame<\/p>\n<\/td>\n
    		\n
    bof<\/p>\n<\/td>\n<\/tr>\n
    \n
    Seitenwechsel<\/p>\n<\/td>\n
    		\n
    PageBreak<\/p>\n<\/td>\n
    		\n
    brk<\/p>\n<\/td>\n<\/tr>\n
    \n
    Registersteuerelement<\/p>\n<\/td>\n
    		\n
    TabControl<\/p>\n<\/td>\n
    		\n
    tab<\/p>\n<\/td>\n<\/tr>\n
    \n
    Unterformular\/-bericht<\/p>\n<\/td>\n
    		\n
    SubForm\/SubReport<\/p>\n<\/td>\n
    		\n
    sfm\/srp<\/p>\n<\/td>\n<\/tr>\n
    \n
    Linie<\/p>\n<\/td>\n
    		\n
    Line<\/p>\n<\/td>\n
    		\n
    lin<\/p>\n<\/td>\n<\/tr>\n
    \n
    Rechteck<\/p>\n<\/td>\n
    		\n
    Rectangle<\/p>\n<\/td>\n
    		\n
    shp<\/p>\n<\/td>\n<\/tr>\n<\/table>\n
    Tab. 4: Präfixe von Formular- und Berichtssteuerelementen<\/b><\/p>\n
    Sonderfall Feldnamen<\/h2>\n
    Ein Sonderfall ist die Benennung von Tabellenfeldern. Dort ist die Verwendung von Präfixen geradezu verpönt. Sie werden kaum eine Datenbank finden, in der die Tabellenfelder einen Namen mit Präfix haben. <\/p>\n
    Weitere Präfixe<\/h2>\n
    Aus Platzgründen können hier leider nicht alle für Access wichtigen Konventionen abgedruckt werden.<\/p>\n
    Wenn Sie an der aktuellen und kompletten Sammlung von Präfixen interessiert sind, sollten Sie sich einmal im Internet unter der Adresse http:\/\/www.xoc.net\/standards\/default.asp umsehen.<\/p>\n
    Die ungarische Notation hilft in vielen Fällen, die Lesbarkeit und auch die Erstellung von Code zu erleichtern. Es gibt noch einige Regeln, die speziell bei der Entwicklung von Access-Anwendungen hilfreich sein können.<\/p>\n
    Tabellennamen<\/h2>\n
    Tabellennamen sollten neben dem bereits erwähnten Präfix tbl treffend und leicht zu merken sein.<\/p>\n
    In normalisierten Datenmodellen enthält jede Tabelle optimalerweise Informationen über genau ein Objekt. Dabei kann es sich beispielsweise um eine Person oder ein Produkt handeln.<\/p>\n
    Wenn diese Voraussetzung erfüllt ist, können Sie die Tabellennamen mühelos aus dem Präfix und der Bezeichnung des Objektes im Plural zusammensetzen. Den Plural verwenden Sie, weil eine Tabelle in der Regel mehrere der benannten Objekte enthält. Sie erhalten dann Namen wie zum Beispiel tblPersonen oder tblProdukte.<\/p>\n
    Auf diese Weise müssen Sie beim Entwickeln nie mehr in das Datenbankfenster schauen, um einen Tabellennamen zu ermitteln, denn alle Tabellen haben eindeutige Namen.<\/p>\n
    Verknüpfungstabellen<\/h3>\n
    Die Ausnahme von dieser Vorgehensweise sind Tabellen, die zur Verknüpfung von zwei oder mehr Tabellen dienen, um eine so genannte m:n-Verknüpfung herzustellen.<\/p>\n
    Für diese Tabellen können Sie ebenfalls eine leicht zu merkende Benennung anwenden: Verwenden Sie einfach das Präfix gefolgt von den Objektnamen der beiden zu verknüpfenden Tabellen im Plural. Sie erhalten dann Tabellennamen wie beispielsweise tblArtikelBestellungen.<\/p>\n
    Wenn Sie die einzelnen Teile des Namens alphabetisch sortieren, müssen Sie sich noch nicht einmal mehr den Namen der Tabelle merken, wenn Sie wissen, welche Objekte die Tabelle verknüpft.<\/p>\n
    Natürlich gibt es auch die Möglichkeit, solchen Tabellen sprechende Namen zu geben. Die Tabelle tblArtikelBestellungen heißt in der Nordwind-Datenbank beispielsweise tblBestelldetails.<\/p>\n
    Wenn Sie aber ein Datenmodell mit vielen derartigen Tabellen verwenden, sind Sie mit der hier vorgeschlagenen Methode auf der sicheren Seite.<\/p>\n
    Leerzeichen und Sonderzeichen vermeiden<\/h2>\n
    Wenn Sie die oben genannten Regeln beachten, werden Sie vermutlich automatisch um die Anwendung von Leerzeichen in Variablen- und Objektnamen herumkommen.<\/p>\n
    Access erlaubt zwar Leerzeichen in solchen Bezeichnungen, aber da dies kein Standard ist, sollten Sie darauf verzichten. Sie könnten zum Beispiel Probleme bekommen, wenn Ihre Datenbank eines Tages zu groß für die Jet-Engine von Access wird und Sie diese auf ein alternatives Datenbanksystem portieren möchten, das keine Leerzeichen in Objektnamen erlaubt. Die Folge wäre, dass Sie den kompletten Code bezüglich dieser Bezeichnungen anpassen müssten.<\/p>\n
    Gleiches gilt für Sonderzeichen. Aber bei konsequenter Anwendung der ungarischen Notation bietet sich auch keine Gelegenheit, Sonderzeichen in Variablen- oder Objektnamen unterzubringen.<\/p>\n
    Die Verwendung der ungarischen Notation ist ein wichtiger Schritt zur Vereinfachung der Programmierung von Access-Datenbanken und von Anwendungen im Allgemeinen. Wenn der Aufbau der Bezeichnungen von Variablen und Objekten einmal verinnerlicht ist, werden Sie kaum noch einmal einen Variablennamen im Deklarationsteil oder einen Objektnamen im Datenbankfenster nachsehen müssen. Gerade bei Softwareprojekten mit mehreren Entwicklern ist die Einhaltung solcher Konventionen sinnvoll.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Bei der Entwicklung von Applikationen steht der Entwickler oft vor der Frage, wie Variablen, Kon-stanten, Objekte und so weiter heißen sollen. Vor allem dann, wenn Anwendungen im Team entstehen, ist die Standardisierung von Bezeichnungen wichtig. So entstehen Namenskonventionen, die festlegen, welche Klassen oder Kategorien von Objekten mit welchen Namenskürzeln identifiziert und gruppiert werden. Dies ist notwendig, damit andere Team-Mitarbeiter den geschaffenen Programmcode schneller verstehen, erleichtert aber ebenso die Wartung von Anwendungen in Zukunft durch die Entwickler selbst oder Drittpersonen. Dieser Artikel vermittelt Informationen über eine in der Programmierung weit verbreitete Konvention – die ungarische Notation.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662003,66052003,44000025],"tags":[],"class_list":["post-55000128","post","type-post","status-publish","format-standard","hentry","category-662003","category-66052003","category-VBA_und_Programmiertechniken"],"yoast_head":"\nEffektiver programmieren mit der ungarischen Notation - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Effektiver programmieren mit der ungarischen Notation\" \/>\n<meta property=\"og:description\" content=\"Bei der Entwicklung von Applikationen steht der Entwickler oft vor der Frage, wie Variablen, Kon-stanten, Objekte und so weiter heißen sollen. Vor allem dann, wenn Anwendungen im Team entstehen, ist die Standardisierung von Bezeichnungen wichtig. So entstehen Namenskonventionen, die festlegen, welche Klassen oder Kategorien von Objekten mit welchen Namenskürzeln identifiziert und gruppiert werden. Dies ist notwendig, damit andere Team-Mitarbeiter den geschaffenen Programmcode schneller verstehen, erleichtert aber ebenso die Wartung von Anwendungen in Zukunft durch die Entwickler selbst oder Drittpersonen. Dieser Artikel vermittelt Informationen über eine in der Programmierung weit verbreitete Konvention - die ungarische Notation.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-06T15:17:32+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"16\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Effektiver programmieren mit der ungarischen Notation\",\"datePublished\":\"2020-05-06T15:17:32+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/\"},\"wordCount\":3096,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/9cd7a44a8459437d8611709189a6a24e\",\"articleSection\":[\"2003\",\"5\\\/2003\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/\",\"name\":\"Effektiver programmieren mit der ungarischen Notation - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/9cd7a44a8459437d8611709189a6a24e\",\"datePublished\":\"2020-05-06T15:17:32+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/9cd7a44a8459437d8611709189a6a24e\",\"contentUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/9cd7a44a8459437d8611709189a6a24e\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Effektiver_programmieren_mit_der_ungarischen_Notation\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Effektiver programmieren mit der ungarischen Notation\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Effektiver programmieren mit der ungarischen Notation - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/","og_locale":"de_DE","og_type":"article","og_title":"Effektiver programmieren mit der ungarischen Notation","og_description":"Bei der Entwicklung von Applikationen steht der Entwickler oft vor der Frage, wie Variablen, Kon-stanten, Objekte und so weiter heißen sollen. Vor allem dann, wenn Anwendungen im Team entstehen, ist die Standardisierung von Bezeichnungen wichtig. So entstehen Namenskonventionen, die festlegen, welche Klassen oder Kategorien von Objekten mit welchen Namenskürzeln identifiziert und gruppiert werden. Dies ist notwendig, damit andere Team-Mitarbeiter den geschaffenen Programmcode schneller verstehen, erleichtert aber ebenso die Wartung von Anwendungen in Zukunft durch die Entwickler selbst oder Drittpersonen. Dieser Artikel vermittelt Informationen über eine in der Programmierung weit verbreitete Konvention - die ungarische Notation.","og_url":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-06T15:17:32+00:00","og_image":[{"url":"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"16\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Effektiver programmieren mit der ungarischen Notation","datePublished":"2020-05-06T15:17:32+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/"},"wordCount":3096,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e","articleSection":["2003","5\/2003","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/","url":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/","name":"Effektiver programmieren mit der ungarischen Notation - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e","datePublished":"2020-05-06T15:17:32+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#primaryimage","url":"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e","contentUrl":"http:\/\/vg05.met.vgwort.de\/na\/9cd7a44a8459437d8611709189a6a24e"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Effektiver_programmieren_mit_der_ungarischen_Notation\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Effektiver programmieren mit der ungarischen Notation"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000128","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000128"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000128\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000128"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000128"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000128"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}