Vergleich von Datenserialisierungsformaten

Dies ist ein Vergleich von Datenserialisierungsformaten , verschiedenen Methoden zur Umwandlung komplexer Objekte in Bitfolgen . Auszeichnungssprachen, die ausschließlich als Dokumentdateiformate verwendet werden , sind nicht enthalten .

Überblick

Name	Schöpfer-Betreuer	Bezogen auf	Standardisiert?	Spezifikation	Binär ?	Für Menschen lesbar ?	Unterstützt Referenzen ? ^e	Schema- IDL ?	Standard -APIs	Unterstützt Zero-Copy -Operationen
Apache Arrow	Apache Software Foundation	N / A	De facto	Pfeilspaltenformat	Ja	NEIN	Ja	Eingebaut	C, C++, C#, Go, Java, JavaScript, Julia, Matlab, Python, R, Ruby, Rust, Swift	Ja
Apache Avro	Apache Software Foundation	N / A	NEIN	Apache Avro™ Spezifikation	Ja	Teil ^g	N / A	Eingebaut	C, C#, C++, Java, PHP, Python, Ruby	N / A
Apache Parquet	Apache Software Foundation	N / A	NEIN	Apache Parquet	Ja	NEIN	NEIN	N / A	Java, Python, C++	NEIN
Apache Thrift	Facebook (Gründer) Apache (Betreuer)	N / A	NEIN	Originales Whitepaper	Ja	Teilweise ^c	NEIN	Eingebaut	C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml, Delphi und andere Sprachen ^{[ 1 ]}	N / A
ASN.1	ISO , IEC , ITU-T	N / A	Ja	Die Normenreihen ISO/IEC 8824 / ITU-T X.680 (Syntax) und ISO/IEC 8825 / ITU-T X.690 (Kodierungsregeln) definieren Syntax und Semantik. X.680, X.681 und X.683 legen die Syntax und Semantik fest.	BER , DER , PER , OER oder kundenspezifisch über ECN	XER , JER , GSER oder kundenspezifisch über ECN	Ja ^f	Eingebaut	N / A	OER
Bencode	Bram Cohen (Erfinder) BitTorrent, Inc. (Betreuer)	N / A	De facto als BEP	Teil der BitTorrent-Protokollspezifikation	Ausgenommen sind Zahlen und Trennzeichen, die ASCII-kodiert sind.	NEIN	NEIN	NEIN	NEIN	NEIN
BSON	MongoDB	JSON	NEIN	BSON-Spezifikation	Ja	NEIN	NEIN	NEIN	NEIN	NEIN
Käpt'n Proto	Kenton Varda	N / A	NEIN	Cap'n Proto-Kodierungsspezifikation	Ja	Teilweise ^h	NEIN	Ja	NEIN	Ja
CBOR	Carsten Bormann, P. Hoffman	MessagePack ^{[ 2 ]}	Ja	RFC 8949	Ja	NEIN	Ja, durch Tagging	CDDL	FIDO2	NEIN
Kommagetrennte Werte (CSV)	RFC-Autor: Yakov Shafranovich	N / A	Unzählige informelle Varianten	RFC 4180 (unter anderem)	NEIN	Ja	NEIN	NEIN	NEIN	NEIN
Gemeinsame Datendarstellung (CDR)	Objektverwaltungsgruppe	N / A	Ja	Allgemeines Inter-ORB-Protokoll	Ja	NEIN	Ja	Ja	Ada, C, C++, Java, Cobol, Lisp, Python, Ruby, Smalltalk	N / A
D-Bus -Nachrichtenprotokoll	freedesktop.org	N / A	Ja	D-Bus-Spezifikation	Ja	NEIN	NEIN	Teilweise (Signaturzeichenfolgen)	Ja	N / A
Effizienter XML-Austausch (EXI)	W3C	XML , effizientes XML	Ja	Effizientes XML-Austauschformat (EXI) 1.0	Ja	XML	XPointer , XPath	XML-Schema	DOM , SAX , StAX , XQuery , XPath	N / A
Extensible Data Notation (edn)	Rich Hickey / Clojure-Community	Clojure	Ja	Offizielle EDN-Spezifikation	NEIN	Ja	NEIN	NEIN	Clojure, Ruby, Go, C++, Javascript, Java, CLR, ObjC, Python ^{[ 3 ]}	NEIN
Flachpuffer	Google	N / A	NEIN	Flatbuffers GitHub	Ja	Apache Arrow	Teilweise (innerhalb des Puffers)	Ja	C++, Java, C#, Go, Python, Rust, JavaScript, PHP, C, Dart, Lua, TypeScript	Ja
Fast Infoset	ISO , IEC , ITU-T	XML	Ja	ITU-T X.891 und ISO/IEC 24824-1:2007	Ja	NEIN	XPointer , XPath	XML-Schema	DOM , SAX , XQuery , XPath	N / A
FHIR	Gesundheitsstufe 7	REST- Grundlagen	Ja	Schnelle Ressourcen zur Interoperabilität im Gesundheitswesen	Ja	Ja	Ja	Ja	Hapi für FHIR ^{[ 4 ]} JSON , XML , Turtle	NEIN
INI	Microsoft	?	NEIN	Es gibt mehrere verschiedene	NEIN	Ja	?	?	?	?
Ion	Amazonas	JSON	NEIN	Die Amazon-Ionen-Spezifikation	Ja	Ja	NEIN	Ionenschema	C, C#, Go, Java, JavaScript, Python, Rust	N / A
Java -Serialisierung	Oracle Corporation	N / A	Ja	Java-Objektserialisierung	Ja	NEIN	Ja	NEIN	Ja	N / A
JSON	Douglas Crockford	JavaScript-Syntax	Ja	STD 90 /RFC 8259 (ergänzend: RFC 6901, RFC 6902), ECMA-404 , ISO/IEC 21778:2017	Nein, aber siehe BSON , Smile , UBJSON.	Ja	JSON-Pointer (RFC 6901) oder alternativ JSONPath , JPath , JSPON , json:select() ; und JSON-LD	Teilweise ( JSON Schema Proposal , ASN.1 mit JER , Kwalify, archiviert am 12.08.2021 in der Wayback Machine , Rx , JSON-LD)	Partial ( Clarinet , JSONQuery / RQL , JSONPath ), JSON-LD	NEIN
MessagePack	Sadayuki Furuhashi	JSON (ungefähr)	NEIN	MessagePack-Formatspezifikation	Ja	NEIN	NEIN	NEIN	NEIN	Ja
Netzstrings	Dan Bernstein	N / A	NEIN	netstrings.txt	Ausgenommen sind ASCII-Begrenzer.	Ja	NEIN	NEIN	NEIN	Ja
OGDL	Rolf Veen	?	NEIN	Spezifikation	Binärspezifikation	Ja	Pfadspezifikation	Schema WD		N / A
OPC-UA Binär	OPC-Stiftung	N / A	NEIN	opcfoundation.org	Ja	NEIN	Ja	NEIN	NEIN	N / A
OpenDDL	Eric Lengyel	C , PHP	NEIN	OpenDDL.org	NEIN	Ja	Ja	NEIN	OpenDDL-Bibliothek	N / A
PHP-Serialisierungsformat	PHP-Gruppe	N / A	Ja	NEIN	Ja	Ja	Ja	NEIN	Ja	N / A
Pickle (Python)	Guido van Rossum	Python	De facto als PEPs	PEP 3154 – Pickle-Protokoll Version 4	Ja	NEIN	Ja ^{[ 5 ]}	NEIN	Ja	NEIN
Immobilienliste	NeXT (Entwickler) Apple (Betreuer)	?	Teilweise	Öffentliche DTD für das XML-Format	Ja	Ja ^b	NEIN	?	Cocoa , CoreFoundation , OpenStep , GnuStep	NEIN
Protocol Buffers (protobuf)	Google	N / A	NEIN	Entwicklerhandbuch: Kodierung , Proto2-Spezifikation und Proto3-Spezifikation	Ja	Ja ^d	NEIN	Eingebaut	C++, Java, C#, Python, Go, Ruby, Objective-C, C, Dart, Perl, PHP, R, Rust, Scala, Swift, Julia, D, ActionScript, Delphi, Elixir, Elm, Erlang, GopherJS, Haskell, Haxe, JavaScript, Kotlin, Lua, Matlab, Mercurt, OCaml, Prolog, Solidity, TypeScript, Vala, Visual Basic	NEIN
S-Ausdrücke	John McCarthy (Original) Ron Rivest (Internet-Entwurf)	Lisp , Netzstrings	Weitgehend de facto	„S-Expressions“ (Archiviert am 07.10.2013 im Internetarchiv Wayback Machine, Entwurf)	Ja, kanonische Darstellung	Ja, fortgeschrittene Transportdarstellung	NEIN	NEIN		N / A
Lächeln	Tatu Saloranta	JSON	NEIN	Spezifikation des Smile-Formats	Ja	NEIN	Ja	Teilweise ( JSON-Schema-Vorschlag , andere JSON-Schemas/IDLs)	Teilweise (über JSON-APIs, implementiert mit Smile-Backend, auf Jackson, Python)	N / A
SEIFE	W3C	XML	Ja	W3C-Empfehlungen : SOAP/1.1 SOAP/1.2	Teilweise ( Effizienter XML-Austausch , Binäres XML , Schnelles Infoset , MTOM , XSD -Base64-Daten )	Ja	Eingebaute ID/Referenz, XPointer , XPath	WSDL , XML-Schema	DOM , SAX , XQuery , XPath	N / A
Formate für den Austausch strukturierter Daten	Max Wildgrube	N / A	Ja	RFC 3072	Ja	NEIN	NEIN	NEIN		N / A
TOML	Tom Preston-Werner	INI- Dateiformat	Ja	Version 1.1.0 Neueste Version	NEIN	Ja	?	?	?	?
UBJSON	The Buzz Media, LLC	JSON , BSON	NEIN	ubjson.org	Ja	NEIN	NEIN	NEIN	NEIN	N / A
Externe Datenrepräsentation (XDR)	Sun Microsystems (Entwickler) IETF (Betreuer)	N / A	Ja	STD 67 /RFC 4506	Ja	NEIN	Ja	Ja	Ja	N / A
XML	W3C	SGML	Ja	W3C-Empfehlungen : 1.0 (Fünfte Ausgabe) 1.1 (Zweite Ausgabe)	Teilweise ( Effizienter XML-Austausch , Binäres XML , Schnelles Infoset , XSD- Base64-Daten )	Ja	XPointer , XPath	XML-Schema , RELAX NG	DOM , SAX , XQuery , XPath	N / A
XML-RPC	Dave Winer ^{[ 6 ]}	XML	NEIN	XML-RPC-Spezifikation	NEIN	Ja	NEIN	NEIN	NEIN	NEIN
YAML	Clark Evans, Ingy döt Net und Oren Ben-Kiki	C , Java , Perl , Python , Ruby , E-Mail , HTML , MIME , URI , XML , SAX , SOAP , JSON ^{[ 7 ]}	NEIN	Version 1.2	NEIN	Ja	Ja	Teilweise ( Kwalify, archiviert am 12.08.2021 in der Wayback Machine , Rx , integrierte Sprachtypdefinitionen)	NEIN	NEIN
Name	Schöpfer-Betreuer	Bezogen auf	Standardisiert?	Spezifikation	Binär ?	Für Menschen lesbar ?	Unterstützt Referenzen ? ^e	Schema- IDL ?	Standard -APIs	Unterstützt Zero-Copy -Operationen

