Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.json

JavaScript Object Notation
License:
Boost License 1.0.
Authors:
Jeremie Pelletier, David Herberth

References http://json.org/

Source std/json.d

Examples:

    import std.conv : to;

    // parse a file or string of json into a usable structure
    string s = `{ "language": "D", "rating": 3.5, "code": "42" }`;
    JSONValue j = parseJSON(s);
    // j and j["language"] return JSONValue,
    // j["language"].str returns a string
    writeln(j["language"].str); // "D"
    writeln(j["rating"].floating); // 3.5

    // check a type
    long x;
    if (const(JSONValue)* code = "code" in j)
    {
        if (code.type() == JSON_TYPE.INTEGER)
            x = code.integer;
        else
            x = to!int(code.str);
    }

    // create a json struct
    JSONValue jj = [ "language": "D" ];
    // rating doesnt exist yet, so use .object to assign
    jj.object["rating"] = JSONValue(3.5);
    // create an array to assign to list
    jj.object["list"] = JSONValue( ["a", "b", "c"] );
    // list already exists, so .object optional
    jj["list"].array ~= JSONValue("D");

    string jjStr = `{"language":"D","list":["a","b","c","D"],"rating":3.5}`;
    writeln(jj.toString); // jjStr

enum `JSONFloatLiteral`: string;
  String literals used to represent special float values within JSON strings.
  `nan`
    string representation of floating-point NaN
  `inf`
    string representation of floating-point Infinity
  `negativeInf`
    string representation of floating-point negative Infinity
enum `JSONOptions`: int;
  Flags that control how json is encoded and parsed.
  `none`
    standard parsing
  `specialFloatLiterals`
    encode NaN and Inf float values as strings
  `escapeNonAsciiChars`
    encode non ascii characters with an unicode escape sequence
  `doNotEscapeSlashes`
    do not escape slashes ('/')
enum `JSON_TYPE`: byte;
  JSON type enumeration
  `NULL`
  `STRING`
  `INTEGER`
  `UINTEGER`
  `FLOAT`
  `OBJECT`
  `ARRAY`
  `TRUE`
  `FALSE`
    Indicates the type of a JSONValue.
