From 8a1331c26acbf0bfc070e557d9dcc78c7fa1d6a2 Mon Sep 17 00:00:00 2001 From: Gregg Kellogg Date: Thu, 7 Jun 2018 15:07:58 -0700 Subject: [PATCH 1/3] Import of Final CG version. --- index.html | 5672 ++++++++++++++++++++++++++++++++++++++++- linked-data-graph.dia | Bin 0 -> 2150 bytes linked-data-graph.png | Bin 0 -> 27844 bytes 3 files changed, 5641 insertions(+), 31 deletions(-) create mode 100644 linked-data-graph.dia create mode 100644 linked-data-graph.png diff --git a/index.html b/index.html index a4066ca3..82999bd8 100644 --- a/index.html +++ b/index.html @@ -1,38 +1,5648 @@ - + - - - Spec proposal - - + + + + + + +
+

JSON is a useful data serialization and messaging format. + This specification defines JSON-LD, a JSON-based format to serialize + Linked Data. The syntax is designed to easily integrate into deployed + systems that already use JSON, and provides a smooth upgrade path from + JSON to JSON-LD. + It is primarily intended to be a way to use Linked Data in Web-based + programming environments, to build interoperable Web services, and to + store Linked Data in JSON-based storage engines.

+
+ +
+

This document has been developed by the + JSON for Linking Data W3C Community Group + as an update to the 1.0 recommendation [[JSON-LD]] developed + by the RDF Working Group. + The specification has undergone + significant development, review, and changes during the course of several years.

+ +

There are several independent + interoperable implementations of + this specification, a test suite [[JSON-LD-TESTS]] and a + live JSON-LD playground that is capable + of demonstrating the features described in this document.

+ +
+

Set of Documents

+

This document is one of three JSON-LD 1.1 Recommendations produced by the + JSON for Linking Data W3C Community Group:

+ + +
+
+ +
+

Introduction

+ +

Linked Data [[LINKED-DATA]] is a way to create a network of + standards-based machine interpretable data across different documents and + Web sites. It allows an application to start at one piece of Linked Data, + and follow embedded links to other pieces of Linked Data that are hosted on + different sites across the Web.

+ +

JSON-LD is a lightweight syntax to serialize Linked Data in + JSON [[!RFC7159]]. Its design allows existing JSON to be interpreted as + Linked Data with minimal changes. JSON-LD is primarily intended to be a + way to use Linked Data in Web-based programming environments, to build + interoperable Web services, and to store Linked Data in JSON-based storage engines. Since + JSON-LD is 100% compatible with JSON, the large number of JSON parsers and libraries + available today can be reused. In addition to all the features JSON provides, + JSON-LD introduces:

+ + + +

+ JSON-LD is designed to be usable directly as JSON, with no knowledge of RDF + [[RDF11-CONCEPTS]]. It is also designed to be usable as RDF, if desired, for + use with other Linked Data technologies like SPARQL. Developers who + require any of the facilities listed above or need to serialize an RDF Graph + or RDF Dataset in a JSON-based syntax will find JSON-LD of interest. People + intending to use JSON-LD with RDF tools will find it can be used as another + RDF syntax, like Turtle [[TURTLE]]. Complete details of how JSON-LD relates + to RDF are in section . +

+ +

+ The syntax is designed to not disturb already + deployed systems running on JSON, but provide a smooth upgrade path from + JSON to JSON-LD. Since the shape of such data varies wildly, JSON-LD + features mechanisms to reshape documents into a deterministic structure + which simplifies their processing.

+ +
+

How to Read this Document

+ +

This document is a detailed specification for a serialization of Linked + Data in JSON. The document is primarily intended for the following audiences:

+ +
    +
  • Software developers who want to encode Linked Data in a variety of + programming languages that can use JSON
    • +
  • Software developers who want to convert existing JSON to JSON-LD
    • +
  • Software developers who want to understand the design decisions and + language syntax for JSON-LD
    • +
  • Software developers who want to implement processors and APIs for + JSON-LD
    • +
  • Software developers who want to generate or consume Linked Data, + an RDF graph, or an RDF Dataset in a JSON syntax
    • +
+ +

A companion document, the JSON-LD 1.1 Processing Algorithms and API specification + [[JSON-LD11CG-API]], specifies how to work with JSON-LD at a higher level by + providing a standard library interface for common JSON-LD operations.

+ +

To understand the basics in this specification you must first be familiar with + JSON, which is detailed in [[!RFC7159]].

+ +

This document almost exclusively uses the term IRI + (Internationalized Resource Indicator) + when discussing hyperlinks. Many Web developers are more familiar with the + URL (Uniform Resource Locator) + terminology. The document also uses, albeit rarely, the URI + (Uniform Resource Indicator) + terminology. While these terms are often used interchangeably among + technical communities, they do have important distinctions from one + another and the specification goes to great lengths to try and use the + proper terminology at all times. +

+
+ +
+

Contributing

+ +

There are a number of ways that one may participate in the development of + this specification:

+ +
    +
  • Technical discussion typically occurs on the public mailing list: + public-linked-json@w3.org
    • + + + +
  • The #json-ld + IRC channel is available for real-time discussion on irc.freenode.net.
    • +
+ +
+ +
+

Terminology

+ +

This document uses the following terms as defined in JSON [[!RFC7159]]. Refer + to the JSON Grammar section in [[!RFC7159]] for formal definitions.

+ +
+
+
+ +
+

Typographical conventions

+
+
+ +
+

Design Goals and Rationale

+ +

JSON-LD satisfies the following design goals:

+ +
+
Simplicity
+
No extra processors or software libraries are necessary to use JSON-LD + in its most basic form. The language provides developers with a very easy + learning curve. Developers only need to know JSON and two + keywords (@context + and @id) to use the basic functionality in JSON-LD.
+
Compatibility
+
A JSON-LD document is always a valid JSON document. This ensures that + all of the standard JSON libraries work seamlessly with JSON-LD documents.
+
Expressiveness
+
The syntax serializes directed graphs. This ensures that almost + every real world data model can be expressed.
+
Terseness
+
The JSON-LD syntax is very terse and human readable, requiring as + little effort as possible from the developer.
+
Zero Edits, most of the time
+
JSON-LD ensures a smooth and simple transition from existing + JSON-based systems. In many cases, + zero edits to the JSON document and the addition of one line to the HTTP response + should suffice (see ). + This allows organizations that have + already deployed large JSON-based infrastructure to use JSON-LD's features + in a way that is not disruptive to their day-to-day operations and is + transparent to their current customers. However, there are times where + mapping JSON to a graph representation is a complex undertaking. + In these instances, rather than extending JSON-LD to support + esoteric use cases, we chose not to support the use case. While Zero + Edits is a design goal, it is not always possible without adding + great complexity to the language. JSON-LD focuses on simplicity when + possible.
+
Usable as RDF
+
JSON-LD is usable by developers as + idiomatic JSON, with no need to understand RDF [[RDF11-CONCEPTS]]. + JSON-LD is also usable as RDF, so people intending to use JSON-LD + with RDF tools will find it can be used like any other RDF syntax. + Complete details of how JSON-LD relates to RDF are in section + .
+
+
+ +
+

Data Model Overview

+ +

Generally speaking, the data model described by a + JSON-LD document is a labeled, + directed graph. The graph contains + nodes, which are connected by + edges. A node is typically data + such as a string, number, + typed values (like dates and times) + or an IRI. + There is also a special class of node called a + blank node, which is typically used to express data that does + not have a global identifier like an IRI. + Blank nodes are identified using a + blank node identifier. This simple data model is incredibly + flexible and powerful, capable of modeling almost any kind of + data. For a deeper explanation of the data model, see + section . +

+ +

Developers who are familiar with Linked Data technologies will + recognize the data model as the RDF Data Model. To dive deeper into how + JSON-LD and RDF are related, see + section .

+ +

At the surface level, a JSON-LD document is simply + JSON, detailed in [[!RFC7159]]. + For the purpose of describing the core data structures, + this is limited to arrays, dictionaries (the parsed version of a JSON Object), + strings, numbers, booleans, and null, + called the JSON-LD internal representation. + This allows surface syntaxes other than JSON + to be manipulated using the same algorithms, when the syntax maps + to equivalent core data structures.

+

Although not discussed in this specification, + parallel work using YAML [[YAML]] + and binary representations such as CBOR [[RFC7049]] + could be used to map into the internal representation, allowing + the JSON-LD 1.1 API [[JSON-LD11CG-API]] to operate as if the source was a + JSON document.

+
+ +
+

Syntax Tokens and Keywords

+ +

JSON-LD specifies a number of syntax tokens and keywords + that are a core part of the language:

+ +
+
@context
+
Used to define the short-hand names that are used throughout a JSON-LD + document. These short-hand names are called terms and help + developers to express specific identifiers in a compact manner. The + @context keyword is described in detail in + .
+
@id
+
Used to uniquely identify things that are being described in the document + with IRIs or + blank node identifiers. This keyword + is described in .
+
@value
+
Used to specify the data that is associated with a particular + property in the graph. This keyword is described in + and + .
+
@language
+
Used to specify the language for a particular string value or the default + language of a JSON-LD document. This keyword is described in + .
+
@type
+
Used to set the data type of a node or + typed value. This keyword is described in + .
+
@container
+
Used to set the default container type for a term. + This keyword is described in the following sections: +
    +
  • ,
    • +
  • ,
    • +
  • ,
    • +
  • ,
    • +
  • ,
    • +
  • ,
    • +
  • , and
    • +
  • .
    • +
+
@list
+
Used to express an ordered set of data. + This keyword is described in .
+
@set
+
Used to express an unordered set of data and to ensure that values are always + represented as arrays. This keyword is described in + .
+
@reverse
+
Used to express reverse properties. This keyword is described in + .
+
@index
+
Used to specify that a container is used to index information and + that processing should continue deeper into a JSON data structure. + This keyword is described in .
+
@base
+
Used to set the base IRI against which to resolve those relative IRIs + interpreted relative to the document. + This keyword is described in .
+
@vocab
+
Used to expand properties and values in @type with a common prefix + IRI. This keyword is described in .
+
@graph
Used to express a graph. + This keyword is described in .
+
@nest
Collects a set of nested properties within + a node object.
+
@none
Used as an index value + in an id map, language map, type map or elsewhere where a dictionary is + used to index into other values.
+
@prefix
+ With the value true, allows this term to be used to construct a compact IRI + when compacting.
+
@version
+ Used in a context definition to set the processing mode. + New features since JSON-LD 1.0 [[!JSON-LD]] described in this specification are + only available when processing mode has been explicitly set to + json-ld-1.1. +
+
:
+
The separator for JSON keys and values that use + compact IRIs.
+
+ +

All keys, keywords, and values in JSON-LD are case-sensitive.

+
+
+ +
+

Conformance criteria are relevant to authors and authoring tool implementers. As well + as sections marked as non-normative, all authoring guidelines, diagrams, examples, + and notes in this specification are non-normative. Everything else in this + specification is normative.

+ +

A JSON-LD document complies with this specification if it follows + the normative statements in appendix . JSON documents + can be interpreted as JSON-LD by following the normative statements in + . For convenience, normative + statements for documents are often phrased as statements on the properties of the document.

+ +

This specification makes use of the following namespaces:

+
+
dc:
+
http://purl.org/dc/terms/
+
cred:
+
https://w3id.org/credentials#
+
foaf:
+
http://xmlns.com/foaf/0.1/
+
prov
+
http://www.w3.org/ns/prov#
+
rdf:
+
http://www.w3.org/1999/02/22-rdf-syntax-ns#
+
schema:
+
http://schema.org/
+
xsd:
+
http://www.w3.org/2001/XMLSchema#
+
+
+ +
+