^ Das aktuelle Standardformat ist binär.
^ Das "klassische" Format ist Klartext, aber auch ein XML-Format wird unterstützt.
^ Theoretisch möglich aufgrund der Abstraktion, jedoch ist keine Implementierung enthalten.
^ Das primäre Format ist binär, es stehen aber auch Text- und JSON-Formate zur Verfügung.^{[ 8 ]}^{[ 9 ]}
^ bedeutet, dass generische Tools/Bibliotheken wissen, wie man eine Referenz auf ein anderes Datenelement im selben Dokument kodiert, dekodiert und auflöst. Ein Tool benötigt möglicherweise dieIDL-Datei, aber nicht mehr. Benutzerdefinierte, nicht standardisierte Referenzierungstechniken sind ausgeschlossen.
ASN.1 bietet mit X.681 (Information Object System), X.682 (Constraints) und X.683 (Parametrisierung) die Möglichkeit, offene Typen präzise zu spezifizieren, deren Werte durch Ganzzahlen,OIDsusw. identifiziert werden können. OIDs sind ein Standardformat für global eindeutige Identifikatoren und gleichzeitig eine Standardnotation („absolute Referenz“) zum Verweisen auf eine Komponente eines Wertes. Beispielsweise verwendet PKIX diese Notation in RFC 5912. Mithilfe dieser Notation (Constraints für parametrisierte Typen mittels Informationsobjektmengen) können generische ASN.1-Tools und -Bibliotheken Referenzen innerhalb eines Dokuments automatisch kodieren, dekodieren und auflösen.
^ Das primäre Format ist binär, ein JSON-Encoder ist verfügbar.^{[ 10 ]}
^ Das primäre Format ist binär, es ist aber auch ein Textformat verfügbar.