struct `JSONValue`;
  JSON value node
  const pure nothrow @nogc @property @safe JSON_TYPE `type`();
    Returns the JSON_TYPE of the value stored in this structure.
    Examples:

        string s = "{ \"language\": \"D\" }";
        JSONValue j = parseJSON(s);
        writeln(j.type); // JSON_TYPE.OBJECT
        writeln(j["language"].type); // JSON_TYPE.STRING

  const pure @property @trusted string `str`();
  pure nothrow @nogc @property @safe string `str`(string `v`);
    Value getter/setter for JSON_TYPE.STRING.
    Throws:
    JSONException for read access if type is not JSON_TYPE.STRING.
    Examples:

        JSONValue j = [ "language": "D" ];

        // get value
        writeln(j["language"].str); // "D"

        // change existing key to new string
        j["language"].str = "Perl";
        writeln(j["language"].str); // "Perl"

  inout pure @property @safe inout(long) `integer`();
  pure nothrow @nogc @property @safe long `integer`(long `v`);
    Value getter/setter for JSON_TYPE.INTEGER.
    Throws:
    JSONException for read access if type is not JSON_TYPE.INTEGER.
  inout pure @property @safe inout(ulong) `uinteger`();
  pure nothrow @nogc @property @safe ulong `uinteger`(ulong `v`);
    Value getter/setter for JSON_TYPE.UINTEGER.
    Throws:
    JSONException for read access if type is not JSON_TYPE.UINTEGER.
  inout pure @property @safe inout(double) `floating`();
  pure nothrow @nogc @property @safe double `floating`(double `v`);
    Value getter/setter for JSON_TYPE.FLOAT. Note that despite the name, this is a 64-bit double, not a 32-bit float.
    Throws:
    JSONException for read access if type is not JSON_TYPE.FLOAT.
  inout pure @property ref @system inout(JSONValue[string]) `object`();
  pure nothrow @nogc @property @safe JSONValue[string] `object`(JSONValue[string] `v`);
    Value getter/setter for JSON_TYPE.OBJECT.
    Throws:
    JSONException for read access if type is not JSON_TYPE.OBJECT.

    Note this is @system because of the following pattern:

        auto a = &(json.object());
        json.uinteger = 0;        // overwrite AA pointer
        (*a)["hello"] = "world";  // segmentation fault

  inout pure @property @trusted inout(JSONValue[string]) `objectNoRef`();
    Value getter for JSON_TYPE.OBJECT. Unlike object, this retrieves the object by value and can be used in @safe code.
    A caveat is that, if the returned value is `null`, modifications will not be visible:

        JSONValue json;
        json.object = null;
        json.objectNoRef["hello"] = JSONValue("world");
        assert("hello" !in json.object);

    Throws:
    JSONException for read access if type is not JSON_TYPE.OBJECT.
  inout pure @property ref @system inout(JSONValue[]) `array`();
  pure nothrow @nogc @property @safe JSONValue[] `array`(JSONValue[] `v`);
    Value getter/setter for JSON_TYPE.ARRAY.
    Throws:
    JSONException for read access if type is not JSON_TYPE.ARRAY.

    Note this is @system because of the following pattern:

        auto a = &(json.array());
        json.uinteger = 0;  // overwrite array pointer
        (*a)[0] = "world";  // segmentation fault

  inout pure @property @trusted inout(JSONValue[]) `arrayNoRef`();
    Value getter for JSON_TYPE.ARRAY. Unlike array, this retrieves the array by value and can be used in @safe code.
    A caveat is that, if you append to the returned array, the new values aren't visible in the

    JSONValue

        JSONValue json;
        json.array = [JSONValue("hello")];
        json.arrayNoRef ~= JSONValue("world");
        assert(json.array.length == 1);

    Throws:
    JSONException for read access if type is not JSON_TYPE.ARRAY.
  const pure nothrow @nogc @property @safe bool `isNull`();
    Test whether the type is JSON_TYPE.NULL
  this(T)(T `arg`)
  if (!isStaticArray!T);
  this(T)(ref T `arg`)
  if (isStaticArray!T);
  inout this(T : JSONValue)(inout T `arg`);
    Constructor for JSONValue. If `arg` is a JSONValue its value and type will be copied to the new JSONValue. Note that this is a shallow copy: if type is JSON_TYPE.OBJECT or JSON_TYPE.ARRAY then only the reference to the data will be copied. Otherwise, `arg` must be implicitly convertible to one of the following types: typeof(`null`), string, ulong, long, double, an associative array V[K] for any V and K i.e. a JSON object, any array or bool. The type will be set accordingly.
    Examples:

        JSONValue j = JSONValue( "a string" );
        j = JSONValue(42);

        j = JSONValue( [1, 2, 3] );
        writeln(j.type); // JSON_TYPE.ARRAY

        j = JSONValue( ["language": "D"] );
        writeln(j.type); // JSON_TYPE.OBJECT

  inout pure ref @safe inout(JSONValue) `opIndex`(size_t `i`);
    Array syntax for json arrays.
    Throws:
    JSONException if type is not JSON_TYPE.ARRAY.
    Examples:

        JSONValue j = JSONValue( [42, 43, 44] );
        writeln(j[0].integer); // 42
        writeln(j[1].integer); // 43

  inout pure ref @safe inout(JSONValue) `opIndex`(string `k`);
    Hash syntax for json objects.
    Throws:
    JSONException if type is not JSON_TYPE.OBJECT.
    Examples:

        JSONValue j = JSONValue( ["language": "D"] );
        writeln(j["language"].str); // "D"

  pure void `opIndexAssign`(T)(auto ref T `value`, string `key`);
    Operator sets `value` for element of JSON object by `key`.
    If JSON `value` is `null`, then operator initializes it with object and then sets `value` for it.
    Throws:
    JSONException if type is not JSON_TYPE.OBJECT or JSON_TYPE.NULL.
    Examples:

        JSONValue j = JSONValue( ["language": "D"] );
        j["language"].str = "Perl";
        writeln(j["language"].str); // "Perl"

  const @safe auto `opBinaryRight`(string op : "in")(string `k`);
    Support for the in operator.
    Tests wether a key can be found in an object.
    Returns:
    when found, the const(JSONValue)* that matches to the key, otherwise `null`.
    Throws:
    JSONException if the right hand side argument JSON_TYPE is not OBJECT.
    Examples:

        JSONValue j = [ "language": "D", "author": "walter" ];
        string a = ("author" in j).str;

  @system int `opApply`(scope int delegate(size_t index, ref JSONValue) `dg`);
    Implements the foreach `opApply` interface for json arrays.
  @system int `opApply`(scope int delegate(string key, ref JSONValue) `dg`);
    Implements the foreach `opApply` interface for json objects.
  const @safe string `toString`(in JSONOptions `options` = JSONOptions.none);
    Implicitly calls toJSON on this JSONValue.
    `options` can be used to tweak the conversion behavior.
  const @safe string `toPrettyString`(in JSONOptions `options` = JSONOptions.none);
    Implicitly calls toJSON on this JSONValue, like toString, but also passes `true` as pretty argument.
    `options` can be used to tweak the conversion behavior
JSONValue `parseJSON`(T)(T `json`, int `maxDepth` = -1, JSONOptions `options` = JSONOptions.none)
if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T));
  Parses a serialized string and returns a tree of JSON values.
  Throws:
  JSONException if the depth exceeds the max depth.
  Parameters:

  T `json` | `json`-formatted string to parse
  int `maxDepth` | maximum depth of nesting allowed, -1 disables depth checking
  JSONOptions `options` | enable decoding string representations of NaN/Inf as float values

JSONValue `parseJSON`(T)(T `json`, JSONOptions `options`)
if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T));
  Parses a serialized string and returns a tree of JSON values.
  Throws:
  json.html#.JSONException">std.`json`.JSONException if the depth exceeds the max depth.
  Parameters:

  T `json` | `json`-formatted string to parse
  JSONOptions `options` | enable decoding string representations of NaN/Inf as float values

@safe string `toJSON`(ref const JSONValue `root`, in bool `pretty` = false, in JSONOptions `options` = JSONOptions.none);
  Takes a tree of JSON values and returns the serialized string.
  Any Object types will be serialized in a key-sorted order.
  If `pretty` is `false` no whitespaces are generated. If `pretty` is `true` serialized string is formatted to be human-readable. Set the JSONOptions.specialFloatLiterals flag is set in `options` to encode NaN/Infinity as strings.
class `JSONException`: object.Exception;
  Exception thrown on JSON errors

Copyright © 1999-2017 by the D Language Foundation | Page generated by Ddoc on Mon Oct 9 11:31:39 2017