Basic Concepts

+ +

JSON [[RFC7159]] is a lightweight, language-independent data interchange format. + It is easy to parse and easy to generate. However, it is difficult to integrate JSON + from different sources as the data may contain keys that conflict with other + data sources. Furthermore, JSON has no + built-in support for hyperlinks, which are a fundamental building block on + the Web. Let's start by looking at an example that we will be using for the + rest of this section:

+ + 
+  
+
+ +

It's obvious to humans that the data is about a person whose + name is "Manu Sporny" + and that the homepage property contains the URL of that person's homepage. + A machine doesn't have such an intuitive understanding and sometimes, + even for humans, it is difficult to resolve ambiguities in such representations. This problem + can be solved by using unambiguous identifiers to denote the different concepts instead of + tokens such as "name", "homepage", etc.

+ +

Linked Data, and the Web in general, uses IRIs + (Internationalized Resource Identifiers as described in [[!RFC3987]]) for unambiguous + identification. The idea is to use IRIs + to assign unambiguous identifiers to data that may be of use to other developers. + It is useful for terms, + like name and homepage, to expand to IRIs + so that developers don't accidentally step on each other's terms. Furthermore, developers and + machines are able to use this IRI (by using a web browser, for instance) to go to + the term and get a definition of what the term means. This process is known as IRI + dereferencing.

+ +

Leveraging the popular schema.org vocabulary, + the example above could be unambiguously expressed as follows:

+ + 
+  
+
+ +

In the example above, every property is unambiguously identified by an IRI and all values + representing IRIs are explicitly marked as such by the + @id keyword. While this is a valid JSON-LD + document that is very specific about its data, the document is also overly verbose and difficult + to work with for human developers. To address this issue, JSON-LD introduces the notion + of a context as described in the next section.

+ +
+

The Context

+ +

When two people communicate with one another, the conversation takes + place in a shared environment, typically called + "the context of the conversation". This shared context allows the + individuals to use shortcut terms, like the first name of a mutual friend, + to communicate more quickly but without losing accuracy. A context in + JSON-LD works in the same way. It allows two applications to use shortcut + terms to communicate with one another more efficiently, but without + losing accuracy.

+ +

Simply speaking, a context is used to map terms to + IRIs. Terms are case sensitive + and any valid string that is not a reserved JSON-LD keyword + can be used as a term.

+ +

For the sample document in the previous section, a context would + look something like this:

+ + 
+    
+
+ +

As the context above shows, the value of a term definition can + either be a simple string, mapping the term to an IRI, + or a JSON object.

+ +

When a JSON object is associated with a term, it is called + an expanded term definition. The example above specifies that + the values of image and homepage, if they are + strings, are to be interpreted as + IRIs. Expanded term definitions + also allow terms to be used for index maps + and to specify whether array values are to be + interpreted as sets or lists. + Expanded term definitions may + be defined using absolute or + compact IRIs as keys, which is + mainly used to associate type or language information with an + absolute or compact IRI.

+ +

Contexts can either be directly embedded + into the document or be referenced. Assuming the context document in the previous + example can be retrieved at https://json-ld.org/contexts/person.jsonld, + it can be referenced by adding a single line and allows a JSON-LD document to + be expressed much more concisely as shown in the example below:

+ + 
+    
+
+ +

The referenced context not only specifies how the terms map to + IRIs in the Schema.org vocabulary but also + specifies that string values associated with + the homepage and image property + can be interpreted as an IRI ("@type": "@id", + see for more details). This information allows developers + to re-use each other's data without having to agree to how their data will interoperate + on a site-by-site basis. External JSON-LD context documents may contain extra + information located outside of the @context key, such as + documentation about the terms declared in the + document. Information contained outside of the @context value + is ignored when the document is used as an external JSON-LD context document.

+ +

JSON documents can be interpreted as JSON-LD without having to be modified by + referencing a context via an HTTP Link Header + as described in . It is also + possible to apply a custom context using the JSON-LD 1.1 API [[JSON-LD11CG-API]].

+ +

In JSON-LD documents, + contexts may also be specified inline. + This has the advantage that documents can be processed even in the + absence of a connection to the Web. Ultimately, this is a modeling decision + and different use cases may require different handling.

+ + 
+    
+
+ +

This section only covers the most basic features of the JSON-LD + Context. More advanced features related to the JSON-LD Context are covered + in section . +

+
+ +
+

IRIs

+ +

IRIs (Internationalized Resource Identifiers + [[!RFC3987]]) are fundamental to Linked Data as that is how most + nodes and properties + are identified. In JSON-LD, IRIs may be represented as an + absolute IRI or a relative IRI. An + absolute IRI is defined in [[!RFC3987]] as containing a + scheme along with path and optional query and + fragment segments. A relative IRI is an IRI + that is relative to some other absolute IRI. + In JSON-LD, with exceptions are as described below, all relative IRIs + are resolved relative to the base IRI.

+ +

Properties, values of @type, + and values of properties with a term definition + that defines them as being relative to the vocabulary mapping, + may have the form of a relative IRI, but are resolved using the + vocabulary mapping, and not the base IRI.

+ +

A string is interpreted as an IRI when it is the + value of an @id member:

+ + 
+  
+
+ +

Values that are interpreted as IRIs, can also be + expressed as relative IRIs. For example, + assuming that the following document is located at + http://example.com/about/, the relative IRI + ../ would expand to http://example.com/ (for more + information on where relative IRIs can be + used, please refer to section ).

+ + 
+  
+
+ +

Absolute IRIs can be expressed directly + in the key position like so:

+ + 
+  
+
+ +

In the example above, the key http://schema.org/name + is interpreted as an absolute IRI.

+ +

Term-to-IRI expansion occurs if the key matches a term defined + within the active context:

+ + 
+  
+
+ +

JSON keys that do not expand to an IRI, such as status + in the example above, are not Linked Data and thus ignored when processed.

+ +

If type coercion rules are specified in the @context for + a particular term or property IRI, an IRI is generated:

+ + 
+  
+
+ +

In the example above, since the value http://manu.sporny.org/ + is expressed as a JSON string, the type coercion + rules will transform the value into an IRI when processing the data. + See for more + details about this feature.

+ +

In summary, IRIs can be expressed in a variety of + different ways in JSON-LD:

+ +
    +
  1. JSON object keys that have a term mapping in + the active context expand to an IRI + (only applies outside of the context definition).
    2. +
  2. An IRI is generated for the string value specified using + @id or @type.
    3. +
  3. An IRI is generated for the string value of any key for which there + are coercion rules that contain an @type key that is + set to a value of @id or @vocab.
    4. +
+ +

This section only covers the most basic features associated with IRIs + in JSON-LD. More advanced features related to IRIs are covered in + section . +

+ +
+ +
+

Node Identifiers

+ +

To be able to externally reference nodes + in a graph, it is important that + nodes have an identifier. IRIs + are a fundamental concept of Linked Data, for + nodes to be truly linked, dereferencing the + identifier should result in a representation of that node. + This may allow an application to retrieve further information about a + node.

+ +

In JSON-LD, a node is identified using the @id + keyword:

+ + 
+  
+
+ +

The example above contains a node object identified by the IRI + http://me.markus-lanthaler.com/.

+ +

This section only covers the most basic features associated with + node identifiers in JSON-LD. More advanced features related to + node identifiers are covered in section . +

+ +
+ +
+

Specifying the Type

+ +

The type of a particular node can be specified using the @type + keyword. In Linked Data, types are uniquely + identified with an IRI.

+ +
+
+
+ +

A node can be assigned more than one type by using an array:

+ +
+
+
+ +

The value of an @type key may also be a term defined in the active context:

+
+
+
+ +

This section only covers the most basic features associated with + types in JSON-LD. It is worth noting that the @type + keyword is not only used to specify the type of a + node but also to express typed values + (as described in ) and to + type coerce values (as described in + ). Specifically, @type + cannot be used in a context to define a node's + type. For a detailed description of the differences, please refer to + .

+ +
+
+ +
+

Advanced Concepts

+ +

JSON-LD has a number of features that provide functionality above and beyond + the core functionality described above. The following section describes this + advanced functionality in more detail.

+ +
+

JSON-LD 1.1 Processing Mode

+ +

New features defined in JSON-LD 1.1 are available + when the processing mode is set to json-ld-1.1. + This may be set using the @version member in a context + set to the value 1.1 as a number, or through an API option.

+ + 
+  
+
+ +

The first context encountered when processing a + document which contains @version determines the processing mode, + unless it is defined explicitly through an API option.

+ +

Setting the processing mode explicitly + for JSON-LD 1.1 is necessary so that a JSON-LD 1.0 processor + does not attempt to process a JSON-LD 1.1 document and silently + produce different results.

+
+ +
+

Base IRI

+ +

JSON-LD allows IRIs + to be specified in a relative form which is + resolved against the document base according + section 5.1 Establishing a Base URI + of [[RFC3986]]. The base IRI may be explicitly set with a context + using the @base keyword.

+ +

For example, if a JSON-LD document was retrieved from http://example.com/document.jsonld, + relative IRIs would resolve against that IRI:

+ + 
+    
+
+ +

This document uses an empty @id, which resolves to the document base. + However, if the document is moved to a different location, the IRI would change. + To prevent this without having to use an absolute IRI, a context + may define an @base mapping, to overwrite the base IRI for the document.

+ + 
+  
+
+ +

Setting @base to null will prevent + relative IRIs to be expanded to + absolute IRIs.

+ +

Please note that the @base will be ignored if used in + external contexts.

+
+ +
+

Default Vocabulary

+ +

At times, all properties and types may come from the same vocabulary. JSON-LD's + @vocab keyword allows an author to set a common prefix which + is used as the vocabulary mapping and is used + for all properties and types that do not match a term and are neither + a compact IRI nor an absolute IRI (i.e., they do + not contain a colon).

+ + 
+  
+
+ +

If @vocab is used but certain keys in an + object should not be expanded using + the vocabulary IRI, a term can be explicitly set + to null in the context. For instance, in the + example below the databaseId member would not expand to an + IRI causing the property to be dropped when expanding.

+ + 
+  
+
+ +
+

Using the Document Base as the Default Vocabulary

+

In some cases, vocabulary terms are defined directly within the document + itself, rather than in an external vocabulary. Since + json-ld-1.1, the vocabulary mapping in the active + context can be set to the empty string "", which causes terms which + are expanded relative to the vocabulary, such as the keys of node + objects, to use the base IRI to create absolute + IRIs.

+ 
+  
+
+

If this document were located at http://example/document, it would expand as follows:

+ 
+  
+
+
+
+ +
+

Compact IRIs

+ +

A compact IRI is a way of expressing an IRI + using a prefix and suffix separated by a colon (:). + The prefix is a term taken from the + active context and is a short string identifying a + particular IRI in a JSON-LD document. For example, the + prefix foaf may be used as a short hand for the + Friend-of-a-Friend vocabulary, which is identified using the IRI + http://xmlns.com/foaf/0.1/. A developer may append + any of the FOAF vocabulary terms to the end of the prefix to specify a short-hand + version of the absolute IRI for the vocabulary term. For example, + foaf:name would be expanded to the IRI + http://xmlns.com/foaf/0.1/name.

+ + 
+  
+
+ +

In the example above, foaf:name expands to the IRI + http://xmlns.com/foaf/0.1/name and foaf:Person expands + to http://xmlns.com/foaf/0.1/Person.

+ +