Syntaxvergleich von für Menschen lesbaren Formaten

Format	Null	Boolescher Wert: wahr	Boolescher Wert: false	Ganze Zahl	Gleitkommazahl	Zeichenkette	Array	Assoziatives Array / Objekt
ASN.1 (XML-Kodierungsregeln)	`<foo />`	`<foo>true</foo>`	`<foo>false</foo>`	`<foo>685230</foo>`	`<foo>6.8523015e+5</foo>`	`<foo>A to Z</foo>`	<SeqOfUnrelatedDatatypes> <isMarried> true </isMarried> <hobby /> <velocity> -42.1e7 </velocity> <bookname> A bis Z </bookname> <bookname> Wir sagten: "Nein." </bookname> </SeqOfUnrelatedDatatypes>	Ein Objekt (der Schlüssel ist ein Feldname): <person> <isMarried> true </isMarried> <hobby /> <height> 1.85 </height> <name> Bob Peterson </name> </person> Eine Datenzuordnung (der Schlüssel ist ein Datenwert): <competition> <measurement> <name> John </name> <height> 3.14 </height> </measurement> <measurement> <name> Jane </name> <height> 2.718 </height> </measurement> </competition> ^A
CSV ^b	`null`^a (oder ein leeres Element in der Zeile)^a	`1`^a`true`^a	`0`^a`false`^a	`685230-685230`^A	`6.8523015e+5`^A	`A to Z"We said, ""no""."`	`true,,-42.1e7,"A to Z"`	42,1 A bis Z, 1, 2, 3
edn	`nil`	`true`	`false`	`685230-685230`	`6.8523015e+5`	`"A to Z"`,`"A \"up to\" Z"`	`[true nil -42.1e7 "A to Z"]`	`{:kw 1, "42" true, "A to Z" [1 2 3]}`
Ion	`nullnull.nullnull.boolnull.intnull.floatnull.decimalnull.timestampnull.stringnull.symbolnull.blobnull.clobnull.structnull.listnull.sexp`	`true`	`false`	`685230-6852300xA74AE0b111010010101110`	`6.8523015e5`	`"A to Z"'''A to Z'''`	[ true , null , -42.1e7 , "A bis Z" ]	{ '42' : true , 'A bis Z' : [ 1 , 2 , 3 ]}
Netzstrings ^c	`0:,`^a`4:null,`^a	`1:1,`^a`4:true,`^a	`1:0,`^a`5:false,`^a	`6:685230,`^A	`9:6.8523e+5,`^A	`6:A to Z,`	`29:4:true,0:,7:-42.1e7,6:A to Z,,`	`41:9:2:42,1:1,,25:6:A to Z,12:1:1,1:2,1:3,,,,`^A
JSON	`null`	`true`	`false`	`685230-685230`	`6.8523015e+5`	`"A to Z"`	[ true , null , -42.1e7 , "A bis Z" ]	{ "42" : true , "A bis Z" : [ 1 , 2 , 3 ]}
OGDL	`null`^A	`true`^A	`false`^A	`685230`^A	`6.8523015e+5`^A	`"A to Z"'A to Z'NoSpaces`	WAHR null -42,1e7 "Von A bis Z" `(true, null, -42.1e7, "A to Z")`	42 WAHR "Von A bis Z" 1 2 3 42 WAHR "A bis Z", (1, 2, 3)
OpenDDL	`ref {null}`	`bool {true}`	`bool {false}`	`int32 {685230}int32 {0x74AE}int32 {0b111010010101110}`	`float {6.8523015e+5}`	`string {"A to Z"}`	Homogene Anordnung: int32 {1, 2, 3, 4, 5} Heterogenes Array: Array { bool {true} ref {null} float {-42.1e7} Zeichenkette {"A bis Z"} }	Wörterbuch { Wert (Schlüssel = "42") {bool {true}} Wert (Schlüssel = "A bis Z") {int32 {1, 2, 3}} }
PHP-Serialisierungsformat	`N;`	`b:1;`	`b:0;`	`i:685230;i:-685230;`	`d:685230.15;`^D`d:INF;d:-INF;d:NAN;`	`s:6:"A to Z";`	`a:4:{i:0;b:1;i:1;N;i:2;d:-421000000;i:3;s:6:"A to Z";}`	Assoziatives Array: `a:2:{i:42;b:1;s:6:"A to Z";a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}}`Objekt: `O:8:"stdClass":2:{s:4:"John";d:3.14;s:4:"Jane";d:2.718;}`^d
Pickle (Python)	`N.`	`I01\n.`	`I00\n.`	`I685230\n.`	`F685230.15\n.`	`S'A to Z'\n.`	`(lI01\na(laF-421000000.0\naS'A to Z'\na.`	`(dI42\nI01\nsS'A to Z'\n(lI1\naI2\naI3\nas.`
Eigenschaftsliste (im Klartextformat) ^{[ 11 ]}	N / A	`<*BY>`	`<*BN>`	`<*I685230>`	`<*R6.8523015e+5>`	`"A to Z"`	`( <BY>, <R-42.1e7>, "A to Z" )`	{ "42" = <BY>; „A bis Z“ = ( <I1>, <I2>, <I3> ); }
Eigenschaftsliste (XML-Format) ^{[ 12 ]}	N / A	`<true />`	`<false />`	`<integer>685230</integer>`	`<real>6.8523015e+5</real>`	`<string>A to Z</string>`	<array> <true /> <real> -42.1e7 </real> <string> A bis Z </string> </array>	<dict> <key> 42 </key> <true /> <key> A bis Z </key> <array> <integer> 1 </integer> <integer> 2 </integer> <integer> 3 </integer> </array> </dict>
Protokollpuffer	N / A	`true`	`false`	`685230-685230`	`20.0855369`	`"A to Z""sdfff2 \000\001\002\377\376\375""q\tqq<>q2&\001\377"`	Feld1: "Wert1" Feld1: "Wert2" Feld1: "Wert3 anotherfield { foo: 123 Balken: 456 } anotherfield { foo: 222 Balken: 333 }	thing1 : "blahblah" thing2 : 18923743 thing3 : - 44 thing4 { submessage_field1 : "foo" submessage_field2 : false } enumeratedThing : SomeEnumeratedValue thing5 : 123.456 [ extensionFieldFoo ] : "etc" [ extensionFieldThatIsAnEnum ] : EnumValue
S-Ausdrücke	`NILnil`	`T#t`^F`true`	`NIL#f`^F`false`	`685230`	`6.8523015e+5`	`abc"abc"#616263#3:abc{MzphYmM=}\|YWJj\|`	`(T NIL -42.1e7 "A to Z")`	`((42 T) ("A to Z" (1 2 3)))`
TOML	N / A	`true`	`false`	`685230+685_230-6852300x_0A_74_AE0b1010_0111_0100_1010_1110`	`6.8523015e+5685.230_15e+03685_230.15inf-infnan`	`"A to Z"'A to Z'`	`["y", -42.1e7, "A to Z"]` [ "y", -42,1e7, "Von A bis Z" ]	`{ John = 3.14, Jane = 2.718 }` 42 = y "A bis Z" = [1, 2, 3]
YAML	`~nullNullNULL`^{[ 13 ]}	`yYyesYesYESonOnONtrueTrueTRUE`^{[ 14 ]}	`nNnoNoNOoffOffOFFfalseFalseFALSE`^{[ 14 ]}	`685230+685_230-685230024722560x_0A_74_AE0b1010_0111_0100_1010_1110190:20:30`^{[ 15 ]}	`6.8523015e+5685.230_15e+03685_230.15190:20:30.15.inf-.inf.Inf.INF.NaN.nan.NAN`^{[ 16 ]}	`A to Z"A to Z"'A to Z'`	`[y, ~, -42.1e7, "A to Z"]` - y - - -42,1e7 - A bis Z	`{"John":3.14, "Jane":2.718}` 42: y A bis Z: [1, 2, 3]
XML ^und SOAP	`<null />`^A	`true`	`false`	`685230`	`6.8523015e+5`	`A to Z`	<item> true </item> <item xsi:nil= "true" /> <item> -42.1e7 </item> <item> A bis Z <item>	<map> <entry key= "42" > true </entry> <entry key= "A to Z" > <item val= "1" /> <item val= "2" /> <item val= "3" /> </entry> </map>
XML-RPC		`<value><boolean>1</boolean></value>`	`<value><boolean>0</boolean></value>`	`<value><int>685230</int></value>`	`<value><double>6.8523015e+5</double></value>`	`<value><string>A to Z</string></value>`	<value><array> <data> <value><boolean> 1 </boolean></value> <value><double> -42.1e7 </double></value> <value><string> A bis Z </string></value> </data> </array></value>	<value><struct> <member> <name> 42 </name> <value><boolean> 1 </boolean></value> </member> <member> <name> A bis Z </name> <value> <array> <data> <value><int> 1 </int></value> <value><int> 2 </int></value> <value><int> 3 </int></value> </data> </array> </value> </member> </struct>

