JSON: Difference between revisions

Use objects and arrays (as appropriate for your language)

and make sure your JSON is valid (https://jsonformatter.org).

 

=={{header|8th}}==

=={{header|Ada}}==

=== Alternative using GNATCOLL ===

with Ada.Text_IO;

with GNATCOLL.JSON;

Put_Line (Penguin.Write);

end JSON_Test;

 

{{out}}

=== Alternative using Matreshka ===

 

with Ada.Wide_Wide_Text_IO; use Ada.Wide_Wide_Text_IO;

with League.JSON.Arrays; use League.JSON.Arrays;

Put_Line (To_JSON_Document (Penguin).To_JSON.To_Wide_Wide_String);

end Main;

 

{{out}}

=={{header|AntLang}}==

JSON parser (maybe failes with "invalid JSON" error)

json:{[data]catch[eval[,|{[y]catch[{":" = "="; "[" = "<"; "]" = ">"; "," = ";"}[y];{x};{[]y}]}'("""("(\\.|[^\\"])*"|\-?[0-9]+(\.[0-9]+)?|\{|\}|\[|\]|\:|\,)"""~data)["strings"]];{x};{error["Invalid JSON"]}]}

 

=={{header|ANTLR}}==

 

===Java===

// Parse JSON

//

| array;

array : '[' {System.out.println(Indent + "Array"); Indent += " ";} (value (',' value)*)? ']' {Indent = Indent.substring(4);};

Produces:

<pre>

=={{header|Apex}}==

JSON serialization and deserialization is built in

String foo {get;set;}

Integer bar {get;set;}

//"testObj.foo == deserializedObject.foo" is true

//"testObj.bar == deserializedObject.bar" is true

 

=={{header|Arturo}}==

 

 

name: "john"

surname: "doe"

number: 10

street: "unknown"

country: "Spain"

married: false

 

 

{{out}}

 

{

"name": "john",

A full roundtrip from JSON file over a Bracmat internal representation back to a JSON file looks like this:

 

 

Let us split this into separate steps.

To read a JSON file "myfile.json", use

 

 

If the JSON data, e.g, an array, has to be read from a string value, use the <code>MEM</code> option on the <code>get</code> function, like this:

 

 

To convert the corresponding Bracmat data structure <code>(,1 2 3)</code> back to a JSON string, use

 

 

To write a JSON string <code>"[1,2,3]"</code> to a file "array.json", use

 

 

Bracmat and JSON/Javascript do far from represent data in similar ways.

Bracmat has no Boolean values <code>true</code> and <code>false</code> and no <code>null</code> value.

Bracmat has arrays and objects, but they are second class citizens. Most data is best represented as binary tree structures, with binary operators like the plus, comma, dot or white space sitting in the nodes and the atomic parts of the data sitting in the leaves.

Here is a full round trip of the following JSON data, which is assumed to be stored in a file "rosetta.json".

The employed code is:

( get$("rosetta.json",JSN):?json

& lst$(json,"json.bra",NEW)

& put$(jsn$!json,"rosetta-roundtrip.json",NEW)

 

rosetta.json:

Reads a snippet of JSON into [https://github.com/lloyd/yajl YAJL's] tree format, then walks the tree to print it back out again. The tree contains numbers both in an unparsed, string form, and also converted to long long or double when possible. The example below demonstrates both ways of dealing with numbers.

 

#include <stdlib.h>

#include <string.h>

 

return EXIT_SUCCESS;

 

{{out}}

This uses the [http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer(v=VS.90).aspx JavaScriptSerializer] class which was shipped with .NET 3.5.

 

using System.Collections.Generic;

using System.Web.Script.Serialization;

Console.WriteLine(array[1]);

}

 

=={{header|C++}}==

{{libheader|U++}}

 

 

using namespace Upp;

Cout() << v[i]["name"] << ' ' << v[i]["phone"] << '\n';

}

 

C++11 {{libheader|nlohmann&#58;&#58;json}}

#include <iomanip> // std::setw

#include <sstream>

return 0;

}

 

=={{header|Caché ObjectScript}}==

 

Class Sample.JSON [ Abstract ]

{

 

}

{{out|Examples}}

<pre>

=={{header|Clojure}}==

Library: [https://github.com/clojure/data.json data.json]

 

; Load as Clojure data structures and bind the resulting structure to 'json-map'.

 

; Pretty-print the Clojure representation of JSON. We've come full circle.

 

=={{header|CoffeeScript}}==

sample =

blue: [1, 2]

console.log json_string

console.log json_obj

 

=={{header|Common Lisp}}==

Library: [https://github.com/hankhero/cl-json cl-json]

(ql:quickload '("cl-json"))

 

(json:decode-json s)))

 

 

<pre>To load "cl-json":

 

=={{header|Crystal}}==

 

class Foo

puts(foo.to_json)

end

 

 

=={{header|D}}==

void main() {

auto j = parseJSON(`{ "foo": 1, "bar": [10, "apples"] }`);

writeln(toJSON(&j));

<pre>{"foo":1,"bar":[10,"apples"]}</pre>

 

=={{header|Dart}}==

 

main(){

assert(as_json_text == '{"compiled":true,"interpreted":true,"creator(s)":["Lars Bak","Kasper Lund"],"development company":"Google"}');

}

 

{{out}}

 

{{trans|JavaScript}}

 

main(){

var json_string = jsonEncode(sample);

}

=={{header|Delphi}}==

{{Trans|C#}}

program JsonTest;

 

Readln;

end.

 

{{out}}

=={{header|EchoLisp}}==

The '''json''' library allows to import/export basic JSON types (string ,numbers, arrays) and to translate EchoLisp objects (lists, dates, ..) from/to JSON objects and types. See reference documentation [[http://www.echolalie.org/echolisp/help.html#export-json]].

;; JSON standard types : strings, numbers, and arrays (vectors)

(export-json #(6 7 8 9)) → "[6,7,8,9]"

→ # (simon 🎩)

 

 

 

 

Structures used both to construct and to parse JSON strings:

person person;

relationships relationship[]?;

relationshipType string;

id int;

 

Construct JSON string:

people.appendElement(new Person { firstName = "Frederick", lastName = "Flintstone", age = 35} );

 

// Show JSON string

 

{{out|Raw Output}}

 

Parse JSON:

family Dictionary;

jsonLib.convertFromJSON(jsonString, family);

end

 

 

{{out}}

The examples above illustrate that it is possible to perform manual conversions to and from a JSON format but in EGL it is much more common for the programming language to handle these conversion automatically as a natural part of service invocations. Below is an example of a function definition designed to consume the Google Maps Geocoding service. The results are returned in a JSON format and parsed by EGL into records that mirror the structure of the reply.

 

function geocode(address String) returns (GoogleGeocoding) {

@Resource{uri = "binding:GoogleGeocodingBinding"},

SysLib.writeStdout(result.results[1].geometry.location.lat);

SysLib.writeStdout(result.results[1].geometry.location.lng);

 

=={{header|Elena}}==

ELENA 4.x

import extensions'dynamic;

console.printLine("json.foo=",o.foo);

console.printLine("json.bar=",o.bar)

{{out}}

<pre>

 

=={{header|Emacs Lisp}}==

 

{{out}}

 

=={{header|Erlang}}==

Use the JSON library for Erlang (mochijson) from [https://github.com/mochi/mochiweb/blob/master/src/mochijson.erl mochiweb]. The JSON code is extracted from [http://en.wikipedia.org/wiki/JSON#JSON_example wikipedia]

-module(json).

-export([main/0]).

io:format("JSON -> Erlang\n~p\n",[mochijson:decode(JSON)]),

io:format("Erlang -> JSON\n~s\n",[mochijson:encode(Erlang)]).

 

{{out}}

 

1. Using Json.Net

open Newtonsoft.Json

type Person = {ID: int; Name:string}

let xs1 = JsonConvert.DeserializeObject<Person list>(json)

xs1 |> List.iter(fun x -> printfn "%i %s" x.ID x.Name)

 

Print:

1 First

2 Second

2. Using FSharp.Data

open FSharp.Data.JsonExtensions

 

| JsonValue.Array(x) -> x |> Array.map(fun x -> {ID = System.Int32.Parse(string x?ID); Name = (string x?Name)})

| _ -> failwith "fail json"

Print:

{

"ID": 1,

1 "First"

2 "Second"

3. Alternative way of parsing: JsonProvider

type Person = {ID: int; Name:string}

type People = JsonProvider<""" [{"ID":1,"Name":"First"},{"ID":2,"Name":"Second"}] """>

People.GetSamples()

|> Array.map(fun x -> {ID = x.Id; Name = x.Name} )

1 First

2 Second

 

=={{header|Factor}}==

USING: json.writer json.reader ;

 

! Create a new data structure and serialize into JSON

{ { "blue" { "ocean" "water" } } >json

 

=={{header|Fantom}}==

 

using util

 

}

}

 

{{out}}

"ocean":{"water":["cold","blue"]}}

</pre>

 

=={{header|Fortran}}==

</pre>

 

program json_fortran

use json_module

 

end program json_fortran

 

=={{header|FunL}}==

Built-in <code>println()</code> also produces JSON conformant output.

This method only uses built-in functions but is comparatively slow.

 

Using module <code>json</code> gives better performance and also pretty prints the JSON output.

 

 

{{out}}

}

</pre>

 

=={{header|Go}}==

Example below shows simple correspondence between JSON objects and Go maps, and shows that you don't have to know anything about the structure of the JSON data to read it in.

 

import "encoding/json"

fmt.Println(err)

}

{{out}}

<pre>

</pre>

Example below demonstrates more typical case where you have an expected correspondence between JSON data and some composite data types in your program, and shows how the correspondence doesn't have to be exact.

 

import "encoding/json"

fmt.Println(string(jData))

}

{{out}}

<pre>

]

</pre>

 

=={{header|Gosu}}==

Gosu consumes JSON as a Dynamic type via this core API:

gw.lang.reflect.json.Json#fromJson( String json ) : javax.script.Bindings

As the signature of the method suggests, you pass in a JSON string and receive standard script Bindings in return. Bindings is basically a map mirroring the tree structure of the JSON object. Internally Gosu supports any Bindings instance as a Dynamic Expando object. Essentially this means you can directly cast any Bindings instance to Dynamic and treat it as an Expando.

 

 

Sample Person JSON (from http://gosu-lang.github.io/data/person.json):

"Name": "Dickson Yamada",

"Age": 39,

]

}

And the dynamic Gosu code to access it:

var personUrl = new URL( "http://gosu-lang.github.io/data/person.json" )

var person: Dynamic = personUrl.JsonContent

print( person.Name )

Notice the JsonContent property on URL:

personUrl.JsonContent

This is a convenient enhancement property Gosu provides for Java’s URL class. It does all the work to get the JSON text and calls the new Json#fromJson() method for you. It also declares the Dynamic type for you as its return type, so the declared Dynamic type on the person var is unnecessary; it’s there to clearly demonstrate that the person var is indeed Dynamic.

 

 

Here’s how we make the previous example work statically:

print( person.toStructure( "Person", false ) )

Gosu enhances Bindings with the method, toStructure( name: String, mutable: boolean ). Note the resulting structure is optionally mutable via the mutable argument. This method generates the complete nesting of types plus convenient factory methods:

structure Person {

static function fromJson( jsonText: String ): Person {

}

}

The Person structure reflects the JSON object’s implied type nesting. You can do whatever you like with this type. You can embed it as an inner structure in an existing class or make a top-level type. In any case all the types in the JSON object are uniquely preserved in one structure. Use it like this:

var person = Person.fromJsonUrl( personUrl )

print( person.Name )

print( person.Address.City )

print( person.Hobby[0].Name )

All statically verified and fully code completion friendly!

Other features:

print( person.toJson() ) // toJson() generates the Expando bindings to a JSON string

print( person.toGosu() ) // toGosu() generates any Bindings instance to a Gosu Expando initializer string

print( person.toXml() ) // toXml() generates any Bindings instance to standard XML

And similar to JavaScript, you can directly evaluate a Gosu Expando initializer string:

var clone = eval( person.toGosu() )

 

=={{header|Groovy}}==

Note that JsonSlurper accepts an extra comma such as [1,2,3,]. This is an extension to the [[http://www.json.org/fatfree.html JSON grammar]].

 

def result = slurper.parseText('''

{

]

}

 

Test:

 

assert result.people[0].name == [family:'Flintstone', given:'Frederick']

assert result.people[3].name == [family:'Rubble', given:'Elisabeth']

assert Eval.x(result, 'x.' + result.people[2].relationships.wife + '.name') == [family:'Rubble', given:'Elisabeth']

 

{{out}}

 

=={{header|Halon}}==

 

$sample = ["blue" => [1, 2], "ocean" => "water"];

 

=={{header|Harbour}}==

Parse JSON string into the ''arr'' variable:

{{out}} the JSON representation of an array ''arr'':

? hb_jsonEncode( arr )

// The output is:

 

=={{header|Haskell}}==

Uses the Aeson library from hackage (http://hackage.haskell.org/package/aeson).

 

{-# LANGUAGE OverloadedStrings #-}

 

Right v | otherwise -> print v

 

 

An example using Aeson and TemplateHaskell. Note that it can handle the absence of keys.

{-# LANGUAGE TemplateHaskell, OverloadedStrings #-}

import Data.Aeson

print (decode test1 :: Maybe Person)

print (decode test2 :: Maybe Person)

 

An example using Aeson and GHC.Generics. Note that it can handle the absence of keys.

{-# LANGUAGE DeriveGeneric, OverloadedStrings #-}

import Data.Aeson

print (decode test1 :: Maybe Person)

print (decode test2 :: Maybe Person)

 

=={{header|Hoon}}==

|= [^ [in=@tas ~] ~]

:- %noun

=. age.o +(age.o) :: increment its age...

%: crip %: pojo :: pretty-print result

 

Usage: Put code in gen/json.hoon

'{"age":5,"name":"pojo"}'

</pre>

 

=={{header|J}}==

Here is a minimal implementation based on [http://www.jsoftware.com/pipermail/chat/2007-April/000462.html an old email message].

 

NB. 0: whitespace

NB. 1: "

jsonSer0=: '"', jsonEsc@:":, '"'"_

jsonEsc=: rplc&(<;._1' \ \\ " \"')

 

Example use:

 

┌────────────────┐

│┌──────┬───────┐│

└──────────────────────────────┘

jsonSerialize jsonParse'{ "blue": [1,2], "ocean": "water" }'

 

Note that these are not strict inverses of each other. These routines allow data to be extracted from json and packed into json format, but only in a minimalistic sense. No attempts are made to preserve the subtleties of type and structure which json can carry. This should be good enough for most applications which are required to deal with json but will not be adequate for ill behaved applications which exploit the typing mechanism to carry significant information.

=={{header|Java}}==

This uses [http://code.google.com/p/google-gson/ Gson], a library to convert JSON to Java objects and vice-versa.

 

public class JsonExample {

}

 

=={{header|JavaScript}}==

Requires JSON library, now present in all major browsers.

 

var sample = { "blue": [1,2], "ocean": "water" };

 

JSON is called ''JavaScript'' Object Notation, but JSON differs form JavaScript object literal. cf. [https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/JSON MDN/JSON]

=={{header|jq}}==

 

 

Here are the jq equivalents of the examples given in the section on Julia, assuming the file data.json holds the following JSON text:

{ "blue": [1,2], "ocean": "water" }

 

produces:

 

{"blue":[1,2],"ocean":"water"}

 

produces:

"{\"blue\":[1,2],\"ocean\":\"water\"}"

 

=={{header|Jsish}}==

Jsish interactive: see 'help [cmd]'

# var data = JSON.parse('{ "foo": 1, "bar": [10, "apples"] }');

 

# puts(JSON.stringify(sample))

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

using JSON

 

@assert jsonstring == "{\"ocean\":\"water\",\"blue\":[1,2]}"

@assert jsonobj == Dict("ocean" => "water", "blue" => [1, 2])

 

=={{header|Kotlin}}==

We use Kotlin JS here to obtain access to the JavaScript JSON object:

 

data class JsonObject(val foo: Int, val bar: Array<String>)

val data2 = JsonObject2("water", arrayOf(1, 2))

println(JSON.stringify(data2))

 

{{out}}

 

=={{header|Lasso}}==

local(mymap = map(

'success' = true,

'<br />'

 

 

=={{header|LFE}}==

 

===Encoding===

(: jiffy encode (list 1 2 3 '"apple" 'true 3.14))

 

The result from that can be made a little more legible with the following:

(: erlang binary_to_list

(: jiffy encode (list 1 2 3 '"apple" 'true 3.14)))

 

===Decoding===

We can run the encoding example in reverse, and get back what we put in above with the following:

(: jiffy decode '"[1,2,3,[97,112,112,108,101],true,3.14]")

 

Here's a key-value example:

(: jiffy decode '"{\"foo\": [1, 2, 3]}")

 

===Decoding to Patterns===

We can also extract the key and value using Erlang patterns:

(let (((tuple (list (tuple key value)))

(: jiffy decode '"{\"foo\": [1, 2, 3]}")))

(: io format '"~p: ~p~n" (list key value)))

 

=={{header|Lingo}}==

 

JavaScript movie script "JSON":

// Simple (unsafe) JSON decoder based on eval()

// @param {string} json

return hash[c]

});

 

-- JSON encoder

-- Supported Lingo data types: VOID, integer, float, string, symbol, list, propList

delete the last char of str

return str

 

Usage:

42,\

3.14159,\

-- [42, 3.1416, [2, 4, #fooBar, "apples", "bananas", "cherries"], ["foo": 1, #bar: <Void>, "Hello": "world!"], <Void>]

put data_decoded

 

=={{header|Lua}}==

Using the [http://www.eharning.us/wiki/luajson/ luajson] library:

 

 

local json_data = [=[[

}

 

 

To manually insert a <code>null</code> value in the JSON output,

use the <code>json.util.null</code> function.

=={{header|M2000 Interpreter}}==

We use a class written in M2000 for Json [[M2000 Interpreter Json Class]] in a module LIB1

MODULE A {

\\ Process data in json format

// call A

A

 

=={{header|Maple}}==

[table(["tree" = "maple", "count" = 21])]

> JSON:-ToString( [table(["tree" = "maple", "count" = 21])] );

 

 

=={{header|MATLAB}} / {{header|Octave}}==

ans =

struct with fields:

>> jsonencode(ans)

ans =

The toolbox [http://iso2mesh.sourceforge.net/cgi-bin/index.cgi?jsonlab/Download JSONlab] is doing a nice job to read (loadjson.m) and write (savejson.m) data in JSON format.

 

===json.org Library===

This uses a library provided by [http://www.json.org/java/index.html json.org] to serialize/deserialize JSON objects.

options replace format comments java crossref symbols nobinary

 

ts.append(']')

return ts.toString()

{{out}}

<pre>

===Google gson Library===

This uses [http://code.google.com/p/google-gson/ Gson], a library to convert JSON to Java objects and vice-versa.

options replace format comments java crossref symbols nobinary

 

ts.append(']')

return ts.toString()

{{out}}

<pre>

 

=={{header|Nim}}==

 

var data = parseJson("""{ "foo": 1, "bar": [10, "apples"] }""")

 

var js = %* [{"name": "John", "age": 30}, {"name": "Susan", "age": 31}]

{{out}}

<pre>1

 

=={{header|Objeck}}==

use Struct;

use JSON;

}

}

 

=={{header|Objective-C}}==

{{works with|Mac OS X|10.7+|Xcode 4.4+}}

id obj = [NSJSONSerialization

JSONObjectWithData: [jsonString dataUsingEncoding: NSUTF8StringEncoding]

encoding: NSUTF8StringEncoding];

NSLog(@"%@", jsonString2);

 

=={{header|OCaml}}==

{{libheader|json-static}}

 

< name "Name": string;

kingdom "Kingdom": string;

let () =

let j = Json_io.json_of_string str in

 

compile with:

{{libheader|yojson}}

 

 

let s = "

let () =

let json = Yojson.Basic.from_string s in

 

Compile and run:

A Json object can be converted to a string using #asString

 

[1] (Json) {"parents" : ["Otmar Gutmann", "Silvio Mazzola"], "name" : "Pingu", "born" : 1986 }

ok

[1] (Json) {"parents" : ["Otmar Gutmann", "Silvio Mazzola"], "name" : "Pingu", "born" : 1986 }

ok

 

=={{header|Ol}}==

Ol comes with library that provides JSON parsing and forming.

 

(import (file json))

 

}

]

 

{{out}}

=={{header|OpenEdge/Progress}}==

The WRITE-JSON and READ-JSON methods were introduced in Progress OpenEdge 10.2B.

DEFINE VARIABLE lcjson AS LONGCHAR NO-UNDO.

 

example.blue [1] example.blue [2] SKIP

example.ocean

 

{{out}} write-json:

=={{header|Oz}}==

Using the [http://code.google.com/p/oz-code/downloads/list google.com/oz-code] JSON library:

[JSON] = {Module.link ['JSON.ozf']}

 

 

Sample = object(blue:array(1 2) ocean:"water")

 

{{out}}

<pre>object(bar:array(10 [97 112 112 108 101 115]) foo:1)

{"blue":[1,2],"ocean":"water"}</pre>

 

=={{header|Perl}}==

{{libheader|JSON}}

 

my $data = decode_json('{ "foo": 1, "bar": [10, "apples"] }');

 

my $sample = { blue => [1,2], ocean => "water" };

 

=={{header|Phix}}==

The distribution now contains a simple json module

{{out}}

<pre>

 

=={{header|PHP}}==

$data = json_decode('{ "foo": 1, "bar": [10, "apples"] }'); // dictionaries will be returned as objects

$data2 = json_decode('{ "foo": 1, "bar": [10, "apples"] }', true); // dictionaries will be returned as arrays

$sample = array( "blue" => array(1,2), "ocean" => "water" );

$json_string = json_encode($sample);

 

=={{header|PicoLisp}}==

PicoLisp has no JSON library, but it is easy enough to write one. The following supports only fixpoint numbers (no floating point, as it doesn't exist in PicoLisp). Arrays and objects are both mapped to lists.

(unless (= X Item)

(quit "Bad JSON" Item) ) )

(and (cdr X) (prin ", ")) )

Item )

This reads/prints JSON from/to files, pipes, sockets etc. To read from a string, a pipe can be used:

<pre>: (pipe (prinl "{ \"foo\": 1, \"bar\": [10, \"apples\"] }")

 

=={{header|Pike}}==

// Decoding

string json = "{\"cake\":[\"desu\",1,2.3],\"foo\":1}";

write("%s\n", Standards.JSON.encode(m));

 

<pre>([ /* 2 elements */

 

=={{header|PowerShell}}==

# JSON input is being stored in ordered hashtable.

# Ordered hashtable is available in PowerShell v3 and higher.

# If you use the Invoke-RestMethod cmdlet there is not need for the ConvertFrom-Json cmdlet

Invoke-WebRequest -Uri "http://date.jsontest.com" | ConvertFrom-Json

{{out}}

{

"foo": 1,

---- ------------------------ ----

12:25:25 PM 1414326325923 10-26-2014

 

=={{header|Prolog}}==

Using SWI-Prolog 7's library(http/json), and the new dict datatype, there is nearly transparent handling of JSON objects. All of the serialization and parsing in the following code is accomplished with two predicates. The rest of the code is for the sake of example.

 

library(func) ]).

 

year:1985

}},

 

{{out}} from these two example predicates:

JSON as Prolog dict: _G5217{widget:_G5207{debug:on,image:_G5123{alignment:center,hOffset:250,name:sun1,src:Images/Sun.png,vOffset:250},text:_G5189{alignment:center,data:Click Here,hOffset:250,name:text1,onMouseUp:sun1.opacity = (sun1.opacity / 100) * 90;,size:36,style:bold,vOffset:100},window:_G5077{height:500,name:main_window,title:Sample Konfabulator Widget,width:500}}}

 

}

}

 

=={{header|PureBasic}}==

If CreateJSON(1)

PB_Team_Members=SetJSONObject(JSONValue(1))

PrintN(Mid(PB_Special_thanks$,JSONErrorPosition()+1))

EndIf

{{out}}

<pre>PureBasic - Team Members:

=={{header|Python}}==

{{works with|Python|2.6+}}{{works with|Python|3.0+}}

>>> data = json.loads('{ "foo": 1, "bar": [10, "apples"] }')

>>> sample = { "blue": [1,2], "ocean": "water" }

{'blue': [1, 2], 'ocean': 'water'}

>>> data

 

Because most of JSON is valid Python syntax (except "true", "false", and "null", and a few obscure escape sequences), it is also possible (but not recommended) to parse JSON using eval():

>>> data = eval('{ "foo": 1, "bar": [10, "apples"] }')

>>> data

 

=={{header|R}}==

data <- fromJSON('{ "foo": 1, "bar": [10, "apples"] }')

<pre>data

$foo

[1] "apples"

</pre>

<pre>{"foo":1,"bar":[10,"apples"]}</pre>

 

=={{header|Racket}}==

#lang racket

 

 

(write-json '(1 2 "three" #hash((x . 1) (y . 2) (z . 3))))

 

=={{header|Raku}}==

Using [http://github.com/moritz/json/ JSON::Tiny]

 

 

 

=={{header|REBOL}}==

Using [http://www.json.org/json.r json.org/json.r]

 

"id": "file",

"string": "File:",

res: json-to-rebol json-str

js: rebol-to-json res

 

json-to-rebol Result:

 

=={{header|Ruby}}==

 

ruby_obj = JSON.parse('{"blue": [1, 2], "ocean": "water"}')

ruby_obj["ocean"] = { "water" => ["fishy", "salty"] }

puts JSON.generate(ruby_obj)

 

{{out}}

{{works with|Rust|1.31}}

{{libheader|Serde|1.0}}

serde = { version = "1.0", features = ["derive"] }

 

Serde is a general serialization/deserialization library. Serde-JSON implements JSON serialization for Serde.

Using said library is quite straight forward, one simply derives <code>Serialize</code>/<code>Deserialize</code> onto the types they want to convert into and from JSON strings.

 

 

#[derive(Serialize, Deserialize, Debug)]

x: i32,

y: i32,

 

Said type could then be used as such:

 

let point = Point { x: 1, y: 2 };

 

println!("serialized = {}", serialized);

println!("deserialized = {:?}", deserialized);

 

The result of which is type-checked JSON (where extra entries get ignored), without need of a key-value container.

It also handles more Rust specific types like enums, tuples, struct tuples, and zero-sized types.

 

struct W { a: i32, b: i32 } // => { "a": 0, "b": 0 }

 

Y(i32), // => { "Y": 0 }

Z, // => { "Z" }

 

The traits are also implemented for <code>HashMap</code> and <code>Vec</code> which can be used as conventional objects/arrays, on top of macros and <code>serde_json::Value</code> to handle all other potentially weird edge cases.

 

use serde_json::Value;

 

#[serde(flatten)]

metadata: HashMap<String, Value>,

 

In this example <code>metadata</code> would simply capture all other additional entries, for example:

 

let data = {

let mut metadata = HashMap::new();

println!("serialized = {}", serialized);

println!("deserialized = {:?}", deserialized);

{{out}}

<pre>serialized = {"points":[{"x":1,"y":2},{"x":15,"y":32}],"square":false,"triangle":3}

Using the builtin parsing lib (debatably slower than third-party libs such as lift-json from Liftweb).

 

import scala.util.parsing.json.{JSON, JSONObject}

 

scala> JSONObject(Map("foo" -> "bar")).toString()

res1: String = {"foo" : "bar"}

 

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

(use json)

(define object-example

; this writes the following:

; {"foo": "bar", "baz": [1, 2, 3], "qux": {"foo": "bar"}}

 

=={{header|SenseTalk}}==

put JSONValue(jsonString)

 

set dataObject to (string_value: "lorem ipsum", int_value: 314, array_value: (2, 4, 6))

 

=={{header|Sidef}}==

{{out}}

{"blue":[1,2],"ocean":{"water":["fishy","salty"]}}</pre>

 

=={{header|Smalltalk}}==

Use the NeoJSON library: [http://smalltalkhub.com/#!/~SvenVanCaekenberghe/Neo NeoJSON]

NeoJSONReader fromString: '{ "foo": 1, "bar": [10, "apples"] }'.

 

{{out}}

=={{header|Standard ML}}==

Works on Unix/Linux/BSD with jq (github.com/stedolan/jq/ ) installed. Data storage in strings, so floating point numbers can be written back as received, in a recursive polymorphic structure, which can also be used to store the data as SML-types. (Without Jq on the system or on Microsoft systems, delete the Validate function and its call, and the code can be used for valid JSON-strings without any white space outside strings (only).)

val Validate = fn jsonstring =>

let

 

end ;

val testString="{\"firstName\":\"John\",\"lastName\":\"Smith\",\"age\":25,\"address\":{\"streetAddress\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"postalCode\":\"10021\"},\"phoneNumber\":[{\"type\":\"home\",\"numbers\":[{\"o\":\"212 555-1234\",\"h\":\"119 323-1234\"}]},{\"type\":\"fax\",\"number\":\"646 555-4567\"}]}" ;

 

elem (St "postalCode", value (St "10021"))]):

(jvals, jvals content) element

 

=={{header|Swift}}==

 

let jsonString = "{ \"foo\": 1, \"bar\": [10, \"apples\"] }"

print("JSON: \(jsonString2)")

}

{{out}}

<pre>

=={{header|Tailspin}}==

A JSON parser and printer can fairly easily be created

// Not all JSON object member keys can be represented, a fallback would need to be implemented

// Currently Tailspin only supports integers so for now we leave numbers as strings, as we do for true, false and null

templates hexToInt

templates hexDigit

<'[Aa]'> 10! <'[Bb]'> 11! <'[Cc]'> 12! <'[Dd]'> 13! <'[Ee]'> 14! <'[Ff]'> 15!

end hexDigit

rule value: (<WS>?) <string|number|object|array|true|false|null> (<WS>?)

 

rule chars: [ <quote|backslash|slash|backspace|formfeed|linefeed|return|tab|unicode|'[^"]'>* ] -> '$...;'

 

rule number: <'-?(0|[1-9][0-9]*)(\.[0-9]+)?((e|E)(\+|-)?[0-9]+)?'> // TODO: represent this other than string

 

rule keyValues: <keyValue> <followingKeyValue>*

 

rule arrayValues: <value> <followingArrayValue>*

 

end jsonParser

 

end printKeyValue

templates encodeChars

<> $ !

end encodeChars

when <{}> do

[ $... ] -> '{$(1) -> printKeyValue;$(2..last)... -> ', $ -> printKeyValue;';}' !

'$;'!

[ $... -> encodeChars ] -> '"$...;"' !

otherwise 'WTF!' !

// Other types do not yet exist in Tailspin

end printJson

'{ "foo": 1, "bar": [10, "apples"] }' -> jsonParser -> '$.bar(2);

' -> !OUT::write

{ blue: [1,2], ocean: 'water' } -> printJson -> '$;

' -> !OUT::write

{{out}}

<pre>

apples

{"blue": [1, 2], "ocean": "water"}

</pre>

 

=={{header|Tcl}}==

For parsing JSON, {{tcllib|json}} provides the capability (see [http://wiki.tcl.tk/13419 the Tcler's Wiki page on it] for more discussion):

set sample {{ "foo": 1, "bar": [10, "apples"] }}

 

set parsed [json::json2dict $sample]

{{out}}

<pre>foo 1 bar {10 apples}</pre>

{{works with|Tcl|8.6}}

{{tcllib|json::write}}

package require json::write

 

}

}

Sample code (note that the value is built with <code>dict create</code> and <code>list</code> so that there is some auxiliary type hints available, which the above procedure can read):

{{out}}

<pre>

=={{header|TXR}}==

 

 

 

 

The parser translates to a nested list structure in which the types are labeled with the strings "O", "A", "N", "S" and "K". (Object, array, number, string, and keyword).

The largest grammar rule handles JSON string literals. The strategy is to generate a HTML string and then filter from HTML using the <code>:from_html</code> filter in TXR. For instance \uABCD is translated to <code>&amp;#xABCD;</code> and then the filter will produce the proper Unicode character. Similarly \" is translated to <code>&amp;quot;</code> and \n is translated to &#10; etc.

 

 

Superfluous terminating commas (not generated by the JSON grammar but accepted by some other parsers) are not allowed by this parser.

 

@(cases)@\

@(string v)@(or)@(num v)@(or)@(object v)@(or)@\

@(end)

@(freeform)

 

A few tests. Note, the <code>badsyntax</code> variable is bound to any trailing portion of the input that does not match the syntax. The call to the parser <code>@(value v)</code> extracts the longest prefix of the input which is consistent with the syntax, leaving the remainder to be matched into <code>badsyntax</code>.

 

(v "O" ((("S" "a") ("O" ((("S" "b") ("N" "3")) (("S" "c") ("A" (("N" "1") ("N" "2") ("N" "3")))))))))

(badsyntax . "[\n")

$ echo -n '"\u1234"' | ./txr -l json.txr -

(v "S" "\11064")

 

=={{header|Wren}}==

{{libheader|Wren-json}}

 

var s = "{ \"foo\": 1, \"bar\": [ \"10\", \"apples\"] }"

o = { "blue": [1, 2], "ocean": "water" }

s = JSON.stringify(o)

 

{{out}}

 

The XPath 3.1 standard specifies an XML format to store JSON information. Different XQuery processors implement their own JSON parsers in addition to the XPath functions. One such function has been added, to show, how to map JSON into an XPath map using the BaseX processor. As XQuery is a superset of XPath, the following code is valid XQuery 3.1. Except for 'null', which does not exist in the XPath data model, all JSON datatypes have their XPath equivalent. 'Null' is being represented by the empty sequence. This gets shown at the last function invocation, which creates an XPath map. It may be interesting to note, that the different options for the json serializers and parsers have not been used here.

let $json := '

{

)

 

 

Result:

 

To convert from JSON to zkl:

var [const] YAJL=a, toJSON=b;

src:=

obj:=YAJL().write(src).close();

// or obj:=src.pump(YAJL()).close(); // for example, from file or socket

{{out}}

<pre>

</pre>

From zkl to JSON:

{{out}}

<pre>{"pi":3.1400000000,"an array":[-1,true,false,null,"foo"],"large number":123456789123456791}