Prefixes are expanded when the form of the value + is a compact IRI represented as a prefix:suffix + combination, the prefix matches a term defined within the + active context, and the suffix does not begin with two + slashes (//). The compact IRI is expanded by + concatenating the IRI mapped to the prefix to the (possibly empty) + suffix. If the prefix is not defined in the active context, + or the suffix begins with two slashes (such as in http://example.com), + the value is interpreted as absolute IRI instead. If the prefix is an + underscore (_), the value is interpreted as blank node identifier + instead.

+ +

It's also possible to use compact IRIs within the context as shown in the + following example:

+ + 
+  
+
+ +

In JSON-LD 1.0, terms may be chosen as compact IRI prefixes when + compacting only if a simple term definition is used where the value ends with a + URI gen-delim character (e.g, /, + # and others, see [[!RFC3986]]). + The previous specification allows any term to be chosen as + a compact IRI prefix, which led to a poor experience.

+ +

In JSON-LD 1.1, terms may be chosen as compact IRI prefixes + when compacting only if + a simple term definition is used where the value ends with a URI gen-delim character, + or if their expanded term definition contains + a @prefix member with the value true.

+ +

This represents a small change to the 1.0 algorithm to prevent IRIs + that are not really intended to be used as prefixes from being used for creating + compact IRIs.

+ +

When processing mode is set to json-ld-1.1, terms will be used as compact IRI prefixes + when compacting only if their expanded term definition contains + a @prefix member with the value true, or if it has a + a simple term definition where the value ends with a URI gen-delim character + (e.g, /, # and others, see [[!RFC3986]]).

+ + 
+  
+
+ +

In this case, the compact-iris term would not normally be usable as a prefix, both + because it is defined with an expanded term definition, and because + it's @id does not end in a + gen-delim character. Adding + "@prefix": true allows it to be used as the prefix portion of + the compact IRI compact-iris:are-considered.

+
+ +
+

Typed Values

+ +

+ A value with an associated type, also known as a + typed value, is indicated by associating a value with + an IRI which indicates the value's type. Typed values may be + expressed in JSON-LD in three ways: +

+ +
    +
  1. By utilizing the @type keyword when defining + a term within an @context section.
    2. +
  2. By utilizing a value object.
    3. +
  3. By using a native JSON type such as number, true, or false.
    4. +
+ +

The first example uses the @type keyword to associate a +type with a particular term in the @context:

+ +
+
+
+ +

The modified key's value above is automatically type coerced to a + dateTime value because of the information specified in the + @context. A JSON-LD processor will interpret the example above + as follows:

+ + + + + + + + + + + + + + + + +
SubjectPropertyValueValue Type
http://example.com/docs/1http://purl.org/dc/terms/modified2010-05-29T14:17:39+02:00xsd:dateTime
+ +

The second example uses the expanded form of setting the type information +in the body of a JSON-LD document:

+ +
+
+
+ +

Both examples above would generate the value + 2010-05-29T14:17:39+02:00 with the type + http://www.w3.org/2001/XMLSchema#dateTime. Note that it is + also possible to use a term or a compact IRI to + express the value of a type.

+ +

The @type keyword is also used to associate a type + with a node. The concept of a node type and + a value type are different.

+ +

A node type specifies the type of thing + that is being described, like a person, place, event, or web page. A + value type specifies the data type of a particular value, such + as an integer, a floating point number, or a date.

+ +
+
+
+ +

The first use of @type associates a node type + (http://schema.org/BlogPosting) with the node, + which is expressed using the @id keyword. + The second use of @type associates a value type + (http://www.w3.org/2001/XMLSchema#dateTime) with the + value expressed using the @value keyword. As a + general rule, when @value and @type are used in + the same JSON object, the @type + keyword is expressing a value type. + Otherwise, the @type keyword is expressing a + node type. The example above expresses the following data:

+ + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValueValue Type
http://example.org/posts#TripToWestVirginiardf:typeschema:BlogPosting-
http://example.org/posts#TripToWestVirginiadc:modified2010-05-29T14:17:39+02:00xsd:dateTime
+ +
+ +
+

Type Coercion

+ +

JSON-LD supports the coercion of values to particular data types. +Type coercion allows someone deploying JSON-LD to coerce the incoming or +outgoing values to the proper data type based on a mapping of data type IRIs to +terms. Using type coercion, value representation is preserved without requiring +the data type to be specified with each piece of data.

+ +

Type coercion is specified within an expanded term definition + using the @type key. The value of this key expands to an IRI. + Alternatively, the keyword @id or @vocab may be used + as value to indicate that within the body of a JSON-LD document, a string value of a + term coerced to @id or @vocab is to be interpreted as an + IRI. The difference between @id and @vocab is how values are expanded + to absolute IRIs. @vocab first tries to expand the value + by interpreting it as term. If no matching term is found in the + active context, it tries to expand it as compact IRI or absolute IRI + if there's a colon in the value; otherwise, it will expand the value using the + active context's vocabulary mapping, if present. + Values coerced to @id in contrast are expanded as + compact IRI or absolute IRI if a colon is present; otherwise, they are interpreted + as relative IRI.

+ +

Terms or compact IRIs used as the value of a + @type key may be defined within the same context. This means that one may specify a + term like xsd and then use xsd:integer within the same + context definition.

+ +

The example below demonstrates how a JSON-LD author can coerce values to +typed values and IRIs.

+ +
+
+
+ +

The example shown above would generate the following data.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValueValue Type
http://example.com/people#johnfoaf:nameJohn Smith 
http://example.com/people#johnfoaf:age41xsd:integer
http://example.com/people#johnfoaf:homepagehttp://personal.example.org/IRI
http://work.example.com/jsmith/IRI
+ +

Terms may also be defined using absolute IRIs + or compact IRIs. This allows coercion rules + to be applied to keys which are not represented as a simple term. + For example:

+ +
+
+
+ +

In this case the @id definition in the term definition is optional. + If it does exist, the compact IRI or IRI representing + the term will always be expanded to IRI defined by the @id + key—regardless of whether a prefix is defined or not.

+ +

Type coercion is always performed using the unexpanded value of the key. In the + example above, that means that type coercion is done looking for foaf:age + in the active context and not for the corresponding, expanded + IRI http://xmlns.com/foaf/0.1/age.

+ +

Keys in the context are treated as terms for the purpose of + expansion and value coercion. At times, this may result in multiple representations for the same expanded IRI. + For example, one could specify that dog and cat both expanded to http://example.com/vocab#animal. + Doing this could be useful for establishing different type coercion or language specification rules. It also allows a compact IRI (or even an + absolute IRI) to be defined as something else entirely. For example, one could specify that + the term http://example.org/zoo should expand to + http://example.org/river, but this usage is discouraged because it would lead to a + great deal of confusion among developers attempting to understand the JSON-LD document.

+ + +
+ +
+

Embedding

+ +

Embedding is a JSON-LD feature that allows an author to + use node objects as + property values. This is a commonly used mechanism for + creating a parent-child relationship between two nodes.

+ +

Without embedding, node objects can be linked by referencing the + identifier of another node object. For example:

+ + 
+  
+
+ +

The previous example describes two node objects, for Manu and Gregg, with + the knows property defined to treat string values as identifiers. + Embedding allows the node object for Gregg to be embedded as a value + of the knows property:

+ + 
+  
+
+ +

A node object, like the one used above, may be used in + any value position in the body of a JSON-LD document. Note that type coercion of the knows property + is not required, as the value is not a string.

+
+ +
+

Advanced Context Usage

+ +

Section introduced the basics of what makes + JSON-LD work. This section expands on the basic principles of the + context and demonstrates how more advanced use cases can + be achieved using JSON-LD.

+ +

In general, contexts may be used at any time a + JSON object is defined. + The only time that one cannot express a context is as a direct child of another context definition. + For example, a JSON-LD document may use more than one context at different + points in a document:

+ + 
+  
+
+ +

Duplicate context terms are overridden using a + most-recently-defined-wins mechanism.

+ + 
+  
+
+ +

In the example above, the name term is overridden + in the more deeply nested details structure. Note that this is + rarely a good authoring practice and is typically used when working with + legacy applications that depend on a specific structure of the + JSON object. If a term is redefined within a + context, all previous rules associated with the previous definition are + removed. If a term is redefined to null, + the term is effectively removed from the list of + terms defined in the active context.

+ +

Multiple contexts may be combined using an array, which is processed + in order. The set of contexts defined within a specific JSON object are + referred to as local contexts. The + active context refers to the accumulation of + local contexts that are in scope at a + specific point within the document. Setting a local context + to null effectively resets the active context + to an empty context. The following example specifies an external context + and then layers an embedded context on top of the external context:

+ + 
+  
+
+ +

When possible, the context definition should be put + at the top of a JSON-LD document. This makes the document easier to read and + might make streaming parsers more efficient. Documents that do not have the + context at the top are still conformant JSON-LD.

+ +

To avoid forward-compatibility issues, terms + starting with an @ character are to be avoided as they + might be used as keyword in future versions + of JSON-LD. Terms starting with an @ character that are not + JSON-LD 1.1 keywords are treated as any other term, i.e., + they are ignored unless mapped to an IRI. Furthermore, the use of + empty terms ("") is not allowed as + not all programming languages are able to handle empty JSON keys.

+
+ +
+

Interpreting JSON as JSON-LD

+ +

Ordinary JSON documents can be interpreted as JSON-LD + by providing an explicit JSON-LD context document. One way + to provide this is by using referencing a JSON-LD + context document in an HTTP Link Header. + Doing so allows JSON to be unambiguously machine-readable without requiring developers to drastically + change their documents and provides an upgrade path for existing infrastructure + without breaking existing clients that rely on the application/json + media type or a media type with a +json suffix as defined in + [[RFC6839]].

+ +

In order to use an external context with an ordinary JSON document, + when retrieving an ordinary JSON document via HTTP, processors MUST + retrieve any JSON-LD document referenced by a + Link Header with:

+ +
    +
  • rel="http://www.w3.org/ns/json-ld#context", and
    • +
  • type="application/ld+json".
    • +
+ +

The referenced document MUST have a top-level JSON object. + The @context subtree within that object is added to the top-level + JSON object of the referencing document. If an array + is at the top-level of the referencing document and its items are + JSON objects, the @context + subtree is added to all array items. All extra information located outside + of the @context subtree in the referenced document MUST be + discarded. Effectively this means that the active context is + initialized with the referenced external context. A response MUST NOT + contain more than one HTTP Link Header [[!RFC5988]] using the + http://www.w3.org/ns/json-ld#context link relation.

+ +

Other mechanisms for providing a JSON-LD Context MAY be described for other + URI schemes.

+ +

The JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]] + provides for an expandContext option for specifying + a context to use when expanding JSON documents programatically.

+ +

The following example demonstrates the use of an external context with an + ordinary JSON document over HTTP:

+ + 
+  
+
+ +

Please note that JSON-LD documents + served with the application/ld+json + media type MUST have all context information, including references to external + contexts, within the body of the document. Contexts linked via a + http://www.w3.org/ns/json-ld#context HTTP Link Header MUST be + ignored for such documents.

+
+ +
+

String Internationalization

+ +

At times, it is important to annotate a string + with its language. In JSON-LD this is possible in a variety of ways. + First, it is possible to define a default language for a JSON-LD document + by setting the @language key in the context:

+ + 
+  
+
+ +

The example above would associate the ja language + code with the two strings 花澄 and 科学者. + Languages codes are defined in [[!BCP47]]. The default language applies to all + string values that are not type coerced.

+ +

To clear the default language for a subtree, @language can + be set to null in a local context as follows:

+ + 
+  
+
+ +

Second, it is possible to associate a language with a specific term + using an expanded term definition:

+ + 
+  
+
+ +

The example above would associate 忍者 with the specified default + language code ja, Ninja with the language code + en, and Nindža with the language code cs. + The value of name, Yagyū Muneyoshi wouldn't be + associated with any language code since @language was reset to + null in the expanded term definition.

+ +

Language associations are only applied to plain + strings. Typed values + or values that are subject to type coercion + are not language tagged.

+ +

Just as in the example above, systems often need to express the value of a + property in multiple languages. Typically, such systems also try to ensure that + developers have a programmatically easy way to navigate the data structures for + the language-specific data. In this case, language maps + may be utilized.

+ + 
+  
+
+ +

The example above expresses exactly the same information as the previous + example but consolidates all values in a single property. To access the + value in a specific language in a programming language supporting dot-notation + accessors for object properties, a developer may use the + property.language pattern. For example, to access the occupation + in English, a developer would use the following code snippet: + obj.occupation.en.

+ +

Third, it is possible to override the default language by using a + value object:

+ + 
+  
+
+ +

This makes it possible to specify a plain string by omitting the + @language tag or setting it to null when expressing + it using a value object:

+ + 
+  
+
+ +
+ +
+

IRI Expansion within a Context

+

In general, normal IRI expansion rules apply + anywhere an IRI is expected (see ). Within + a context definition, this can mean that terms defined + within the context may also be used within that context as long as + there are no circular dependencies. For example, it is common to use + the xsd namespace when defining typed values:

+ +
+
+
+ +

In this example, the xsd term is defined + and used as a prefix for the @type coercion + of the age property.

+ +

Terms may also be used when defining the IRI of another +term:

+ +
+
+
+ +

Compact IRIs + and IRIs may be used on the left-hand side of a + term definition.

+ +
+
+
+ +

+In this example, the compact IRI form is used in two different +ways. +In the first approach, foaf:age declares both the +IRI for the term (using short-form) as well as the +@type associated with the term. In the second +approach, only the @type associated with the term is +specified. The full IRI for +foaf:homepage is determined by looking up the foaf +prefix in the +context. +

+ +

+Absolute IRIs may also be used in the key position in a context: +

+ +
+
+
+ +

In order for the absolute IRI to match above, the absolute IRI + needs to be used in the JSON-LD document. Also note that foaf:homepage + will not use the { "@type": "@id" } declaration because + foaf:homepage is not the same as http://xmlns.com/foaf/0.1/homepage. + That is, terms are looked up in a context using + direct string comparison before the prefix lookup mechanism is applied.

+ +

While it is possible to define a compact IRI, or + an absolute IRI to expand to some other unrelated IRI + (for example, foaf:name expanding to + http://example.org/unrelated#species), such usage is strongly + discouraged.

+ +

The only exception for using terms in the context is that + circular definitions are not allowed. That is, + a definition of term1 cannot depend on the + definition of term2 if term2 also depends on + term1. For example, the following context definition + is illegal:

+
+
+
+
+ +
+

Sets and Lists

+ +

A JSON-LD author can express multiple values in a compact way by using + arrays. Since graphs do not describe ordering for links + between nodes, arrays in JSON-LD do not provide an ordering of the + contained elements by default. This is exactly the opposite from regular JSON + arrays, which are ordered by default. For example, consider the following + simple document:

+ +
+
+
+ +

The example shown above would result in the following data being generated, + each relating the node to an individual value, with no inherent order:

+ + + + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValue
http://example.org/people#joebobfoaf:nickjoe
http://example.org/people#joebobfoaf:nickbob
http://example.org/people#joebobfoaf:nickJB
+ +

Multiple values may also be expressed using the expanded form:

+ +
+
+
+ +

The example shown above would generate the following data, again with + no inherent order:

+ + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValueLanguage
http://example.org/articles/8dc:titleDas Kapitalde
http://example.org/articles/8dc:titleCapitalen
+ +

Although multiple values of a property are typically of the same type, + JSON-LD places no restriction on this, and a property may have values + of different types:

+ +
+
+
+ +

The example shown above would generate the following data, also with + no inherent order:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValueLanguageValue Type
http://example.org/people#michaeldc:nameMichael
http://example.org/people#michaeldc:nameMike
http://example.org/people#michaeldc:nameMigueles
http://example.org/people#michaeldc:namehttps://www.wikidata.org/wiki/Q4927524
http://example.org/people#michaeldc:name42xsd:integer
+ +

As the notion of ordered collections is rather important in data + modeling, it is useful to have specific language support. In JSON-LD, + a list may be represented using the @list keyword as follows:

+
+
+
+ +

This describes the use of this array as being ordered, + and order is maintained when processing a document. If every use of a given multi-valued + property is a list, this may be abbreviated by setting @container + to @list in the context:

+
+
+
+ +

List of lists in the form of list objects + are not allowed in this version of JSON-LD. This decision was made due to the + extreme amount of added complexity when processing lists of lists.

+ +

While @list is used to describe ordered lists, + the @set keyword is used to describe unordered sets. + The use of @set in the body of a JSON-LD document + is optimized away when processing the document, as it is just syntactic + sugar. However, @set is helpful when used within the context + of a document. + Values of terms associated with an @set or @list container + are always represented in the form of an array, + even if there is just a single value that would otherwise be optimized to + a non-array form in compact form (see + ). This makes post-processing of + JSON-LD documents easier as the data is always in array form, even if the + array only contains a single value.

+ +
+ +
+

Reverse Properties

+ +

JSON-LD serializes directed graphs. That means that + every property points from a node to another node + or value. However, in some cases, it is desirable + to serialize in the reverse direction. Consider for example the case where a person + and its children should be described in a document. If the used vocabulary does not + provide a children property but just a parent + property, every node representing a child would have to + be expressed with a property pointing to the parent as in the following + example.

+ + 
+  
+
+ +

Expressing such data is much simpler by using JSON-LD's @reverse + keyword:

+ + 
+  
+
+ +

The @reverse keyword can also be used in + expanded term definitions + to create reverse properties as shown in the following example:

+ + + 
+  
+
+
+ +
+

Scoped Contexts

+ +

An expanded term definition can include a @context + property, which defines a context (an embedded context) for values of properties defined using that term. This allows + values to use term definitions, base IRI, + vocabulary mapping or default language which is different from the + node object they are contained in, as if the + context was specified within the value itself.

+ + 
+  
+
+ +

In this case, the social profile is defined using the schema.org vocabulary, but interest is imported from FOAF, and is used to define a node describing one of Manu's interests where those properties now come from the FOAF vocabulary.

+ +

Expanding this document, uses a combination of terms defined in the outer context, and those defined specifically for that term in an embedded context.

+ + 
+  
+
+ +

Scoping can also be performed using a term used as a value of @type:

+ + 
+  
+
+ +

Scoping on @type is useful when common properties are used to + relate things of different types, where the vocabularies in use within + different entities calls for different context scoping. For example, + hasPart/partOf may be common terms used in a document, but mean + different things depending on the context.

+ +

When expanding, each value of @type is considered + (ordering them lexographically) where that value is also a term in + the active context having its own embedded context. If so, that + embedded context is applied to the active context. When compacting, if + a term is chosen to represent an IRI used as a value of @type where that + term definition also has an embedded context, it is then applied to the + active context to affect further compaction.

+ +

The values of @type are unordered, so if multiple + types are listed, the order that scoped contexts are applied is based on + lexicographical ordering.

+ +

If a term defines a scoped context, and then that term + is later re-defined, the association of the context defined in the earlier + expanded term definition is lost + within the scope of that re-definition. This is consistent with + term definitions of a term overriding previous term definitions from + earlier less deeply nested definitions, as discussed in + .

+ +

Scoped Contexts are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+ + +
+

Named Graphs

+ +

At times, it is necessary to make statements about a graph + itself, rather than just a single node. This can be done by + grouping a set of nodes using the @graph + keyword. A developer may also name data expressed using the + @graph keyword by pairing it with an + @id keyword as shown in the following example:

+ + 
+  
+
+ +

The example above expresses a named graph that is identified + by the Blank Node identifier _:graph. That + graph is composed of the statements about Manu and Gregg. Metadata about + the graph itself is expressed via the generatedAt property, + which specifies when the graph was generated. An alternative view of the + information above is represented in table form below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GraphSubjectPropertyValueValue Type
 _:graphprov:generatedAtTime2012-04-09xsd:date
_:graphhttp://manu.sporny.org/about#manuxsd:typefoaf:Person
_:graphhttp://manu.sporny.org/about#manufoaf:nameManu Sporny
_:graphhttp://manu.sporny.org/about#manufoaf:knowshttp://greggkellogg.net/foaf#me
_:graphhttp://greggkellogg.net/foaf#mexsd:typefoaf:Person
_:graphhttp://greggkellogg.net/foaf#mefoaf:nameGregg Kellogg
_:graphhttp://greggkellogg.net/foaf#mefoaf:knowshttp://manu.sporny.org/about#manu
+ +

When a JSON-LD document's top-level structure is an + object that contains no other + properties than @graph and + optionally @context (properties that are not mapped to an + IRI or a keyword are ignored), + @graph is considered to express the otherwise implicit + default graph. This mechanism can be useful when a number + of nodes exist at the document's top level that + share the same context, which is, e.g., the case when a + document is flattened. The + @graph keyword collects such nodes in an array + and allows the use of a shared context.

+ + 
+  
+
+ +

In this case, embedding doesn't work as each node object + references the other. This is equivalent to using multiple + node objects in array and defining + the @context within each node object:

+ + 
+  
+
+ +
+

Graph Containers

+

In some cases, it is useful to logically partition data into separate + graphs, without making this explicit within the JSON expression. For + example, a JSON document may contain data against which other metadata is + asserted and it is useful to separate this data in the data model using + the notion of named graphs, without the syntactic overhead + associated with the @graph keyword.

+ +

An expanded term definition can use @graph as the + value of @container. This indicates that values of this + term should be considered to be named graphs, where the + graph name is an automatically assigned blank node identifier + creating an implicitly named graph. When expanded, these become + simple graph objects.

+ +

An alternative to our example above could use an anonymously named graph + as follows:

+ + 
+    
+
+ +

The example above expresses a named graph that is identified + by the blank node identifier _:claim. That + graph is composed of the statements about Manu and Gregg. Metadata about + the graph itself is expressed via the generatedAt property, + which specifies when the graph was generated. An alternative view of the + information above is represented in table form below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GraphSubjectPropertyValueValue Type
 _:metadataprov:generatedAtTime2012-04-09xsd:date
 _:metadatacred:claim_:claim
_:claimhttp://manu.sporny.org/about#manuxsd:typefoaf:Person
_:claimhttp://manu.sporny.org/about#manufoaf:nameManu Sporny
_:claimhttp://manu.sporny.org/about#manufoaf:knowshttp://greggkellogg.net/foaf#me
_:claimhttp://greggkellogg.net/foaf#mexsd:typefoaf:Person
_:claimhttp://greggkellogg.net/foaf#mefoaf:nameGregg Kellogg
_:claimhttp://greggkellogg.net/foaf#mefoaf:knowshttp://manu.sporny.org/about#manu
+ +

Expanding this graph results in the following:

+ + 
+    
+
+ +

Strictly speaking, the value of such a term + is not a named graph, rather it is the graph name + associated with the named graph, which exists separately within + the dataset.

+ +

Graph Containers are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+
+ +
+

Identifying Blank Nodes

+ +

At times, it becomes necessary to be able to express information without + being able to uniquely identify the node with an IRI. + This type of node is called a blank node. JSON-LD does not require + all nodes to be identified using @id. However, some graph topologies + may require identifiers to be serializable. Graphs containing loops, e.g., cannot + be serialized using embedding alone, @id must be used to connect the nodes. + In these situations, one can use blank node identifiers, + which look like IRIs using an underscore (_) + as scheme. This allows one to reference the node locally within the document, but + makes it impossible to reference the node from an external document. The + blank node identifier is scoped to the document in which it is used.

+ + 
+  
+
+ +

The example above contains information about two secret agents that cannot be identified + with an IRI. While expressing that agent 1 knows agent 2 + is possible without using blank node identifiers, + it is necessary to assign agent 1 an identifier so that it can be referenced + from agent 2.

+

It is worth noting that blank node identifiers may be relabeled during processing. + If a developer finds that they refer to the blank node more than once, + they should consider naming the node using a dereferenceable IRI so that + it can also be referenced from other documents.

+
+ +
+

Aliasing Keywords

+ +

Each of the JSON-LD keywords, + except for @context, may be aliased to application-specific + keywords. This feature allows legacy JSON content to be utilized + by JSON-LD by re-using JSON keys that already exist in legacy documents. + This feature also allows developers to design domain-specific implementations + using only the JSON-LD context.

+ + 
+  
+
+ +

In the example above, the @id and @type + keywords have been given the aliases + url and a, respectively.

+ +

Since keywords cannot be redefined, they can also not be aliased to + other keywords.

+
+ +
+

Data Indexing

+ +

Databases are typically used to make access to + data more efficient. Developers often extend this sort of functionality into + their application data to deliver similar performance gains. Often this + data does not have any meaning from a Linked Data standpoint, but is + still useful for an application.

+ +

JSON-LD introduces the notion of index maps + that can be used to structure data into a form that is + more efficient to access. The data indexing feature allows an author to + structure data using a simple key-value map where the keys do not map + to IRIs. This enables direct access to data + instead of having to scan an array in search of a specific item. + In JSON-LD such data can be specified by associating the + @index keyword with a + @container declaration in the context:

+ + 
+  
+
+ +

In the example above, the post term has + been marked as an index map. The en and + de keys will be ignored semantically, but preserved + syntactically, by the JSON-LD Processor. This allows a developer to + access the German version of the post using the + following code snippet: obj.post.de.

+ +

The interpretation of the data above is expressed in + the table below. Note how the index keys do not appear in the Linked Data + below, but would continue to exist if the document were compacted or + expanded (see and + ) using a JSON-LD processor:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SubjectPropertyValue
http://example.com/rdf:typeschema:Blog
http://example.com/schema:nameWorld Financial News
http://example.com/schema:blogPosthttp://example.com/posts/1/en
http://example.com/schema:blogPosthttp://example.com/posts/1/de
http://example.com/posts/1/enschema:articleBodyWorld commodities were up today with heavy trading of crude oil...
http://example.com/posts/1/enschema:wordCount1539
http://example.com/posts/1/deschema:articleBodyDie Werte an Warenbörsen stiegen im Sog eines starken Handels von Rohöl...
http://example.com/posts/1/deschema:wordCount1204
+ +

The value of @container can also + be an array containing both @index and @set. + When compacting, this ensures that a JSON-LD Processor will use + the array form for all values of indexes.

+ + 
+  
+
+ +

If the processing mode is set to json-ld-1.1, + the special index @none is used for indexing + data which does not have an associated index, which is useful to maintain + a normalized representation.

+ + 
+  
+
+
+
+

Named Graph Indexing

+ +

In addition to indexing node objects by index, graph objects may + also be indexed by an index. By using the @graph + container type, introduced in + in addition to @index, an object value of such a property is + treated as a key-value map where the keys do not map to IRIs, but + are taken from an @index property associated with named graphs + which are their values. When expanded, these must be simple graph objects

+ +

The following example describes a default graph referencing multiple named + graphs using an index map.

+ + 
+  
+
+ +

This expands to the following:

+ + 
+  
+
+ +

When expressed as Quads, this becomes the following:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GraphSubjectPropertyValueValue Type
 http://example.com/rdf:typeschema:Blog
 http://example.com/schema:nameWorld Financial News
 http://example.com/schema:blogPost_:b1
 http://example.com/schema:blogPost_:b2
_:b1http://example.com/posts/1/deschema:wordCount1204xsd:integer
_:b1http://example.com/posts/1/deschema:articleBodyDie Werte an Warenbörsen stiegen im Sog eines starken Handels von Rohöl...
_:b2http://example.com/posts/1/enschema:wordCount1539xsd:integer
_:b2http://example.com/posts/1/enschema:articleBodyWorld commodities were up today with heavy trading of crude oil...
+ +

As with index maps, when used with @graph, a container may also + include @set to ensure that key values are always contained in an array.

+ +

If the processing mode is set to json-ld-1.1, + the special index @none is used for indexing + graphs which does not have an @index key, which is useful to maintain + a normalized representation. Note, however, that + compacting a document where multiple unidentified named graphs are + compacted using the @none index will result in the content + of those graphs being merged. To prevent this, give each graph a distinct + @index key.

+ + 
+  
+
+ +

This expands to the following:

+ + 
+  
+
+
+ +
+

Language Indexing

+ +

JSON which includes string values in multiple languages may be + represented using a language map to allow for easily + indexing property values by language tag. This enables direct access to + language values instead of having to scan an array in search of a specific item. + In JSON-LD such data can be specified by associating the + @language keyword with a + @container declaration in the context:

+ + 
+  
+
+ +

In the example above, the label term has + been marked as an language map. The en and + de keys are implicitly associated with their respective + values by the JSON-LD Processor. This allows a developer to + access the German version of the label using the + following code snippet: obj.label.de.

+ +

The value of @container can also + be an array containing both @language and @set. + When compacting, this ensures that a JSON-LD Processor will use + the array form for all values of language tags.

+ + 
+  
+
+ +

If the processing mode is set to json-ld-1.1, + the special index @none is used for indexing + data which does not have a language, which is useful to maintain + a normalized representation.

+ + 
+  
+
+
+ +
+

Node Identifier Indexing

+ +

In addition to index maps, JSON-LD introduces the notion of id maps + for structuring data. The id indexing feature allows an author to + structure data using a simple key-value map where the keys map + to IRIs. This enables direct access to associated node objects + instead of having to scan an array in search of a specific item. + In JSON-LD such data can be specified by associating the + @id keyword with a + @container declaration in the context:

+ + 
+  
+
+ +

In the example above, the post term has + been marked as an id map. The http://example.com/posts/1/en and + http://example.com/posts/1/de keys will be interpreted + as the @id property of the node object value.

+ +

The interpretation of the data above is exactly the same + as that in + using a JSON-LD processor.

+ +

The value of @container can also + be an array containing both @id and @set. + When compacting, this ensures that a JSON-LD processor will use + the array form for all values of node identifiers.

+ + 
+  
+
+ +

The special index @none is used for indexing + node objects which do not have an @id, which is useful to maintain + a normalized representation. The @none index may also be + a term which expands to @none, such as the term none + used in the example below.

+ + 
+  
+
+ +

Id maps are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+ +
+

Named Graph Indexing by Identifier

+ +

In addition to indexing node objects by identifier, graph objects may + also be indexed by their graph name. By using the @graph + container type, introduced in + in addition to @id, an object value of such a property is + treated as a key-value map where the keys represent the identifiers of named graphs + which are their values.

+ +

The following example describes a default graph referencing multiple named + graphs using an id map.

+ + 
+  
+
+ +

This expands to the following:

+ + 
+  
+
+ +

When expressed as Quads, this becomes the following:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GraphSubjectPropertyValueValue Type
 _:graphprov:generatedAtTime2012-04-09xsd:date
 _:graphhttp://example.org/graphMaphttp://manu.sporny.org/about#manu
 _:graphhttp://example.org/graphMaphttp://greggkellogg.net/foaf#me
_:manuhttp://manu.sporny.org/about#manuxsd:typefoaf:Person
_:manuhttp://manu.sporny.org/about#manufoaf:nameManu Sporny
_:manuhttp://manu.sporny.org/about#manufoaf:knowshttp://greggkellogg.net/foaf#me
_:gregghttp://greggkellogg.net/foaf#mexsd:typefoaf:Person
_:gregghttp://greggkellogg.net/foaf#mefoaf:nameGregg Kellogg
_:gregghttp://greggkellogg.net/foaf#mefoaf:knowshttp://manu.sporny.org/about#manu
+ +

As with id maps, when used with @graph, a container may also + include @set to ensure that key values are always contained in an array.

+ +

As with id maps, the special index @none is used for indexing + named graphs which do not have an @id, which is useful to maintain + a normalized representation. The @none index may also be + a term which expands to @none. + Note, however, that if multiple graphs are represented without + an @id, they will be merged on expansion. To prevent this, + use @none judiciously, and consider giving graphs + their own distinct identifier.

+ + 
+  
+
+ +

Graph Containers are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+ +
+

Node Type Indexing

+ +

In addition to id and index maps, JSON-LD introduces the notion of type maps + for structuring data. The type indexing feature allows an author to + structure data using a simple key-value map where the keys map + to IRIs. This enables data to be structured based on the @type + of specific node objects. + In JSON-LD such data can be specified by associating the + @type keyword with a + @container declaration in the context:

+ + 
+  
+
+ +

In the example above, the affiliation term has + been marked as an type map. The schema:Corporation and + schema:ProfessionalService keys will be interpreted + as the @type property of the node object value.

+ +

The value of @container can also + be an array containing both @type and @set. + When compacting, this ensures that a JSON-LD processor will use + the array form for all values of types.

+ + 
+  
+
+ +

The special index @none is used for indexing + node objects which do not have an @type, which is useful to maintain + a normalized representation. The @none index may also be + a term which expands to @none, such as the term none + used in the example below.

+ + 
+  
+
+ +

As with id maps, when used with @type, a container may also + include @set to ensure that key values are always contained in an array.

+ +

Type maps are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+ +
+

Nested Properties

+ +

Many JSON APIs separate properties from their entities using an + intermediate object; in JSON-LD these are called nested properties. + For example, a set of possible labels may be grouped + under a common property:

+ 
+  
+
+ +

By defining labels using the keyword @nest, + a JSON-LD processor will ignore the nesting created by using the + labels property and process the contents as if it were declared + directly within containing object. In this case, the labels + property is semantically meaningless. Defining it as equivalent to + @nest causes it to be ignored when expanding, making it + equivalent to the following:

+ + 
+  
+
+ +

Similarly, node definitions may contain a @nest property to + reference a term aliased to @nest which causes such + values to be nested under that aliased term.

+ 
+  
+
+ +

Nested properties are a new feature in JSON-LD 1.1, requiring + processing mode set to json-ld-1.1.

+
+ +
+

Expanded Document Form

+ +

The JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]] + defines a method for expanding a JSON-LD document. + Expansion is the process of taking a JSON-LD document and applying a + @context such that all IRIs, types, and values + are expanded so that the @context is no longer necessary.

+ +

For example, assume the following JSON-LD input document:

+ + 
+  
+
+ +

Running the JSON-LD Expansion algorithm against the JSON-LD input document + provided above would result in the following output:

+ + 
+  
+
+ +

JSON-LD's media type defines a + profile parameter which can be used to signal or request + expanded document form. The profile URI identifying expanded document + form is http://www.w3.org/ns/json-ld#expanded.

+
+ +
+

Compacted Document Form

+ +

The JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]] defines + a method for compacting a JSON-LD document. Compaction is the process + of applying a developer-supplied context to shorten IRIs + to terms or compact IRIs + and JSON-LD values expressed in expanded form to simple values such as + strings or numbers. + Often this makes it simpler to work with document as the data is expressed in + application-specific terms. Compacted documents are also typically easier to read + for humans.