^ Ausgelassene XML-Elemente werden vonXML-Datenbindungstoolsals NULL-Werte dekodiert. Hier wird eine weitere mögliche Kodierung gezeigt;das XML-Schemadefiniert keine Kodierung für diesen Datentyp.
^ Die RFC-CSV-Spezifikation befasst sich nur mit Trennzeichen, Zeilenumbrüchen und Anführungszeichen; sie befasst sich nicht direkt mit der Serialisierung vonProgrammierdatenstrukturen.
^ DieNetstrings-Spezifikation befasst sich ausschließlich mit verschachteltenByte-Strings; alles andere fällt nicht in den Geltungsbereich der Spezifikation.
PHP deserialisiert Gleitkommazahlen korrekt, serialisiert sie aber in ihrer vollständigen Dezimaldarstellung. Beispielsweise wird 3,14 zu 10 ...3.140 000 000 000 000 124 344 978 758 017 532 527 446 746 826 171 875 .
^ XML-DatenbindungenundSOAP-Serialisierungswerkzeuge ermöglichen die typsichere XML-Serialisierung von ProgrammierdatenstruktureninXML. Dargestellt sind XML-Werte, die in XML-Elementen und -Attributen verwendet werden können.
^ Diese Syntax ist nicht mit dem Internet-Draft kompatibel, wird aber von einigen Lisp-Dialekten verwendet.

