An empty Object matches any object

{}                @> {} == True
{"a":1,"b":false} @> {} == True

Any key-value will be matched top-level

{"a":1,"b":{"c":true"}} @> {"a":1}         == True
{"a":1,"b":{"c":true"}} @> {"b":1}         == False
{"a":1,"b":{"c":true"}} @> {"b":{}}        == True
{"a":1,"b":{"c":true"}} @> {"c":true}      == False
{"a":1,"b":{"c":true"}} @> {"b":{c":true}} == True

An empty Array matches any array

[]                    @> [] == True
[1,2,"hi",false,null] @> [] == True

Any array has to be a sub-set. Any object or array will also be compared as being a subset of.

[1,2,"hi",false,null] @> [1]                       == True
[1,2,"hi",false,null] @> [null,"hi"]               == True
[1,2,"hi",false,null] @> ["hi",true]               == False
[1,2,"hi",false,null] @> ["hi",2,null,false,1]     == True
[1,2,"hi",false,null] @> [1,2,"hi",false,null,{}]  == False

Arrays and objects inside arrays match the same way they'd be matched as being on their own.

[1,"hi",[false,3],{"a":[null]}] @> [{}]            == True
[1,"hi",[false,3],{"a":[null]}] @> [{"a":[]}]      == True
[1,"hi",[false,3],{"a":[null]}] @> [{"b":[null]}]  == False
[1,"hi",[false,3],{"a":[null]}] @> [[]]            == True
[1,"hi",[false,3],{"a":[null]}] @> [[3]]           == True
[1,"hi",[false,3],{"a":[null]}] @> [[true,3]]      == False

A regular value has to be a member

[1,2,"hi",false,null] @> 1      == True
[1,2,"hi",false,null] @> 5      == False
[1,2,"hi",false,null] @> "hi"   == True
[1,2,"hi",false,null] @> false  == True
[1,2,"hi",false,null] @> "2"    == False

An object will never match with an array

[1,2,"hi",[false,3],{"a":null}] @> {}          == False
[1,2,"hi",[false,3],{"a":null}] @> {"a":null}  == False

For any other JSON values the (\@>.) operator functions like an equivalence operator.

"hello" @> "hello"     == True
"hello" @> "Hello"     == False
"hello" @> "h"         == False
"hello" @> {"hello":1} == False
"hello" @> ["hello"]   == False

5       @> 5       == True
5       @> 5.00    == True
5       @> 1       == False
5       @> 7       == False
12345   @> 1234    == False
12345   @> 2345    == False
12345   @> "12345" == False
12345   @> [1,2,3,4,5] == False

true    @> true    == True
true    @> false   == False
false   @> true    == False
true    @> "true"  == False

null    @> null    == True
null    @> 23      == False
null    @> "null"  == False
null    @> {}      == False

{"a":null}             ? "a"  == True
{"test":false,"a":500} ? "a"  == True
{"b":{"a":[]}}         ? "a"  == False
{}                     ? "a"  == False
{}                     ? "{}" == False
{}                     ? ""   == False
{"":9001}              ? ""   == True

This operator will match an array if the string to be matched is an element of that array, but nothing else.

["a"]              ? "a"   == True
[["a"]]            ? "a"   == False
[9,false,"1",null] ? "1"   == True
[]                 ? "[]"  == False
[{"a":true}]       ? "a"   == False

This operator functions like an equivalence operator on strings only. Any other value does not match.

"a"  ? "a"    == True
"1"  ? "1"    == True
"ab" ? "a"    == False
1    ? "1"    == False
null ? "null" == False
true ? "true" == False
1.5  ? "1.5"  == False

{"a":null}                 ?| ["a","b","c"] == True
{"test":false,"a":500}     ?| ["a","b","c"] == True
{}                         ?| ["a","{}"]    == False
{"b":{"a":[]}}             ?| ["a","c"]     == False
{"b":{"a":[]},"test":null} ?| []            == False

This operator will match an array if any of the elements of the list are matching string elements of the array.

["a"]              ?| ["a","b","c"] == True
[["a"]]            ?| ["a","b","c"] == False
[9,false,"1",null] ?| ["a","false"] == False
[]                 ?| ["a","b","c"] == False
[]                 ?| []            == False
[{"a":true}]       ?| ["a","b","c"] == False
[null,4,"b",[]]    ?| ["a","b","c"] == True

This operator functions much like an equivalence operator on strings only. If a string matches with any element of the given list, the comparison matches. No other values match.

"a"  ?| ["a","b","c"] == True
"1"  ?| ["a","b","1"] == True
"ab" ?| ["a","b","c"] == False
1    ?| ["a","1"]     == False
null ?| ["a","null"]  == False
true ?| ["a","true"]  == False
"a"  ?| []            == False

{"a":null}                 ?& ["a"]         == True
{"a":null}                 ?& ["a","a"]     == True
{"test":false,"a":500}     ?& ["a"]         == True
{"test":false,"a":500}     ?& ["a","b"]     == False
{}                         ?& ["{}"]        == False
{"b":{"a":[]}}             ?& ["a"]         == False
{"b":{"a":[]},"c":false}   ?& ["a","c"]     == False
{"a":1,"b":2,"c":3,"d":4}  ?& ["b","d"]     == True
{}                         ?& []            == True
{"b":{"a":[]},"test":null} ?& []            == True

This operator will match an array if all of the elements of the list are matching string elements of the array.

["a"]                   ?& ["a"]         == True
["a"]                   ?& ["a","a"]     == True
[["a"]]                 ?& ["a"]         == False
["a","b","c"]           ?& ["a","b","d"] == False
[9,"false","1",null]    ?& ["1","false"] == True
[]                      ?& ["a","b"]     == False
[{"a":true}]            ?& ["a"]         == False
["a","b","c","d"]       ?& ["b","c","d"] == True
[null,4,{"test":false}] ?& []            == True
[]                      ?& []            == True

This operator functions much like an equivalence operator on strings only. If a string matches with all elements of the given list, the comparison matches.

"a"   ?& ["a"]     == True
"1"   ?& ["a","1"] == False
"b"   ?& ["b","b"] == True
"ab"  ?& ["a","b"] == False
1     ?& ["1"]     == False
null  ?& ["null"]  == False
true  ?& ["true"]  == False
31337 ?& []        == True
true  ?& []        == True
null  ?& []        == True