+ +

For example, assume the following JSON-LD input document:

+ + 
+  
+
+ +

Additionally, assume the following developer-supplied JSON-LD context:

+ + 
+  
+
+ +

Running the JSON-LD Compaction algorithm given the context supplied above + against the JSON-LD input document provided above would result in the following + output:

+ + 
+  
+
+ +

JSON-LD's media type defines a + profile parameter which can be used to signal or request + compacted document form. The profile URI identifying compacted document + form is http://www.w3.org/ns/json-ld#compacted.

+
+ +
+

Flattened Document Form

+ +

The JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]] defines + a method for flattening a JSON-LD document. Flattening collects all + properties of a node in a single JSON object and labels + all blank nodes with + blank node identifiers. + This ensures a shape of the data and consequently may drastically simplify the code + required to process JSON-LD in certain applications.

+ +

For example, assume the following JSON-LD input document:

+ + 
+  
+
+ +

Running the JSON-LD Flattening algorithm against the JSON-LD input document in + the example above and using the same context would result in the following + output:

+ + 
+  
+
+ +

JSON-LD's media type defines a + profile parameter which can be used to signal or request + flattened document form. The profile URI identifying flattened document + form is http://www.w3.org/ns/json-ld#flattened. It can be + combined with the profile URI identifying + expanded document form or + compacted document from.