Vergleich binärer Formate

Format	Null	Boolesche Werte	Ganze Zahl	Gleitkommazahl	Zeichenkette	Array	Assoziatives Array / Objekt
ASN.1 ( BER- , PER- oder OER -Kodierung)	NULL- Typ	BOOLEAN : BER: als 1 Byte in Binärform; PER: als 1 Bit; OER: als 1 Byte	GANZZAHL : BER: Binärdarstellung variabler Länge im Big-Endian-Format (bis zu 2 ^{2 ¹⁰²⁴} Bit); PER Unaligned: eine feste Anzahl von Bits, wenn der Integer-Typ einen endlichen Wertebereich hat; andernfalls eine variable Anzahl von Bits; PER-ausgerichtet: eine feste Anzahl von Bits, wenn der Integer-Typ einen endlichen Bereich hat und die Größe des Bereichs kleiner als 65536 ist; andernfalls eine variable Anzahl von Oktetten; OER: 1, 2 oder 4 Oktette (entweder mit oder ohne Vorzeichen), falls der Integer-Typ einen endlichen Wertebereich besitzt, der in diese Anzahl von Oktetten passt; andernfalls eine variable Anzahl von Oktetten.	REAL : Im ISO-6093-Format werden reelle Werte zur Basis 10 als Zeichenketten dargestellt; Binäre reelle Werte werden in einem Binärformat dargestellt, das die Mantisse, die Basis (2, 8 oder 16) und den Exponenten enthält; Die Sonderwerte NaN, -INF, +INF und negative Null werden ebenfalls unterstützt.	Mehrere gültige Typen ( VisibleString, PrintableString, GeneralString, UniversalString, UTF8String )	Datenspezifikationen SET OF (ungeordnet) und SEQUENCE OF (garantierte Reihenfolge)	Benutzerdefinierbarer Typ
BSON	`\x0A`(1 Byte)	Wahr: `\x08\x01`Falsch: `\x08\x00`(2 Bytes)	int32: 32-Bit- Little-Endian -Zweierkomplement oder int64: 64-Bit- Little-Endian- Zweierkomplement	Double : little-endian binary64	UTF-8- kodiert, gefolgt von der int32-kodierten Zeichenkettenlänge in Bytes	BSON- eingebettetes Dokument mit numerischen Schlüsseln	BSON eingebettetes Dokument
Kurze binäre Objektdarstellung (CBOR)	`\xf6`(1 Byte)	WAHR:`\xf5` FALSCH:`\xf4` (1 Byte)	Kleine positive/negative `\x00`– `\x17`& `\x20`– `\x37`(1 Byte) 8-Bit: positiv `\x18`, negativ `\x38`(+ 1 Byte) 16-Bit: positiv `\x19`, negativ `\x39`(+ 2 Bytes) 32-Bit: positiv `\x1A`, negativ `\x3A`(+ 4 Bytes) 64-Bit: positiv `\x1B`, negativ `\x3B`(+ 8 Bytes) Negatives x wird als (−x − 1) kodiert	IEEE Half/Single/Double `\xf9`– `\xfb`(+ 2–8 Bytes) Dezimalzahlen und Bigfloat-Werte (4+ Bytes) werden als `\xc4`Tag + 2-elementiges Array aus Mantisse und Exponent kodiert.	Länge und Inhalt (1–9 Byte Overhead) Bytestring `\x40`–`\x5f` UTF-8`\x60` –`\x7f` Unbestimmte Teilstrings `\x5f`, die `\x7f`zusammengefügt werden, bis `\xff`.	Länge und Elemente `\x80`–`\x9e` Unbestimmte Liste, `\x9f`die durch `\xff`einen Eintrag beendet wird.	Länge (in Paaren) und Elemente `\xa0`–`\xbe` Unbestimmte Abbildung, `\xbf`die durch `\xff`den Schlüssel beendet wird.
Effizienter XML-Austausch (EXI) ^{[ a ]} (Nicht erhaltenes lexikalisches Werteformat)	xsi:nil ist im Binärkontext nicht zulässig.	1-2-Bit-Ganzzahl, die als boolescher Wert interpretiert wird.	Boolesches Vorzeichen, plus 7-Bit-Oktette beliebiger Länge, analysiert, bis das höchstwertige Bit 0 ist, in Little-Endian-Formatierung. Das Schema kann den Nullpunkt auf eine beliebige Zahl setzen. Unsigned überspringt das boolesche Flag.	Gleitkommazahl: ganzzahlige Mantisse und ganzzahliger Exponent. Dezimal: Boolesches Vorzeichen, ganzzahliger Wert, ganzzahliger Bruchteil.	Unicode-Werte, die mit einer Längenangabe versehen sind und als ganze Zahlen kodiert werden. Ganze Zahlen können stattdessen Aufzählungen oder Einträge in einer Zeichenkettentabelle darstellen.	Liste von Elementen mit vorangestellter Länge.	Nicht im Protokoll vorgesehen.
Flachpuffer	Als Fehlen eines Feldes im übergeordneten Objekt kodiert	WAHR:`\x01` FALSCH:`\x00` (1 Byte)	Little-Endian Zweierkomplement, vorzeichenbehaftet und vorzeichenlos, 8/16/32/64 Bit	Gleitkommazahlen : Little-Endian binary32 Doubles : little-endian binary64	UTF-8- kodiert, gefolgt von der 32-Bit-Ganzzahllänge der Zeichenkette in Bytes	Vektoren beliebigen anderen Typs, denen die Länge der Anzahl der Elemente als 32-Bit-Ganzzahl vorangestellt ist.	Tabellen (Schema-definierte Typen) oder nach Schlüssel sortierte Vektoren (Maps / Wörterbücher)
Ion ^{[ 18 ]}	`\x0f`^{[ B ]}	WAHR:`\x11` FALSCH:`\x10`	Positiv `\x2x`, negativ`\x3x` Null wird immer im Tag-Byte kodiert. BigInts über 13 Byte (10⁴ Bit) haben einen zusätzlichen Speicherbedarf von mindestens einem Byte für die Länge.	`\x44`(32-Bit-Gleitkommazahl) `\x48`(64-Bit-Gleitkommazahl) Null wird immer im Tag-Byte kodiert.	UTF-8 :`\x8x` Andere Zeichenketten:`\x9x` Beliebige Länge und beliebiger Overhead	`\xbx`Beliebige Länge und beliebiger Overhead. Länge in Oktetten.	Strukturen (nummerierte Felder):`\xdx` Anmerkungen (benannte Felder):`\xex`
MessagePack	`\xc0`	WAHR:`\xc3` FALSCH:`\xc2`	Einzelbyte "fixnum" (Werte −32 – 127 ) oder Typcode (1 Byte) + Big-Endian (u)int8/16/32/64	Typcode (1 Byte) + IEEE Single/Double	Typcode + bis zu 15 Bytes oder Typcode + Länge als uint8/16/32 + Bytes; Die Kodierung ist nicht spezifiziert ^{[ 19 ].}	Als "fixarray" (Einzelbyte-Präfix + bis zu 15 Array-Elemente) oder Typcode (1 Byte) + 2–4 Byte Länge + Array-Elemente	Als "fixmap" (Einzelbyte-Präfix + bis zu 15 Schlüssel-Wert-Paare) oder Typcode (1 Byte) + 2–4 Byte Länge + Schlüssel-Wert-Paare
Netzstrings ^{[ c ]}	Nicht im Protokoll vorgesehen.	Nicht im Protokoll vorgesehen.	Nicht im Protokoll vorgesehen.	Nicht im Protokoll vorgesehen.	Längenkodiert als ASCII-Zeichenkette + ':' + Daten + ',' Die Längenberechnung berücksichtigt nur die Oktette zwischen ':' und ','.	Nicht im Protokoll vorgesehen.	Nicht im Protokoll vorgesehen.
OGDL Binär
Eigenschaftsliste (Binärformat)
Protokollpuffer			Variable Codierungslänge, vorzeichenbehaftet, 32 Bit: Varint-Codierung eines "ZigZag"-codierten Werts`(n << 1) XOR (n >> 31)` Variable Codierungslänge, vorzeichenbehaftet, 64 Bit: Varint-Codierung von „ZigZag“-codiert`(n << 1) XOR (n >> 63)` Konstante Codierungslänge 32 Bit: 32 Bit im Little-Endian -Zweierkomplement Konstante Codierungslänge 64 Bit: 64 Bit im Little-Endian -Zweierkomplement	Gleitkommazahlen : Little-Endian binary32 Doubles : little-endian binary64	UTF-8- kodiert, gefolgt von der Varint-kodierten ganzzahligen Länge der Zeichenkette in Bytes	Wiederholte Werte mit demselben Tag oder, nur bei Varint-kodierten Ganzzahlen, Werte, die zusammenhängend gepackt und mit Tag und Gesamtbytelänge versehen sind.	N / A
Lächeln	`\x21`	WAHR:`\x23` FALSCH:`\x22`	Einzelbyte "klein" (Werte −16 – 15 kodiert als `\xc0`–`\xdf` ), zickzackcodiertes `varint`s (1–11 Datenbytes) oder`BigInteger`	IEEE Single/Double,`BigDecimal`	Längenpräfixierte „kurze“ Zeichenketten (bis zu 64 Bytes), markerterminierte „lange“ Zeichenketten und (optionale) Rückverweise	Heterogene Arrays beliebiger Länge mit Endmarkierung	Schlüssel-Wert-Paare beliebiger Länge mit Endmarkierung
Structured Data eXchange Formats (SDXF)			Big-Endian-Ganzzahl mit Vorzeichen, 24 Bit oder 32 Bit.	Big-Endian IEEE Double	Entweder UTF-8- oder ISO 8859-1-kodiert	Liste von Elementen mit identischer ID und Größe, der ein Array-Header mit der Länge int16 vorangestellt ist.	Chunks können andere Chunks bis zu einer beliebigen Tiefe enthalten.
Sparsamkeit

