Schlüssel/Wert-Paar: Unterschied zwischen den Versionen

aus GlossarWiki, der Glossar-Datenbank der Fachhochschule Augsburg
← zur vorherigen Versionen-Differenz
Kowa (Diskussion | Beiträge)
Administrator, Bots, Bürokraten, emailconfirmed, Oberflächenadministratoren, interwiki, oversight, SMW-Administratoren, SMW-Kuratoren, SMW-Editoren, Oversighter, Administratoren
42.989 Bearbeitungen
Keine Bearbeitungszusammenfassung
Kowa (Diskussion | Beiträge)
Administrator, Bots, Bürokraten, emailconfirmed, Oberflächenadministratoren, interwiki, oversight, SMW-Administratoren, SMW-Kuratoren, SMW-Editoren, Oversighter, Administratoren
42.989 Bearbeitungen
 
(75 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
{{Qualität
{{Qualität
|correctness        = 2
|correctness        = 4
|extent              = 2
|extent              = 4
|numberOfReferences  = 0
|numberOfReferences  = 3
|qualityOfReferences = 0
|qualityOfReferences = 4
|conformance        = 5
|conformance        = 4
}}
}}


==Definition (Kowarschick<ref>{{Quelle|Kowarschick (MMDB)}})==
==Definition (Kowarschick<ref name="MMDB">{{Quelle|Kowarschick (MMDB)}}</ref>)==
Attribute sind [[geordnetes Paar|geordnete Schlüssel-/Wert-Paare]] <math>(\rm{key}, \rm{value})</math> oder auch <code>key: value</code>. Der '''Schlüssel''' wird auch '''Attributbezeichner''' genannt. Und an Stelle von '''Wert''' sagt man häufig auch '''Attributwert'''.
'''Schlüssel-/Wert-Paare''' ('''key-value pairs''') sind [[geordnetes Paar|geordnete Paare]] <math>(\rm{key}, \rm{value})</math>,
die zur Benennung von [[Wert]]en dienen. Der ''Schlüssel'' (englisch: ''key'') dient dabei als ''Name'' des zugehörigen ''Wert''es (englisch: ''value'').  


Ein Attribut kann auch mehr als einen Attributebezeichner haben. In diesem Fall verwendet man Tripel, Quadrupel etc. zur Beschreibung von Attributen.
Dem Schlüssel kann ein [[Datentyp]] <math>\rm{typ}</math>, {{dh}} eine nicht-leere {{Menge}} (oder {{Klasse}})  zugeordnet werden,
der die möglichen Werte, die unter diesem Namen „gespeichert“ werden können, beschränkt.
Das geordnete Paar  <math>(\rm{key}, \rm{typ})</math> heißt '''Typdefinition''' zum Schlüssel-/Wert-Paar <math>(\rm{key}, \rm{value})</math>, falls <math>\rm{value}  \in \rm{typ}</math>.


Die erlaubten Attributwerte können mit Hilfe von so genannten {{Domäne}}n, {{dh}} mit Hilfe von nicht-leeren {{Menge}}n oder {{Klasse}}n beschränkt werden.
===Varianten===
Schlüssel/Wert-Paare kommen in der Mathematik und der Informatik unter ganz verschiedenen Bezeichungen vor:
{| class = "wikitable" style = "table-layout: fixed; max-width: 48em; border: 0;"
|-
! | '''Name'''
! | '''Schlüssel'''
! | '''Wert'''
! | '''Datentyp'''
! | '''[[EcmaScript]]/[[TypeScript]]-Beispiel'''
|-
| | Attribut<br/><br/>property
| | Attributname<br/>Attributbezeichner<br/>property<br/>name
| | Attributwert<br/><br/>property<br/>value
| | [[Domäne]]<br/>domain<br/>property<br/>type
| |
{| class="texttable"
|-
| style="width: 7.5em" | ''Attribut:''
|| Objekt: <code>{a: 5}</code>
|-
|| ''Attributname:''
|| <code>a</code>
|-
|| ''Attributwert:''
|| <code>5</code>
|-
|| ''Domäne:''
|| JavaScript-[[Universum]]
|}


==Beispiele==
|-
| | Variable
| | Variablenname
| | Variablenwert
| | Typ
| |
{| class="texttable"
|-
| style="width: 7.5em" | ''Variable:''
|| <code>let a: number = 5</code>
|-
|| ''Variablenname:''
|| <code>a</code>
|-
|| ''Variablenwert:''
|| <code>5</code>
|-
|| ''Typ:''
|| <code>number</code>
|}
|-
| | Parameter
| | Parameter
| | Argument
| | Typ
| |
{| class="texttable"
|-
| style="width: 7.5em" | ''Funktion:'' 
| | <code>let f = </code><br/><code>(a: number) => {a*a} </code>
|-
|| ''Funktionsaufruf:''
|| <code>f(5)</code>
|-
|| ''Parameter:''
|| <code>a</code>
|-
|| ''Argument:''
|| <code>5</code>
|-
|| ''Typ:''
|| <code>number</code>
|}
|-
| | [[Hash map|hash entry]]
| | hash key
| | hash value
| | hash type
| |
{| class="texttable"
|-
| style="width: 7.5em" | ''Map:'' 
|| <code>let m = new Map(); m.set('a', 5);</code>
|-
|| ''hash key:''
|| <code>a</code>
|-
|| ''hash value:''
|| <code>5</code>
|-
|| ''hash type:''
|| JavaScript-[[Universum]]
|}
|}
 
In [[SQL]] werden [[Tupel]] als Zeilen (''rows'') in [[Tabelle]]n (''tables'', das sind spezielle [[Relation]]en) gespeichert.
Die Tupelattribute haben dabei zwar nur einen Wert (<code>5</code> bzw. <code>6</code>) aber
jeweils ''zwei'' unterschiedliche Attributbezeichner: einen Namen (<code>a</code> bzw. <code>b</code>)
und eine Position  (Spalte <code>1</code> bzw. Spalte <code>b2</code>).
 
{| class = "wikitable"
|-
! | '''<code>a</code>'''
! | '''<code>b</code>'''
|-
| | <code>5</code>
| | <code>6</code>
|}
 
Ein derartiges Attribut kann durch ein Schlüssel/Schlüssel/Wert-Tripel dargestellt. Prinzipiell kann man auch Attribute mit noch mehr Namen definieren,
indem man anstelle von Schlüssel/Wert-Paaren und Schlüssel/Schlüssel/Wert-Tripeln auch Schlüssel/Schlüssel/Schlüssel/Wert-Quadrupel etc. zulässt.
Diese kommen in der Praxis allerdings kaum vor.
 
Schlüssel/Wert-Paare sind so universell einsetzbar, dass sie nicht nur in Programmiersprachen zum Einsatz kommen, sondern auch in
Auszeichnungssprachen, Transferprotokollen und an vielen weiteren Stellen im IT-Bereich:
 
* [[XML]]-Attribut-Listen<ref>[http://www.w3.org/TR/2008/REC-xml-20081126/#attdecls W3C: Extensible Markup Language (XML) 1.0 (Fifth Edition), 3.3 Attribute-List Declarations]</ref>: <code>&lt;p id="first", class="important"&gt;...&lt;/p&gt;</code>
* [[HTTP]]-Header-Attribute<ref>[https://tools.ietf.org/html/rfc2616#section-4.2 RFC 2616, Section 4.2]</ref>: <code>Accept-Charset: utf-8</code>
* [[E-Mail]]-Header-Attribute<ref>[https://tools.ietf.org/html/rfc2822#section-2.2 RFC 2822, Section 2.2]</ref>: <code>Date: 10 Aug 2019 12:02:45 +0100</code>
* Query-Strings in [[URL]]s<ref>[https://tools.ietf.org/html/rfc3986#section-3.4 RFC 3986, Section 3.4]</ref>: <code>?name=Eieruhr&preis=10.99</code>
*[[BibTeX]]-Einträge<ref>[http://www.bibtex.org/Format/de/ bibtex.org: BibTeX Format Beschreibung]</ref>: <code>@book{ wk, author = "W. Kowarschick", title = "...", ... }</code>
* [[OpenStreetMap]]-Tags<ref>[https://wiki.openstreetmap.org/wiki/Tags wiki.openstreetmap.org: Taga]</ref>: <code>name:de=Albrecht-Dürer-Straße</code>
* [[Initialisierungsdatei]]en (INI-Dateien)<ref>[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731332(v=ws.11) Microsoft: Configure an Ini File Item]</ref>: <code>PropertyName1=PropertyValue1</code>
* etc.
 
=== Schreibweisen===
Die Schreibweise von Schlüssel/Wert-Paaren hängt vom jewiligen Einsatzgebiet ab:
* <math>(\rm{key}, \rm{value})</math>, <math>(\rm{key1}, \rm{key2}, \rm{value})</math>, ...
* <math>[\rm{key}, \rm{value}]</math>, <math>[\rm{key1}, [\rm{key2}, \rm{value}]]</math>, ...
* <code>key: value</code> ({{zB}} [[HTTP]]-Header)
* <code>"key": value</code> ({{zB}} [[JSON]])
* <code>key=value</code>  ({{zB}} Query-String einer [[URL]])
* <code>key="value"</code> ({{zB}} [[XML]]-Attribut)
 
Der Schlüssel kann auch nur ''implizit'' vorhanden, wie beispielsweise die Position eines Attributs
in einem [[Tupel#Tupel_in_Listennotation_.28in_Anlehnung_an_McCarthy_et_al..5B4.5D.29|Tupel in Listennotation]].
 
Und es ist auch möglich, dass die Zuordung eines Wertes zu einem Schlüssel ''indirekt'' erfolgt. Zum Beispiel wird einem [[Funktionsparameter]] (Schlüssel)
durch einen [[Funktionsaufruf]] ein [[Funktionsargument]] (Wert) übergeben. Während der Ausführung des Funktionsrumpfes
besteht das so gebildete Schlüssel/Wert-Paar (sofern der Wert nicht im Funktionsrumpf geändert wird), danach wird es wieder gelöscht.
 
==Formale Definition (Kowarschick<ref name="MMDB"/>)==
'''Vorbemerkung'''<br/>
Nachfolgend werden '''Attribute''' definiert. Diese Definition kann eins zu eins für jede ander Art von  Schlüssel-Wert-Tupeln übernommen werden,
wobei natürlich die Begriffe entsprechend angepasst werden müssen.
 
'''Definition'''<br/>
Es seien <math>a^1, \ldots, a^m</math> paarweise verschiedene Werte (<math>m \ge 1</math>), die als Bezeichner fungieren,
<math>D</math> eine {{Domäne}}, {{dh}} eine nicht-leere {{Menge}} (oder {{Klasse}}), und
<math>v \in D</math> ein Element von <math>D</math>.
 
Dann heißt das [[Tupel|m+1-Tupel]] <math>(a^1, \ldots, a^m, D)</math> '''Attributdefinition'''
mit '''Attributnamen''' <math>a^1, \ldots, a^m</math> und {{Domäne}} <math>D</math>. Das Tupel
<math>(a^1, \ldots, a^m, v)</math> heißt '''Attribut (zur Domäne <math>D</math>)''' mit
'''Attributnamen''' <math>a^1, \ldots, a^m</math> und '''Attributwert''' <math>v</math>.
 
'''Anmerkung'''<br/>
Zur Definition von Attributen wurde der Begriff [[Tupel]] als bekannt vorausgesetzt.
Andererseits benötigt man zur Definition von allgemeinen Tupeln den zuvor definierten
Attributbegriff. Es liegt hier jedoch kein Circulus vitiosus (Zirkelschluss) vor,
da man Attribute gemäß [[John MaCarthy]]<ref>{{Quelle|McCarthy (1960)}}</ref> auch allein mit Hilfe von [[geordnetes Paar|geordneten Paaren]] <math>[a,b]</math> definieren kann:
<div class="formula"><math>\begin{array}[t]{lcl}
(a^1, \ldots, a^m, D) & := & [a^1, [a^2, \ldots [a^m, [D, \emptyset]]\ldots]] \\
(a^1, \ldots, a^m, v) & := & [a^1, [a^2, \ldots [a^m, [v, \emptyset]]\ldots]]
\end{array}</math></div>
 
(Formal müsste diese Definition rekursiv über die Anzahl der Attributnamen erfolgen.)
 
===Spezialfälle===
Es seien <math>i \in \mathbb N_0</math> eine natürliche Zahl und <math>a</math>
eine [[Zeichenkette]], die mit einem Buchstaben beginnt
sowie evtl. endlich viele weitere Zeichen enthält (Buchstaben, Ziffern und einige ausgewählte
Sonderzeichen wie <code>+</code>, <code>-</code>, <code>_</code>, <code>@</code>,
<code>$</code> etc.).
 
Dann heißen
* <math>(i, v)</math> '''Positionsattribut'''
* <math>(a, v)</math> '''benanntes Attribut'''
* <math>(a, i, v)</math> '''benanntes Positionsattribut'''
 
Folgende alternative Schreibweisen werden in diesem Wiki ebenfalls verwendet:
* '''Positionsattribut''': <math>i: v</math> ([[Formel]]) bzw.  <code>i: v</code> ([[Pseudocode]])
* '''benanntes Attribut''': <math>a: v</math> (Formel) bzw.  <code>a: v</code> (Pseudocode)
* '''benanntes Positionsattribut''': <math>a/i: v</math> (Formel) bzw.  <code>a/i: v</code> (Pseudocode)
 
'''Beispiele (Pseudocode)'''
{| class = "wikitable" style = "table-layout: fixed; max-width: 48em; border: 0;"
{| class = "wikitable" style = "table-layout: fixed; max-width: 48em; border: 0;"
|-
|-
Zeile 36: Zeile 222:
==Quellen==
==Quellen==
<references/>
<references/>
==Siehe auch==
* [[WikipediaEN:Attribute–value_pair]]
[[Kategorie:Datenmanagement]]
[[Kategorie:Datenmanagement]]

Aktuelle Version vom 13. August 2019, 15:32 Uhr

Dieser Artikel erfüllt die GlossarWiki-Qualitätsanforderungen nur teilweise:

Korrektheit: 4
(großteils überprüft) 		Umfang: 4
(unwichtige Fakten fehlen) 		Quellenangaben: 3
(wichtige Quellen vorhanden) 		Quellenarten: 4
(sehr gut) 		Konformität: 4
(sehr gut)

Definition (Kowarschick[1])

Schlüssel-/Wert-Paare (key-value pairs) sind geordnete Paare $ (\rm{key}, \rm{value}) $, die zur Benennung von Werten dienen. Der Schlüssel (englisch: key) dient dabei als Name des zugehörigen Wertes (englisch: value).

Dem Schlüssel kann ein Datentyp $ \rm{typ} $, d. h. eine nicht-leere Menge (oder Klasse) zugeordnet werden, der die möglichen Werte, die unter diesem Namen „gespeichert“ werden können, beschränkt. Das geordnete Paar $ (\rm{key}, \rm{typ}) $ heißt Typdefinition zum Schlüssel-/Wert-Paar $ (\rm{key}, \rm{value}) $, falls $ \rm{value} \in \rm{typ} $.

Varianten

Schlüssel/Wert-Paare kommen in der Mathematik und der Informatik unter ganz verschiedenen Bezeichungen vor:

Name Schlüssel Wert Datentyp EcmaScript/TypeScript-Beispiel
Attribut

property 		Attributname
Attributbezeichner
property
name 		Attributwert

property
value 		Domäne
domain
property
type
Attribut: Objekt: {a: 5}
Attributname: a
Attributwert: 5
Domäne: JavaScript-Universum
Variable Variablenname Variablenwert Typ
Variable: let a: number = 5
Variablenname: a
Variablenwert: 5
Typ: number
Parameter Parameter Argument Typ
Funktion: let f =
(a: number) => {a*a}
Funktionsaufruf: f(5)
Parameter: a
Argument: 5
Typ: number
hash entry hash key hash value hash type
Map: let m = new Map(); m.set('a', 5);
hash key: a
hash value: 5
hash type: JavaScript-Universum

In SQL werden Tupel als Zeilen (rows) in Tabellen (tables, das sind spezielle Relationen) gespeichert. Die Tupelattribute haben dabei zwar nur einen Wert (5 bzw. 6) aber jeweils zwei unterschiedliche Attributbezeichner: einen Namen (a bzw. b) und eine Position (Spalte 1 bzw. Spalte b2).

a b
5 6

Ein derartiges Attribut kann durch ein Schlüssel/Schlüssel/Wert-Tripel dargestellt. Prinzipiell kann man auch Attribute mit noch mehr Namen definieren, indem man anstelle von Schlüssel/Wert-Paaren und Schlüssel/Schlüssel/Wert-Tripeln auch Schlüssel/Schlüssel/Schlüssel/Wert-Quadrupel etc. zulässt. Diese kommen in der Praxis allerdings kaum vor.

Schlüssel/Wert-Paare sind so universell einsetzbar, dass sie nicht nur in Programmiersprachen zum Einsatz kommen, sondern auch in Auszeichnungssprachen, Transferprotokollen und an vielen weiteren Stellen im IT-Bereich:

  • XML-Attribut-Listen[2]: <p id="first", class="important">...</p>
  • HTTP-Header-Attribute[3]: Accept-Charset: utf-8
  • E-Mail-Header-Attribute[4]: Date: 10 Aug 2019 12:02:45 +0100
  • Query-Strings in URLs[5]: ?name=Eieruhr&preis=10.99
  • BibTeX-Einträge[6]: @book{ wk, author = "W. Kowarschick", title = "...", ... }
  • OpenStreetMap-Tags[7]: name:de=Albrecht-Dürer-Straße
  • Initialisierungsdateien (INI-Dateien)[8]: PropertyName1=PropertyValue1
  • etc.

Schreibweisen

Die Schreibweise von Schlüssel/Wert-Paaren hängt vom jewiligen Einsatzgebiet ab:

  • $ (\rm{key}, \rm{value}) $, $ (\rm{key1}, \rm{key2}, \rm{value}) $, ...
  • $ [\rm{key}, \rm{value}] $, $ [\rm{key1}, [\rm{key2}, \rm{value}]] $, ...
  • key: value (z. B. HTTP-Header)
  • "key": value (z. B. JSON)
  • key=value (z. B. Query-String einer URL)
  • key="value" (z. B. XML-Attribut)

Der Schlüssel kann auch nur implizit vorhanden, wie beispielsweise die Position eines Attributs in einem Tupel in Listennotation.

Und es ist auch möglich, dass die Zuordung eines Wertes zu einem Schlüssel indirekt erfolgt. Zum Beispiel wird einem Funktionsparameter (Schlüssel) durch einen Funktionsaufruf ein Funktionsargument (Wert) übergeben. Während der Ausführung des Funktionsrumpfes besteht das so gebildete Schlüssel/Wert-Paar (sofern der Wert nicht im Funktionsrumpf geändert wird), danach wird es wieder gelöscht.

Formale Definition (Kowarschick[1])

Vorbemerkung
Nachfolgend werden Attribute definiert. Diese Definition kann eins zu eins für jede ander Art von Schlüssel-Wert-Tupeln übernommen werden, wobei natürlich die Begriffe entsprechend angepasst werden müssen.

Definition
Es seien $ a^1, \ldots, a^m $ paarweise verschiedene Werte ($ m \ge 1 $), die als Bezeichner fungieren, $ D $ eine Domäne, d. h. eine nicht-leere Menge (oder Klasse), und $ v \in D $ ein Element von $ D $.

Dann heißt das m+1-Tupel $ (a^1, \ldots, a^m, D) $ Attributdefinition mit Attributnamen $ a^1, \ldots, a^m $ und Domäne $ D $. Das Tupel $ (a^1, \ldots, a^m, v) $ heißt Attribut (zur Domäne $ D $) mit Attributnamen $ a^1, \ldots, a^m $ und Attributwert $ v $.

Anmerkung
Zur Definition von Attributen wurde der Begriff Tupel als bekannt vorausgesetzt. Andererseits benötigt man zur Definition von allgemeinen Tupeln den zuvor definierten Attributbegriff. Es liegt hier jedoch kein Circulus vitiosus (Zirkelschluss) vor, da man Attribute gemäß John MaCarthy[9] auch allein mit Hilfe von geordneten Paaren $ [a,b] $ definieren kann:

$ \begin{array}[t]{lcl} (a^1, \ldots, a^m, D) & := & [a^1, [a^2, \ldots [a^m, [D, \emptyset]]\ldots]] \\ (a^1, \ldots, a^m, v) & := & [a^1, [a^2, \ldots [a^m, [v, \emptyset]]\ldots]] \end{array} $

(Formal müsste diese Definition rekursiv über die Anzahl der Attributnamen erfolgen.)

Spezialfälle

Es seien $ i \in \mathbb N_0 $ eine natürliche Zahl und $ a $ eine Zeichenkette, die mit einem Buchstaben beginnt sowie evtl. endlich viele weitere Zeichen enthält (Buchstaben, Ziffern und einige ausgewählte Sonderzeichen wie +, -, _, @, $ etc.).

Dann heißen

  • $ (i, v) $ Positionsattribut
  • $ (a, v) $ benanntes Attribut
  • $ (a, i, v) $ benanntes Positionsattribut

Folgende alternative Schreibweisen werden in diesem Wiki ebenfalls verwendet:

  • Positionsattribut: $ i: v $ (Formel) bzw. i: v (Pseudocode)
  • benanntes Attribut: $ a: v $ (Formel) bzw. a: v (Pseudocode)
  • benanntes Positionsattribut: $ a/i: v $ (Formel) bzw. a/i: v (Pseudocode)

Beispiele (Pseudocode)

Attributart Beispiel Domäne
Benanntes Attribut name: 'Anton' name: String
Positionsattribut 1: 'Anton' 1: String
Benanntes Positionsattribut 1/name: 'Anton' 1/name: String

Quellen

  1. ↑ 1,0 1,1 Kowarschick (MMDB): Wolfgang Kowarschick; Vorlesung „Multimedia-Datenbanksysteme“; Hochschule: Hochschule Augsburg; Adresse: Augsburg; Web-Link; 2016; Quellengüte: 3 (Vorlesung)
  2. ↑ W3C: Extensible Markup Language (XML) 1.0 (Fifth Edition), 3.3 Attribute-List Declarations
  3. ↑ RFC 2616, Section 4.2
  4. ↑ RFC 2822, Section 2.2
  5. ↑ RFC 3986, Section 3.4
  6. ↑ bibtex.org: BibTeX Format Beschreibung
  7. ↑ wiki.openstreetmap.org: Taga
  8. ↑ Microsoft: Configure an Ini File Item
  9. ↑ McCarthy (1960): John McCarthy; Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I; in: Communications of the ACM; Band: 3; Nummer: 4; Seite(n): 184-195; Verlag: Association for Computing Machinery; Adresse: New York; Web-Link 0, Web-Link 1; 1960; Quellengüte: 5 (Artikel)

Siehe auch

Abgerufen von „https://glossar.hs-augsburg.de/w/index.php?title=Schlüssel/Wert-Paar&oldid=48605“