+
+ +
+

Embedding JSON-LD in HTML Documents

+ +

HTML script tags can be used to embed blocks of data in documents. + This way, JSON-LD content can be easily embedded in HTML by placing + it in a script element with the type attribute set to + application/ld+json.

+ + 
+  
+
+ +

Depending on how the HTML document is served, certain strings may need + to be escaped.

+ +

Defining how such data may be used is beyond the scope of this specification. + The embedded JSON-LD document might be extracted as is or, e.g., be + interpreted as RDF.

+ +

If JSON-LD content is extracted as RDF [[RDF11-CONCEPTS]], it should be expanded into an + RDF Dataset using the + Deserialize JSON-LD to RDF Algorithm + [[JSON-LD11CG-API]].

+
+ +
+ +
+

Data Model

+ +

JSON-LD is a serialization format for Linked Data based on JSON. + It is therefore important to distinguish between the syntax, which is + defined by JSON in [[!RFC7159]], and the data model which is + an extension of the RDF data model [[!RDF11-CONCEPTS]]. The precise + details of how JSON-LD relates to the RDF data model are given in + .

+ +

To ease understanding for developers unfamiliar with the RDF model, the + following summary is provided:

+ + + +

JSON-LD documents MAY contain data + that cannot be represented by the data model + defined above. Unless otherwise specified, such data is ignored when a + JSON-LD document is being processed. One result of this rule + is that properties which are not mapped to an IRI, + a blank node, or keyword will be ignored.