^ Jede XML-basierte Darstellung kann komprimiert oder als EXI – "Efficient XML Interchange (EXI) Format 1.0 (Second Edition)" – generiert werden .^{[ 17 ]} – ein „Schema-basierter“ (im Gegensatz zu einem schema-abhängigen oder schema-losen) Binärkomprimierungsstandard für XML.
Alle grundlegenden Ion-Typen besitzen eine Null-Variante mit dem Tag 0xXf. Alle Tags, die mit 0x0X beginnen (außer 0x0f), definieren ignorierte Auffüllung.
^ Die Interpretation von Netstrings ist vollständig anwendungs- oder schemaabhängig.

Siehe auch

Vergleich von Dokumentauszeichnungssprachen

Referenzen

^ Apache Thrift
^ Bormann, Carsten (26.12.2018). „CBOR-Beziehung mit msgpack“ . GitHub . Abgerufen am 14.08.2023 .
^ "Implementierungen" . GitHub .
^ „HAPI FHIR – Die Open-Source-FHIR-API für Java“ . hapifhir.io .
^ cpython/Lib/pickle.py
^ „Eine kurze Geschichte von SOAP“ . www.xml.com .
^ Ben-Kiki, Oren; Evans, Clark; Net, Ingy döt (2009-10-01). „YAML Ain't Markup Language (YAML) Version 1.2“ . Die offizielle YAML-Website . Abgerufen am 10.02.2012 .
^ "text_format.h - Protocol Buffers" . Google Developers .
^ „JSON-Mapping – Protocol Buffers“ . Google Developers .
^ "Avro JSON-Format" .
^ „Dokumentation der NSPropertyListSerialization-Klasse“ . www.gnustep.org . Archiviert vom Original am 19.05.2011 . Abgerufen am 28.10.2009 .
^ „Dokumentationsarchiv“ . developer.apple.com .
^ Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Null Language-Independent Type for YAML Version 1.1“ . YAML.org . Abgerufen am 12.09.2009 .
^ ^a ^b Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Boolean Language-Independent Type for YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .
^ Oren Ben-Kiki; Clark Evans; Brian Ingerson (11.02.2005). „Integer Language-Independent Type for YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .
^ Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Gleitkomma-Sprachunabhängiger Typ für YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .
^ „Effizienter, erweiterbarer Austausch“ .
^ Ionenbinärkodierung
^ „MessagePack ist eine extrem effiziente Bibliothek zur Objektserialisierung. Sie ist wie JSON, aber sehr schnell und klein: msgpack/msgpack .“ 2. April 2019 – via GitHub.

