jsonpointer

Calling Get with a pointer value that dereferences an array index beyond it's bounds will return an ArrayIndexOutOfBounds error. When calling set this also applies except that if the index is equal to the array length it is considered valid and performs ano": ["bar", "baz"], append. See above for the JSON data being evaluated.

pointer, _ := NewJSONPointerFromString("/foo/2")
_, err := pointer.Get(ExampleJson, -1)
fmt.Println(err)

Output:
array index 2 is beyond the array bounds.

Providing a string with an invalid escape sequence to NewJSONPointer will return a BadEscapeSequence error. See above for the JSON data being evaluated.

_, err := NewJSONPointerFromString("/foo/~2")
fmt.Print(err)

Output:
the escape sequence "~2" found in the JSON pointer "/foo/~2" is invalid

Calling Get or Set with a pointer value that dereferences an array index where the token is non-numeric will return an InvalidArrayIndex error. When calling Set this also applies except that the token "-" is evaluated to the length of the array (and thus performs an append.) See above for the JSON data being evaluated.

pointer, _ := NewJSONPointerFromString("/foo/!")
_, err := pointer.Get(ExampleJson, -1)
fmt.Println(err)

Output:
cannot index an array by the value "!"

Note that the first example is a JSON pointer to the root document, while the second example references the empty string key ("") directly under the root document.

pointer, _ := NewJSONPointerFromString("")
fmt.Println(pointer.Depth())

pointer, _ = NewJSONPointerFromString("/")
fmt.Println(pointer.Depth())

pointer, _ = NewJSONPointerFromString("/foo")
fmt.Println(pointer.Depth())

pointer, _ = NewJSONPointerFromString("/foo/bar/baz")
fmt.Println(pointer.Depth())

Output:
0
1
1
3

pointer, err := NewJSONPointerFromString("/foo")
value, err := pointer.Get(ExampleJson, -1)
fmt.Println(value, err)

pointer, err = NewJSONPointerFromString("/foo/0")
value, err = pointer.Get(ExampleJson, -1)
fmt.Println(value, err)

pointer, err = NewJSONPointerFromString("/foo/0/boom")
value, err = pointer.Get(ExampleJson, -1)
fmt.Println(value, err)

pointer, err = NewJSONPointerFromString("/foo/0/boom")
value, err = pointer.Get(ExampleJson, 2)
fmt.Println(value, err)

Output:
[bar baz] <nil>
bar <nil>
<nil> cannot index primitave value "bar"
bar <nil>

// Construct the same JSON data structure used by other examples, but since
// it will be modified we create a new instance that won't effect other
// tests.
var Json map[string]interface{}
_ = json.Unmarshal([]byte(JSONBytes), &Json)

pointer, _ := NewJSONPointerFromString("/foo/2")
value, _ := pointer.Set(Json, "qux", -1)
value, err := pointer.Get(value, 1)
fmt.Println(value, err)

// Lets see what happens with an array index greater than the length
pointer, _ = NewJSONPointerFromString("/foo/4")
_, err = pointer.Set(Json, "corge", -1)
fmt.Println(err)

// The '-' token is a special token that can only be used for Set operations
// which will always append to the end of an array.
pointer, _ = NewJSONPointerFromString("/foo/-")
_, err = pointer.Set(Json, "corge", -1)
value, _ = pointer.Get(Json, 1)
fmt.Println(value)

// Oops, that's the wrong metastatic variable!
pointer, _ = NewJSONPointerFromString("/foo/3")
_, err = pointer.Set(Json, "quux", -1)
value, _ = pointer.Get(Json, 1)
fmt.Println(value)

pointer, _ = NewJSONPointerFromString("/o@p")
_, _ = pointer.Set(Json, 9, -1)
value, err = pointer.Get(Json, -1)
fmt.Println(value)

// Finally let's engineer a situation where an append must occur on the root
// document to illustrate that in this corner case you will only see the
// changed data if you capture the returned data:
data := make([]interface{}, 2, 2)
data[0], data[1] = "bar", "baz"
pointer, _ = NewJSONPointerFromString("/2")
value, _ = pointer.Set(data, "qux", -1)
fmt.Println(data, value)

Output:
[bar baz qux] <nil>
array index 4 is beyond the array bounds.
[bar baz qux corge]
[bar baz qux quux]
9
[bar baz] [bar baz qux]

One of the likely use cases for constructing JSONPointers from string slices as is done with NewJSONPointerFromTokens would be to construct a valid JSONPointer string for a given property/index path. Here's how to do that:

pointer := NewJSONPointerFromTokens(&[]string{})
fmt.Printf("%q\n", pointer.String())

pointer = NewJSONPointerFromTokens(&[]string{""})
fmt.Printf("%q\n", pointer.String())

pointer = NewJSONPointerFromTokens(&[]string{"foo"})
fmt.Printf("%q\n", pointer.String())

pointer = NewJSONPointerFromTokens(&[]string{"foo", "bar", "baz"})
fmt.Printf("%q\n", pointer.String())

Output:
""
"/"
"/foo"
"/foo/bar/baz"

Note that the difference between the first and second example is that the first is completely empty, while the second contains one string which happens to be the empty string ("".)

pointer, _ := NewJSONPointerFromString("")
tokens := pointer.Tokens()
fmt.Println(len(tokens), tokens)

pointer, _ = NewJSONPointerFromString("/")
tokens = pointer.Tokens()
fmt.Println(len(tokens), tokens)

pointer, _ = NewJSONPointerFromString("/foo")
tokens = pointer.Tokens()
fmt.Println(len(tokens), tokens)

pointer, _ = NewJSONPointerFromString("/foo/bar/baz")
tokens = pointer.Tokens()
fmt.Println(len(tokens), tokens)

Output:
0 []
1 []
1 [foo]
3 [foo bar baz]

Calling NewJSONPointerFromString with a string that neither is the empty string nor starts with a "/" is invalid and will return a JSONPointerSyntaxError

_, err := NewJSONPointerFromString("boom")
fmt.Print(err)

Output:
"boom" is not a valid JSON pointer string representation.

Calling Get or Set with a pointer that dereferences a primitave (null/nil, boolean/bool, number/float64 or string) before exausting all tokens to be evaluated will return a UnindexableValue error. See above for the JSON data being evaluated.

pointer, _ := NewJSONPointerFromString("/foo/0/boom/big")
_, err := pointer.Set(ExampleJson, "badda", -1)
fmt.Println(err)

Output:
cannot index primitave value "bar"