+ +

Additionally, the JSON serialization format is internally represented using + the JSON-LD internal representation, which uses the generic + concepts of arrays, dictionaries, + strings, numbers, booleans, and null to describe + the data represented by a JSON document.

+

An illustration of the data model

+

Figure 1: An illustration of the data model.

+
+ +
+

JSON-LD Grammar

+ +

This appendix restates the syntactic conventions described in the + previous sections more formally.

+ +

A JSON-LD document MUST be valid JSON text as described + in [[!RFC7159]], or some format that can be represented + in the JSON-LD internal representation that is equivalent to + valid JSON text.

+ +

A JSON-LD document MUST be a single node object, + a JSON object consisting of only + the members @context and/or @graph, + or an array or zero or more node objects.

+ +

In contrast to JSON, in JSON-LD the keys in objects + MUST be unique.

+ +

JSON-LD allows keywords to be aliased + (see for details). Whenever a keyword is + discussed in this grammar, the statements also apply to an alias for + that keyword. For example, if the active context + defines the term id as an alias for @id, + that alias may be legitimately used as a substitution for @id. + Note that keyword aliases are not expanded during context + processing.

+ +
+

Terms

+ +

A term is a short-hand string that expands + to an IRI or a blank node identifier.

+ +

A term MUST NOT equal any of the JSON-LD + keywords.

+ +

When used as the prefix in a Compact IRI, to avoid + the potential ambiguity of a prefix being confused with an IRI + scheme, terms SHOULD NOT come from the list of URI schemes as defined in + [[!IANA-URI-SCHEMES]]. Similarly, to avoid confusion between a + Compact IRI and a term, terms SHOULD NOT include a colon (:) + and SHOULD be restricted to the form of + isegment-nz-nc + as defined in [[!RFC3987]].

+ +

To avoid forward-compatibility issues, a term SHOULD NOT start + with an @ character as future versions of JSON-LD may introduce + additional keywords. Furthermore, the term MUST NOT + be an empty string ("") as not all programming languages + are able to handle empty JSON keys.

+ +

See and + for further discussion + on mapping terms to IRIs.

+
+ +
+

Node Objects

+ +

A node object represents zero or more properties of a + node in the graph serialized by the + JSON-LD document. A JSON object is a + node object if it exists outside of a JSON-LD + context and:

+ +
    +
  • it is not the top-most JSON object in the JSON-LD document consisting + of no other members than @graph and @context,
    • +
  • it does not contain the @value, @list, + or @set keywords, and
    • +
  • it is not a graph object.
    • +
+ +

The properties of a node in + a graph may be spread among different + node objects within a document. When + that happens, the keys of the different + node objects need to be merged to create the + properties of the resulting node.

+ +

A node object MUST be a JSON object. All keys + which are not IRIs, compact IRIs, terms valid in the + active context, or one of the following keywords + (or alias of such a keyword) + MUST be ignored when processed:

+ +
    +
  • @context,
    • +
  • @id,
    • +
  • @graph,
    • +
  • @nest,
    • +
  • @type,
    • +
  • @reverse, or
    • +
  • @index
    • +
+ +

If the node object contains the @context + key, its value MUST be null, an absolute IRI, + a relative IRI, a context definition, or + an array composed of any of these.

+ +

If the node object contains the @id key, + its value MUST be an absolute IRI, a relative IRI, + or a compact IRI (including + blank node identifiers). + See , + , and + for further discussion on + @id values.

+ +

If the node object contains the @graph + key, its value MUST be + a node object or + an array of zero or more node objects. + If the node object contains an @id keyword, + its value is used as the graph name of a named graph. + See for further discussion on + @graph values. As a special case, if a JSON object + contains no keys other than @graph and @context, and the + JSON object is the root of the JSON-LD document, the + JSON object is not treated as a node object; this + is used as a way of defining node objects + that may not form a connected graph. This allows a + context to be defined which is shared by all of the constituent + node objects.

+ +

If the node object contains the @type + key, its value MUST be either an absolute IRI, a + relative IRI, a compact IRI + (including blank node identifiers), + a term defined in the active context expanding into an absolute IRI, or + an array of any of these. + See for further discussion on + @type values.

+ +

If the node object contains the @reverse key, + its value MUST be a JSON object containing members representing reverse + properties. Each value of such a reverse property MUST be an absolute IRI, + a relative IRI, a compact IRI, a blank node identifier, + a node object or an array containing a combination of these.

+ +

If the node object contains the @index key, + its value MUST be a string. See + for further discussion + on @index values.

+ +

If the node object contains the @nest key, + its value MUST be an JSON object or an array of JSON objects + which MUST NOT include a value object. See + for further discussion + on @nest values.

+ +

Keys in a node object that are not + keywords MAY expand to an absolute IRI + using the active context. The values associated with keys that expand + to an absolute IRI MUST be one of the following:

+ + +
+ +
+

Graph Objects

+ +

A graph object represents a named graph, which MAY include + include an explicit graph name. + A JSON object is a graph object if + it exists outside of a JSON-LD context, + it is not a node object, + it is not the top-most JSON object in the JSON-LD document, and + it consists of no members other than @graph, + @index, @id + and @context, or an alias of one of these keywords.

+ +

If the graph object contains the @context + key, its value MUST be null, an absolute IRI, + a relative IRI, a context definition, or + an array composed of any of these.

+ +

If the graph object contains the @id key, + its value is used as the identifier (graph name) of a named graph, and + MUST be an absolute IRI, a relative IRI, + or a compact IRI (including + blank node identifiers). + See , + , and + for further discussion on + @id values.

+ +

A graph object without an @id member is also a + simple graph object and represents a named graph without an + explicit identifier, although in the data model it still has a + graph name, which is an implicitly allocated + blank node identifier.

+ +

The value of the @graph key MUST be + a node object or + an array of zero or more node objects. + See for further discussion on + @graph values..

+
+ +
+

Value Objects

+ +

A value object is used to explicitly associate a type or a + language with a value to create a typed value or a language-tagged + string.

+ +

A value object MUST be a JSON object containing the + @value key. It MAY also contain an @type, + an @language, an @index, or an @context key but MUST NOT contain + both an @type and an @language key at the same time. + A value object MUST NOT contain any other keys that expand to an + absolute IRI or keyword.

+ +

The value associated with the @value key MUST be either a + string, a number, true, + false or null.

+ +

The value associated with the @type key MUST be a + term, a compact IRI, + an absolute IRI, a string which can be turned + into an absolute IRI using the vocabulary mapping, or null.

+ +

The value associated with the @language key MUST have the + lexical form described in [[!BCP47]], or be null.

+ +

The value associated with the @index key MUST be a + string.

+ +

See and + + for more information on value objects.

+
+ +
+

Lists and Sets

+ +

A list represents an ordered set of values. A set + represents an unordered set of values. Unless otherwise specified, + arrays are unordered in JSON-LD. As such, the + @set keyword, when used in the body of a JSON-LD document, + represents just syntactic sugar which is optimized away when processing the document. + However, it is very helpful when used within the context of a document. Values + of terms associated with an @set or @list container + will always be represented in the form of an array when a document + is processed—even if there is just a single value that would otherwise be optimized to + a non-array form in compact document form. + This simplifies post-processing of the data as the data is always in a + deterministic form.

+ +

A list object MUST be a JSON object that contains no + keys that expand to an absolute IRI or keyword other + than @list, @context, and @index.

+ +

A set object MUST be a JSON object that contains no + keys that expand to an absolute IRI or keyword other + than @set, @context, and @index. + Please note that the @index key will be ignored when being processed.

+ +

In both cases, the value associated with the keys @list and @set + MUST be one of the following types:

+ + +

See for further discussion on sets and lists.

+
+ +
+

Language Maps

+ +

A language map is used to associate a language with a value in a + way that allows easy programmatic access. A language map may be + used as a term value within a node object if the term is defined + with @container set to @language, + + or an array containing both @language and @set + . The keys of a + language map MUST be strings representing + [[BCP47]] language codes, the keyword @none, + or a term which expands to @none, + and the values MUST be any of the following types:

+ + + +

See for further discussion + on language maps.

+
+ +
+

Index Maps

+ +

An index map allows keys that have no semantic meaning, + but should be preserved regardless, to be used in JSON-LD documents. + An index map may + be used as a term value within a node object if the + term is defined with @container set to @index, + + or an array containing both @index and @set + . + The values of the members of an index map MUST be one + of the following types:

+ + + +

See for further information on this topic.

+ +

Index Maps may also be used to map indexes to associated + named graphs, if the term is defined with @container + set to an array containing both @graph and + @index, and optionally including @set. The + value consists of the node objects contained within the named + graph which is named using the referencing key, which can be + represented as a simple graph object.