Externe Links

[18] Jede XML-basierte Darstellung kann komprimiert oder als EXI – "Efficient XML Interchange (EXI) Format 1.0 (Second Edition)" – generiert werden .^{[ 17 ]} – ein „Schema-basierter“ (im Gegensatz zu einem schema-abhängigen oder schema-losen) Binärkomprimierungsstandard für XML.

[20] Alle grundlegenden Ion-Typen besitzen eine Null-Variante mit dem Tag 0xXf. Alle Tags, die mit 0x0X beginnen (außer 0x0f), definieren ignorierte Auffüllung.

[22] Die Interpretation von Netstrings ist vollständig anwendungs- oder schemaabhängig.

[1] Apache Thrift

[2] Bormann, Carsten (26.12.2018). „CBOR-Beziehung mit msgpack“ . GitHub . Abgerufen am 14.08.2023 .

[3] "Implementierungen" . GitHub .

[4] „HAPI FHIR – Die Open-Source-FHIR-API für Java“ . hapifhir.io .

[5] ython/Lib/pickle.py

[xmlrpc-hist-6] „Eine kurze Geschichte von SOAP“ . www.xml.com .

[7] Ben-Kiki, Oren; Evans, Clark; Net, Ingy döt (2009-10-01). „YAML Ain't Markup Language (YAML) Version 1.2“ . Die offizielle YAML-Website . Abgerufen am 10.02.2012 .