+
+ +
+

Id Maps

+ +

An id map is used to associate an IRI with a value that allows easy + programmatic access. An id map may be used as a term value within a node object if the term + is defined with @container set to @id, + or an array containing both @id and @set. + The keys of an id map MUST be IRIs + (relative IRI, compact IRI (including blank node identifiers), or absolute IRI), + the keyword @none, + or a term which expands to @none, + and the values MUST be node objects.

+ +

If the value contains a property expanding to @id, it's value MUST + be equivalent to the referencing key. Otherwise, the property from the value is used as + the @id of the node object value when expanding.

+ +

Id Maps may also be used to map graph names to their + named graphs, if the term is defined with @container + set to an array containing both @graph and @id, + and optionally including @set. The value consists of the + node objects contained within the named graph + which is named using the referencing key.

+
+ +
+

Type Maps

+ +

A type map is used to associate an IRI with a value that allows easy + programmatic access. A type map may be used as a term value within a node object if the term + is defined with @container set to @type, + or an array containing both @type and @set. + The keys of a type map MUST be IRIs + (relative IRI, compact IRI (including blank node identifiers), or absolute IRI), + the keyword @none, + or a term which expands to @none, + and the values MUST be node objects.

+ +

If the value contains a property expanding to @type, and it's value + is contains the referencing key after suitable expansion of both the referencing key + and the value, then the node object already contains the type. Otherwise, the property from the value is + added as a @type of the node object value when expanding.

+
+ +
+

Property Nesting

+ +

A nested property is used to gather properties of a node object in a separate + JSON object, or array of JSON objects which are not + value objects. It is semantically transparent and is removed + during the process of expansion. Property nesting is recursive, and + collections of nested properties may contain further nesting.

+ +

Semantically, nesting is treated as if the properties and values were declared directly + within the containing node object.

+
+ +
+

Context Definitions

+ +

A context definition defines a local context in a + node object.

+ +

A context definition MUST be a JSON object whose + keys MUST be either terms, compact IRIs, absolute IRIs, + or one of the keywords @language, @base, + @vocab, or @version.

+ +

If the context definition has an @language key, + its value MUST have the lexical form described in [[!BCP47]] or be null.

+ +

If the context definition has an @base key, + its value MUST be an absolute IRI, a relative IRI, + or null.

+ +

If the context definition has an @vocab key, + its value MUST be a absolute IRI, a compact IRI, + a blank node identifier, + an empty string (""), + a term, or null.

+ +

If the context definition has an @version key, + its value MUST be a number with the value 1.1.

+ +

The value of keys that are not keywords MUST be either an + absolute IRI, a compact IRI, a term, + a blank node identifier, a keyword, null, + or an expanded term definition.

+ +

An expanded term definition is used to describe the mapping + between a term and its expanded identifier, as well as other + properties of the value associated with the term when it is + used as key in a node object.

+ +

An expanded term definition MUST be a JSON object + composed of zero or more keys from + @id, + @reverse, + @type, + @language, + @context, + @prefix, or + @container. An + expanded term definition SHOULD NOT contain any other keys.

+ +

If the term being defined is not a compact IRI or + absolute IRI and the active context does not have an + @vocab mapping, the expanded term definition MUST + include the @id key.

+ +

If the expanded term definition contains the @id + keyword, its value MUST be null, an absolute IRI, + a blank node identifier, a compact IRI, a term, + or a keyword.

+ +

If an expanded term definition has an @reverse member, + it MUST NOT have @id or @nest members at the same time, + its value MUST be an absolute IRI, + a blank node identifier, a compact IRI, or a term. If an + @container member exists, its value MUST be null, + @set, or @index.

+ +

If the expanded term definition contains the @type + keyword, its value MUST be an absolute IRI, a + compact IRI, a term, null, or one of the + keywords @id or @vocab.

+ +

If the expanded term definition contains the @language keyword, + its value MUST have the lexical form described in [[!BCP47]] or be null.

+ +

If the expanded term definition contains the @container + keyword, its value MUST be either + @list, + @set, + @language, + @index, + @id, + @graph, + @type, or be + null + + or an array containing exactly any one of those keywords, or a + combination of @set and any of @index, + @id, @graph, @type, + @language in any order + . + @container may also be an array + containing @graph along with either @id or + @index and also optionally including @set. + If the value + is @language, when the term is used outside of the + @context, the associated value MUST be a language map. + If the value is @index, when the term is used outside of + the @context, the associated value MUST be an + index map.

+ +

If an expanded term definition has an @context member, + it MUST be a valid context definition.

+ +

If the expanded term definition contains the @nest + keyword, its value MUST be either @nest, or a term + which expands to @nest.

+ +

If the expanded term definition contains the @prefix + keyword, its value MUST be true or false.

+ +

Terms MUST NOT be used in a circular manner. That is, + the definition of a term cannot depend on the definition of another term if that other + term also depends on the first term.

+ +

See for further discussion on contexts.

+
+ +
+ +
+

Relationship to RDF

+ +

JSON-LD is a + concrete RDF syntax + as described in [[RDF11-CONCEPTS]]. Hence, a JSON-LD document is both an + RDF document and a JSON document and correspondingly represents an + instance of an RDF data model. However, JSON-LD also extends the RDF data + model to optionally allow JSON-LD to serialize + generalized RDF Datasets. + The JSON-LD extensions to the RDF data model are:

+ + + +

Summarized, these differences mean that JSON-LD is capable of serializing any RDF + graph or dataset and most, but not all, JSON-LD documents can be directly + interpreted as RDF as described in RDF 1.1 Concepts [[RDF11-CONCEPTS]].

+ +

For authors and developers working with blank nodes + as properties when deserializing to RDF, + three potential approaches are suggested:

+ + + +

The normative algorithms for interpreting JSON-LD as RDF and serializing + RDF as JSON-LD are specified in the JSON-LD 1.1 Processing Algorithms and API + specification [[JSON-LD11CG-API]].

+ +

Even though JSON-LD serializes + generalized RDF Datasets, it can + also be used as a RDF graph source. + In that case, a consumer MUST only use the default graph and ignore all named graphs. + This allows servers to expose data in languages such as Turtle and JSON-LD + using content negotiation.

+ +

Publishers supporting both dataset and graph syntaxes have to ensure that + the primary data is stored in the default graph to enable consumers that do not support + datasets to process the information.

+ +
+

Serializing/Deserializing RDF

+ +

The process of serializing RDF as JSON-LD and deserializing JSON-LD to RDF + depends on executing the algorithms defined in + RDF Serialization-Deserialization Algorithms + in the JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]]. + It is beyond the scope of this document to detail these algorithms any further, + but a summary of the necessary operations is provided to illustrate the process.

+ +

The procedure to deserialize a JSON-LD document to RDF involves the + following steps:

+ +
    +
  1. Expand the JSON-LD document, removing any context; this ensures + that properties, types, and values are given their full representation + as IRIs and expanded values. Expansion + is discussed further in .
    2. +
  2. Flatten the document, which turns the document into an array of + node objects. Flattening is discussed + further in .
    3. +
  3. Turn each node object into a series of RDF triples.
    4. +
+ +

For example, consider the following JSON-LD document in compact form:

+ + 
+    
+
+ +

Running the JSON-LD Expansion and Flattening algorithms against the + JSON-LD input document in the example above would result in the + following output:

+ + 
+    
+
+ +

Deserializing this to RDF now is a straightforward process of turning + each node object into one or more RDF triples. This can be + expressed in Turtle as follows:

+ + 
+    
+
+ +

The process of serializing RDF as JSON-LD can be thought of as the + inverse of this last step, creating an expanded JSON-LD document closely + matching the triples from RDF, using a single node object + for all triples having a common subject, and a single property + for those triples also having a common predicate.

+
+
+ +
+

Changes since 1.0 Recommendation of 16 January 2014

+ +
+ +
+

Open Issues

+

The following is a list of issues open at the time of publication.

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+

+
+ +
+

Relationship to Other Linked Data Formats

+ +

The JSON-LD examples below demonstrate how JSON-LD can be used to + express semantic data marked up in other linked data formats such as Turtle, + RDFa, Microformats, and Microdata. These sections are merely provided as + evidence that JSON-LD is very flexible in what it can express across different + Linked Data approaches.

+ +
+

Turtle

+ +

The following are examples of transforming RDF expressed in Turtle [[TURTLE]] + into JSON-LD.

+ +
+

Prefix definitions

+ +

The JSON-LD context has direct equivalents for the Turtle + @prefix declaration:

+ + 
+      
+
+ + 
+      
+
+
+ +
+

Embedding

+ +

Both Turtle and JSON-LD allow embedding, although Turtle only allows embedding of + blank nodes.

+ + 
+      
+
+ + 
+      
+
-
-

- This is an unofficial proposal. -

+ +
+

Conversion of native data types

+ +

In JSON-LD numbers and boolean values are native data types. While Turtle + has a shorthand syntax to express such values, RDF's abstract syntax requires + that numbers and boolean values are represented as typed literals. Thus, + to allow full round-tripping, the JSON-LD 1.1 Processing Algorithms and API specification [[JSON-LD11CG-API]] + defines conversion rules between JSON-LD's native data types and RDF's + counterparts. Numbers without fractions are + converted to xsd:integer-typed literals, numbers with fractions + to xsd:double-typed literals and the two boolean values + true and false to a xsd:boolean-typed + literal. All typed literals are in canonical lexical form.

+ + 
+      
+
+ + 
+      
+
+
-
-

Introduction

-

- See ReSpec's user guide - for how toget started! -

+
+

Lists

+

Both JSON-LD and Turtle can represent sequential lists of values.

+ + 
+      
+
+ + 
+      
+
- +
+ +
+

RDFa

+ +

The following example describes three people with their respective names and + homepages in RDFa [[RDFA-CORE]].

+ + 
+    
+
+ +

An example JSON-LD implementation using a single context is + described below.

+ + 
+    
+
+
+ +
+

Microformats

+ +

The following example uses a simple Microformats hCard example to express + how Microformats [[MICROFORMATS]] are represented in JSON-LD.

+ + 
+    
+
+ +

The representation of the hCard expresses the Microformat terms in the + context and uses them directly for the url and fn + properties. Also note that the Microformat to JSON-LD processor has + generated the proper URL type for http://tantek.com/.

+ + 
+    
+
+
+ +
+

Microdata

+ +

The HTML Microdata [[MICRODATA]] example below expresses book information as + a Microdata Work item.

+ + 
+    
+
+ +

Note that the JSON-LD representation of the Microdata information stays + true to the desires of the Microdata community to avoid contexts and + instead refer to items by their full IRI.

+ + 
+    
+
+
+
+ +
+

IANA Considerations

+ +

This section has been submitted to the Internet Engineering Steering + Group (IESG) for review, approval, and registration with IANA.

+ +

application/ld+json

+
+
Type name:
+
application
+
Subtype name:
+
ld+json
+
Required parameters:
+
None
+
Optional parameters:
+
+
+
profile
+
+

A non-empty list of space-separated URIs identifying specific + constraints or conventions that apply to a JSON-LD document according to [[RFC6906]]. + A profile does not change the semantics of the resource representation + when processed without profile knowledge, so that clients both with + and without knowledge of a profiled resource can safely use the same + representation. The profile parameter MAY be used by + clients to express their preferences in the content negotiation process. + If the profile parameter is given, a server SHOULD return a document that + honors the profiles in the list which are recognized by the server. + It is RECOMMENDED that profile URIs are dereferenceable and provide + useful documentation at that URI. For more information and background + please refer to [[RFC6906]].

+

This specification defines three values for the profile parameter. + To request or specify expanded JSON-LD document form, + the URI http://www.w3.org/ns/json-ld#expanded SHOULD be used. + To request or specify compacted JSON-LD document form, + the URI http://www.w3.org/ns/json-ld#compacted SHOULD be used. + To request or specify flattened JSON-LD document form, + the URI http://www.w3.org/ns/json-ld#flattened SHOULD be used. + Please note that, according [[HTTP11]], the value of the profile + parameter has to be enclosed in quotes (") because it contains + special characters and, if multiple profiles are combined, whitespace.

+

When processing the "profile" media type parameter, it is important to + note that its value contains one or more URIs and not IRIs. In some cases + it might therefore be necessary to convert between IRIs and URIs as specified in + section 3 Relationship between IRIs and URIs + of [[RFC3987]].

+
+
+
+
Encoding considerations:
+
See RFC 6839, section 3.1.
+
Security considerations:
+
See [[!RFC7159]] +

Since JSON-LD is intended to be a pure data exchange format for + directed graphs, the serialization SHOULD NOT be passed through a + code execution mechanism such as JavaScript's eval() + function to be parsed. An (invalid) document may contain code that, + when executed, could lead to unexpected side effects compromising + the security of a system.

+

When processing JSON-LD documents, links to remote contexts are + typically followed automatically, resulting in the transfer of files + without the explicit request of the user for each one. If remote + contexts are served by third parties, it may allow them to gather + usage patterns or similar information leading to privacy concerns. + Specific implementations, such as the API defined in the + JSON-LD 1.1 Processing Algorithms and API specification [[!JSON-LD11CG-API]], + may provide fine-grained mechanisms to control this behavior.

+

JSON-LD contexts that are loaded from the Web over non-secure connections, + such as HTTP, run the risk of being altered by an attacker such that + they may modify the JSON-LD active context in a way that + could compromise security. It is advised that any application that + depends on a remote context for mission critical purposes vet and + cache the remote context before allowing the system to use it.

+

Given that JSON-LD allows the substitution of long IRIs with short terms, + JSON-LD documents may expand considerably when processed and, in the worst case, + the resulting data might consume all of the recipient's resources. Applications + should treat any data with due skepticism.

+
+
Interoperability considerations:
+
Not Applicable
+
Published specification:
+
http://www.w3.org/TR/json-ld
+
Applications that use this media type:
+
Any programming environment that requires the exchange of + directed graphs. Implementations of JSON-LD have been created for + JavaScript, Python, Ruby, PHP, and C++. +
+
Additional information:
+
+
+
Magic number(s):
+
Not Applicable
+
File extension(s):
+
.jsonld
+
Macintosh file type code(s):
+
TEXT
+
+
+
Person & email address to contact for further information:
+
Manu Sporny <msporny@digitalbazaar.com>
+
Intended usage:
+
Common
+
Restrictions on usage:
+
None
+
Author(s):
+
Manu Sporny, Dave Longley, Gregg Kellogg, Markus Lanthaler, Niklas Lindström
+
Change controller:
+
W3C
+
+ +

Fragment identifiers used with application/ld+json + are treated as in RDF syntaxes, as per + RDF 1.1 Concepts and Abstract Syntax + [[RDF11-CONCEPTS]].

+
+ +
+

Security Considerations

+

Consider requirements from Self-Review Questionnaire: Security and Privacy.

+

See,

+
+ +
+

Acknowledgements

+ +

The authors would like to extend a deep appreciation and the most sincere + thanks to Mark Birbeck, who contributed foundational concepts + to JSON-LD via his work on RDFj. JSON-LD uses a number of core concepts + introduced in RDFj, such as the context as a mechanism to provide an + environment for interpreting JSON data. Mark had also been very involved in + the work on RDFa as well. RDFj built upon that work. JSON-LD exists + because of the work and ideas he started nearly a decade ago in 2004.

+ +

A large amount of thanks goes out to the JSON-LD Community Group + participants who worked through many of the technical issues on the mailing + list and the weekly telecons - of special mention are François Daoust, + Stéphane Corlosquet, Lin Clark, and Zdenko 'Denny' Vrandečić.

+ +

The work of David I. Lehn and Mike Johnson are appreciated for + reviewing, and performing several early implementations + of the specification. Thanks also to Ian Davis for this work on RDF/JSON.

+ +

Thanks to the following individuals, in order of their first name, for + their input on the specification: Adrian Walker, Alexandre Passant, + Andy Seaborne, Ben Adida, Blaine Cook, Bradley Allen, Brian Peterson, + Bryan Thompson, Conal Tuohy, Dan Brickley, Danny Ayers, Daniel Leja, + Dave Reynolds, David Booth, David I. Lehn, David Wood, Dean Landolt, + Ed Summers, elf Pavlik, + Eric Prud'hommeaux, Erik Wilde, Fabian Christ, Jon A. Frost, Gavin Carothers, + Glenn McDonald, Guus Schreiber, Henri Bergius, Jose María Alvarez Rodríguez, + Ivan Herman, Jack Moffitt, Josh Mandel, KANZAKI Masahide, Kingsley Idehen, + Kuno Woudt, Larry Garfield, Mark Baker, Mark MacGillivray, Marko Rodriguez, + Marios Meimaris, Matt Wuerstl, + Melvin Carvalho, Nathan Rixham, Olivier Grisel, Paolo Ciccarese, Pat Hayes, + Patrick Logan, Paul Kuykendall, Pelle Braendgaard, + Peter Patel-Schneider, Peter Williams, Pierre-Antoine Champin, + Richard Cyganiak, Roy T. Fielding, Sandro Hawke, Simon Grant, Srecko Joksimovic, + Stephane Fellah, Steve Harris, Ted Thibodeau Jr., Thomas Steiner, Tim Bray, + Tom Morris, Tristan King, Sergio Fernández, Werner Wilms, and William Waites.

+
+ + diff --git a/linked-data-graph.dia b/linked-data-graph.dia new file mode 100644 index 0000000000000000000000000000000000000000..3e3fa6ba838fb57d55dd6632f1126a4201993cf7 GIT binary patch literal 2150 zcmV-s2$}aEiwFP!000021MOW~Z{xNSe&1hVcwZfw_eSPDDmTfJ zEbl!=$!-7R=j!SYS7L@+a^8@=jAnM6+vrQXXbhJzr-)wKd{^vZnH4b%a*0hKi1V+J>1A^s%$Gzxrp*vobF>m|0H#1P$Zafmn2#+Och)A z%kgmI%fcm>h08As7Z>--EHCpYF83kFS(ex+tx?PT!Jdv&Oriu-?5$>DWQ0+i6CpU3 zMi6s4+~>F~Gp`K-gr|5~&i6s$w5$P0C+Tw=&*o)E@%7^u`Z$(~W_dh)n~Ancv`DG? z>Hh0m-@Zdv)zY6mNq>xsc%0a#+MnY)uf;!~NBr*Bsm#&l^^V$5OKY`vQ*DJ6$J@Kv zLp-&`0X5q$(;{iUDmFaS>$~ON+cEW{9q*%pNTO$(uf+eh@jH5}54>WVUNkA=$MxN- zKFP*^+ex`!XT>U+Jl%wAMVBc&ua z1BSRzYPTQuS)>hRJl+M#p&3y+OY92}6~+uGl17RVVMr080asxCn%|EBo@8lyZ_{bj zo>N-6UlQsig;uU4CRm(dayqT2gi zE3{`-!3ot&5^OLgTuH3NX=u>p_fei_PrG0?eOT0BtfS=n#HO>iThq1jhx_ZD2u=+_ z*Yh(*^Pb}xn%|;mymvM^J{SB_O!C$WwL&mZoe$|32diI_2Zgc-oZAX z?AP)Y-H;XCkgjw?kv3Y3fkZ?Kk8HEX5lC|-M#_z5=3ps55w>(aa=^&$lxcH-s}O6e z+)hNc3W1Bs+%6)N<+GuCvn4`%!xLz8DYLX}f_Kk*pQA;bJVPyQ9)Irlit^bho(8q8 zU;Y#?Y;p5jmP}tO?D3UoaB3SyAg8RlgvMAdK~DkOc9Pzh8o;<45X4in zbYYu6>V}fvi_+)<9XD7Wt16vt9nQm6w7YYpjbx5R4D;$5tzjggm1`up)}VrzTq9R~ zNwcRSkktjqs#!k+S6v}jv94St5ayDLfkMisW3_?d%yAV)hG+w~nq3W7*{{)Jnb?Y~ zmNtX`4nYSd!NIx&XEp0-;H)d;EZ&u~2tiy{?4ht%*4h9uGa?ER&MH)`#5J?lI2#Af zx&UXj>1klCD`YLvm9=g#5=skE%_e&!trr}M;OFQSto-&#>%zPgrNs*^y|B`sHhHvV zJc%wrN*Zrp+&3w;sA1rwE94}3hIw^xX&hBB2+RCVtgnDD5hIC=($yVU;j5fjk7gn4 zyU@IPqk;yyxfv~=1!fMXhG+p^hA%;2E1CBJ)hI@_nutNYO zr3s}YK$euc%ml8r@|?8U+RUctf?zBM0x3@X=WG%sTvnOET4^o_Ga+a5$IRIz_^6~! zw*59fchY7v-4J{(zVV(T?k1H$$-&A|MJTE0hKMRj93Gns@y+2Raj2(a#HF$`-*kha zE4WnLFha4BLKzj<=Er0kc@)`jA7t}Kl08l4QCYCCBDbfJ!cZiN zNS_`KAaUcidjQ`kIx>jBKvUpJ5EygxMEyzZ;(n6l>Hf~#bGNaAI-sS%RvOv{9-PFO zxoM9MSbOo&?gl$#1Y?qca|9G3wKx%MoaIxSUyiVfISluPZQ_TwiynirjHc7=D0{C# zOfUgGXs|GhDt4;X3$vBq(`==NfD3a2p%CMY(eEq%Cm!PeGa9qby9fw#gWCC(gm_JI z102lUCPyp<)*~VicliNe%ZR4hr!6}}6N4oSmMmDZ@7|ITFkuEle2%D=QU^f|z)t3#RRliYyW9S|d$R7bgCL%{_SoC(j1^lhzd zKl80qmQ*;&Ev(ZYT&JgZei7#;gNRhtI-qZb$%DTf{N-jH4F2*po^Fi0r*lY6>f>X*`pX*}H&HbrNRs-9ZH%vg zlYR|HgI;KpbBjI(cDhD(BHh_(z2#jo&-C=Nx1Kn5Vx+#)S8=2jqk)?)!cEQE7|7{g cC8zqn`jcCCAGZD`*WHKz1G@?~2#9n50H^6c`~Uy| literal 0 HcmV?d00001 diff --git a/linked-data-graph.png b/linked-data-graph.png new file mode 100644 index 0000000000000000000000000000000000000000..f1c0d76d0cd617f0dae2d89ce05fec32e36e7a61 GIT binary patch literal 27844 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 literal 0 HcmV?d00001 From 9644c812bbbb0881f1347a790297959e3f936e2f Mon Sep 17 00:00:00 2001 From: Gregg Kellogg Date: Fri, 8 Jun 2018 15:49:16 -0700 Subject: [PATCH 2/3] Updates for WG docs. --- index.html | 114 ++++++++++++++++++++++------------------------------- 1 file changed, 47 insertions(+), 67 deletions(-) diff --git a/index.html b/index.html index 82999bd8..cd4363a7 100644 --- a/index.html +++ b/index.html @@ -4,7 +4,7 @@ JSON-LD 1.1 - + +