[8] "text_format.h - Protocol Buffers" . Google Developers .

[9] „JSON-Mapping – Protocol Buffers“ . Google Developers .

[10] "Avro JSON-Format" .

[gnustep-11] „Dokumentation der NSPropertyListSerialization-Klasse“ . www.gnustep.org . Archiviert vom Original am 19.05.2011 . Abgerufen am 28.10.2009 .

[12] „Dokumentationsarchiv“ . developer.apple.com .

[13] Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Null Language-Independent Type for YAML Version 1.1“ . YAML.org . Abgerufen am 12.09.2009 .

[yamlbool-14] Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Boolean Language-Independent Type for YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .

[15] Oren Ben-Kiki; Clark Evans; Brian Ingerson (11.02.2005). „Integer Language-Independent Type for YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .

[16] Oren Ben-Kiki; Clark Evans; Brian Ingerson (18.01.2005). „Gleitkomma-Sprachunabhängiger Typ für YAML Version 1.1“ . YAML.org . Clark C. Evans . Abgerufen am 12.09.2009 .

[17] „Effizienter, erweiterbarer Austausch“ .

[19] Ionenbinärkodierung

[21] „MessagePack ist eine extrem effiziente Bibliothek zur Objektserialisierung. Sie ist wie JSON, aber sehr schnell und klein: msgpack/msgpack .“ 2. April 2019 – via GitHub.

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[ 15 ]

[ 16 ]

[ a ]

[ 18 ]

[ B ]

[ 19 ].

[ c ]

[ 17 ]