# Enum serde_json::Value

source · [−]

    pub enum Value {
        Null,
        Bool(bool),
        Number(Number),
        String(String),
        Array(Vec<Value>),
        Object(Map<String, Value>),
    }

Expand description

Represents any valid JSON value.

See the `serde_json::value` module documentation for usage examples.

## Variants

### `Null`

Represents a JSON null value.

    let v = json!(null);

### `Bool(bool)`

Represents a JSON boolean.

    let v = json!(true);

### `Number(Number)`

Represents a JSON number, whether integer or floating point.

    let v = json!(12.5);

### `String(String)`

Represents a JSON string.

    let v = json!("a string");

### `Array(Vec<Value>)`

Represents a JSON array.

    let v = json!(["an", "array"]);

### `Object(Map<String, Value>)`

Represents a JSON object.

By default the map is backed by a BTreeMap. Enable the `preserve_order` feature of serde_json to use IndexMap instead, which preserves entries in the order they are inserted into the map. In particular, this allows JSON data to be deserialized into a Value and serialized to a string while retaining the order of map keys in the input.

    let v = json!({ "an": "object" });

## Implementations

source

### impl Value

source

#### pub fn get<I: Index>(&self, index: I) -> Option<&Value>

Index into a JSON array or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of an array.

Returns `None` if the type of `self` does not match the type of the index, for example if the index is a string and `self` is an array or a number. Also returns `None` if the given key does not exist in the map or the given index is not within the bounds of the array.

    let object = json!({ "A": 65, "B": 66, "C": 67 });
    assert_eq!(*object.get("A").unwrap(), json!(65));

    let array = json!([ "A", "B", "C" ]);
    assert_eq!(*array.get(2).unwrap(), json!("C"));

    assert_eq!(array.get("A"), None);

Square brackets can also be used to index into a value in a more concise way. This returns `Value::Null` in cases where `get` would have returned `None`.

    let object = json!({
        "A": ["a", "á", "à"],
        "B": ["b", "b́"],
        "C": ["c", "ć", "ć̣", "ḉ"],
    });
    assert_eq!(object["B"][0], json!("b"));

    assert_eq!(object["D"], json!(null));
    assert_eq!(object[0]["x"]["y"]["z"], json!(null));

source

#### pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value>

Mutably index into a JSON array or map. A string index can be used to access a value in a map, and a usize index can be used to access an element of an array.

Returns `None` if the type of `self` does not match the type of the index, for example if the index is a string and `self` is an array or a number. Also returns `None` if the given key does not exist in the map or the given index is not within the bounds of the array.

    let mut object = json!({ "A": 65, "B": 66, "C": 67 });
    *object.get_mut("A").unwrap() = json!(69);

    let mut array = json!([ "A", "B", "C" ]);
    *array.get_mut(2).unwrap() = json!("D");

source

#### pub fn is_object(&self) -> bool

Returns true if the `Value` is an Object. Returns false otherwise.

For any Value on which `is_object` returns true, `as_object` and `as_object_mut` are guaranteed to return the map representation of the object.

    let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });

    assert!(obj.is_object());
    assert!(obj["a"].is_object());

    // array, not an object
    assert!(!obj["b"].is_object());

source

#### pub fn as_object(&self) -> Option<&Map<String, Value>>

If the `Value` is an Object, returns the associated Map. Returns None otherwise.

    let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });

    // The length of `{"nested": true}` is 1 entry.
    assert_eq!(v["a"].as_object().unwrap().len(), 1);

    // The array `["an", "array"]` is not an object.
    assert_eq!(v["b"].as_object(), None);

source

#### pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>>

If the `Value` is an Object, returns the associated mutable Map. Returns None otherwise.

    let mut v = json!({ "a": { "nested": true } });

    v["a"].as_object_mut().unwrap().clear();
    assert_eq!(v, json!({ "a": {} }));

source

#### pub fn is_array(&self) -> bool

Returns true if the `Value` is an Array. Returns false otherwise.

For any Value on which `is_array` returns true, `as_array` and `as_array_mut` are guaranteed to return the vector representing the array.

    let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });

    assert!(obj["a"].is_array());

    // an object, not an array
    assert!(!obj["b"].is_array());

source

#### pub fn as_array(&self) -> Option<&Vec<Value>>

If the `Value` is an Array, returns the associated vector. Returns None otherwise.

    let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });

    // The length of `["an", "array"]` is 2 elements.
    assert_eq!(v["a"].as_array().unwrap().len(), 2);

    // The object `{"an": "object"}` is not an array.
    assert_eq!(v["b"].as_array(), None);

source

#### pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>>

If the `Value` is an Array, returns the associated mutable vector. Returns None otherwise.

    let mut v = json!({ "a": ["an", "array"] });

    v["a"].as_array_mut().unwrap().clear();
    assert_eq!(v, json!({ "a": [] }));

source

#### pub fn is_string(&self) -> bool

Returns true if the `Value` is a String. Returns false otherwise.

For any Value on which `is_string` returns true, `as_str` is guaranteed to return the string slice.

    let v = json!({ "a": "some string", "b": false });

    assert!(v["a"].is_string());

    // The boolean `false` is not a string.
    assert!(!v["b"].is_string());

source

#### pub fn as_str(&self) -> Option<&str>

If the `Value` is a String, returns the associated str. Returns None otherwise.

    let v = json!({ "a": "some string", "b": false });

    assert_eq!(v["a"].as_str(), Some("some string"));

    // The boolean `false` is not a string.
    assert_eq!(v["b"].as_str(), None);

    // JSON values are printed in JSON representation, so strings are in quotes.
    //
    //    The value is: "some string"
    println!("The value is: {}", v["a"]);

    // Rust strings are printed without quotes.
    //
    //    The value is: some string
    println!("The value is: {}", v["a"].as_str().unwrap());

source

#### pub fn is_number(&self) -> bool

Returns true if the `Value` is a Number. Returns false otherwise.

    let v = json!({ "a": 1, "b": "2" });

    assert!(v["a"].is_number());

    // The string `"2"` is a string, not a number.
    assert!(!v["b"].is_number());

source

#### pub fn is_i64(&self) -> bool

Returns true if the `Value` is an integer between `i64::MIN` and `i64::MAX`.

For any Value on which `is_i64` returns true, `as_i64` is guaranteed to return the integer value.

    let big = i64::max_value() as u64 + 10;
    let v = json!({ "a": 64, "b": big, "c": 256.0 });

    assert!(v["a"].is_i64());

    // Greater than i64::MAX.
    assert!(!v["b"].is_i64());

    // Numbers with a decimal point are not considered integers.
    assert!(!v["c"].is_i64());

source

#### pub fn is_u64(&self) -> bool

Returns true if the `Value` is an integer between zero and `u64::MAX`.

For any Value on which `is_u64` returns true, `as_u64` is guaranteed to return the integer value.

    let v = json!({ "a": 64, "b": -64, "c": 256.0 });

    assert!(v["a"].is_u64());

    // Negative integer.
    assert!(!v["b"].is_u64());

    // Numbers with a decimal point are not considered integers.
    assert!(!v["c"].is_u64());

source

#### pub fn is_f64(&self) -> bool

Returns true if the `Value` is a number that can be represented by f64.

For any Value on which `is_f64` returns true, `as_f64` is guaranteed to return the floating point value.

Currently this function returns true if and only if both `is_i64` and `is_u64` return false but this is not a guarantee in the future.

    let v = json!({ "a": 256.0, "b": 64, "c": -64 });

    assert!(v["a"].is_f64());

    // Integers.
    assert!(!v["b"].is_f64());
    assert!(!v["c"].is_f64());

source

#### pub fn as_i64(&self) -> Option<i64>

If the `Value` is an integer, represent it as i64 if possible. Returns None otherwise.

    let big = i64::max_value() as u64 + 10;
    let v = json!({ "a": 64, "b": big, "c": 256.0 });

    assert_eq!(v["a"].as_i64(), Some(64));
    assert_eq!(v["b"].as_i64(), None);
    assert_eq!(v["c"].as_i64(), None);

source

#### pub fn as_u64(&self) -> Option<u64>

If the `Value` is an integer, represent it as u64 if possible. Returns None otherwise.

    let v = json!({ "a": 64, "b": -64, "c": 256.0 });

    assert_eq!(v["a"].as_u64(), Some(64));
    assert_eq!(v["b"].as_u64(), None);
    assert_eq!(v["c"].as_u64(), None);

source

#### pub fn as_f64(&self) -> Option<f64>

If the `Value` is a number, represent it as f64 if possible. Returns None otherwise.

    let v = json!({ "a": 256.0, "b": 64, "c": -64 });

    assert_eq!(v["a"].as_f64(), Some(256.0));
    assert_eq!(v["b"].as_f64(), Some(64.0));
    assert_eq!(v["c"].as_f64(), Some(-64.0));

source

#### pub fn is_boolean(&self) -> bool

Returns true if the `Value` is a Boolean. Returns false otherwise.

For any Value on which `is_boolean` returns true, `as_bool` is guaranteed to return the boolean value.

    let v = json!({ "a": false, "b": "false" });

    assert!(v["a"].is_boolean());

    // The string `"false"` is a string, not a boolean.
    assert!(!v["b"].is_boolean());

source

#### pub fn as_bool(&self) -> Option<bool>

If the `Value` is a Boolean, returns the associated bool. Returns None otherwise.

    let v = json!({ "a": false, "b": "false" });

    assert_eq!(v["a"].as_bool(), Some(false));

    // The string `"false"` is a string, not a boolean.
    assert_eq!(v["b"].as_bool(), None);

source

#### pub fn is_null(&self) -> bool

Returns true if the `Value` is a Null. Returns false otherwise.

For any Value on which `is_null` returns true, `as_null` is guaranteed to return `Some(())`.

    let v = json!({ "a": null, "b": false });

    assert!(v["a"].is_null());

    // The boolean `false` is not null.
    assert!(!v["b"].is_null());

source

#### pub fn as_null(&self) -> Option<()>

If the `Value` is a Null, returns (). Returns None otherwise.

    let v = json!({ "a": null, "b": false });

    assert_eq!(v["a"].as_null(), Some(()));

    // The boolean `false` is not null.
    assert_eq!(v["b"].as_null(), None);

source

#### pub fn pointer(&self, pointer: &str) -> Option<&Value>

Looks up a value by a JSON Pointer.

JSON Pointer defines a string syntax for identifying a specific value within a JavaScript Object Notation (JSON) document.

A Pointer is a Unicode string with the reference tokens separated by `/`. Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The addressed value is returned and if there is no such value `None` is returned.

For more information read RFC6901.

##### Examples

    let data = json!({
        "x": {
            "y": ["z", "zz"]
        }
    });

    assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
    assert_eq!(data.pointer("/a/b/c"), None);

source

#### pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value>

Looks up a value by a JSON Pointer and returns a mutable reference to that value.

JSON Pointer defines a string syntax for identifying a specific value within a JavaScript Object Notation (JSON) document.

A Pointer is a Unicode string with the reference tokens separated by `/`. Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The addressed value is returned and if there is no such value `None` is returned.

For more information read RFC6901.

##### Example of Use

    use serde_json::Value;

    fn main() {
        let s = r#"{"x": 1.0, "y": 2.0}"#;
        let mut value: Value = serde_json::from_str(s).unwrap();

        // Check value using read-only pointer
        assert_eq!(value.pointer("/x"), Some(&1.0.into()));
        // Change value with direct assignment
        *value.pointer_mut("/x").unwrap() = 1.5.into();
        // Check that new value was written
        assert_eq!(value.pointer("/x"), Some(&1.5.into()));
        // Or change the value only if it exists
        value.pointer_mut("/x").map(|v| *v = 1.5.into());

        // "Steal" ownership of a value. Can replace with any valid Value.
        let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
        assert_eq!(old_x, 1.5);
        assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
    }

source

#### pub fn take(&mut self) -> Value

Takes the value out of the `Value`, leaving a `Null` in its place.

    let mut v = json!({ "x": "y" });
    assert_eq!(v["x"].take(), json!("y"));
    assert_eq!(v, json!({ "x": null }));

## Trait Implementations

source

### impl Clone for Value

source

#### fn clone(&self) -> Value

Returns a copy of the value. Read more

1.0.0 · source

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more

source

### impl Debug for Value

source

#### fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

source

### impl Default for Value

The default value is `Value::Null`.

This is useful for handling omitted `Value` fields when deserializing.

#### Examples

    use serde_json::Value;

    #[derive(Deserialize)]
    struct Settings {
        level: i32,
        #[serde(default)]
        extras: Value,
    }

    let data = r#" { "level": 42 } "#;
    let s: Settings = serde_json::from_str(data)?;

    assert_eq!(s.level, 42);
    assert_eq!(s.extras, Value::Null);

source

#### fn default() -> Value

Returns the “default value” for a type. Read more

source

### impl<'de> Deserialize<'de> for Value

source

#### fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> where
D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

source

### impl<'de> Deserializer<'de> for &'de Value

#### type Error = Error

The error type that can be returned if some error occurs during deserialization. Read more

source

#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Require the `Deserializer` to figure out how to drive the visitor based on what data type is in the input. Read more

source

#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i8` value.

source

#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i16` value.

source

#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i32` value.

source

#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i64` value.

source

#### fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i128` value. Read more

source

#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u8` value.

source

#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u16` value.

source

#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u32` value.

source

#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u64` value.

source

#### fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `u128` value. Read more

source

#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f32` value.

source

#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f64` value.

source

#### fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an optional value. Read more

source

#### fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an enum value with a particular name and possible variants. Read more

source

#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a newtype struct with a particular name. Read more

source

#### fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `bool` value.

source

#### fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `char` value.

source

#### fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a string value and does not benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a string value and would benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a byte array and would benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit value.

source

#### fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit struct with a particular name. Read more

source

#### fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a sequence of values.

source

#### fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a sequence of values and knows how many values there are without looking at the serialized data. Read more

source

#### fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a tuple struct with a particular name and number of fields. Read more

source

#### fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a map of key-value pairs.

source

#### fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a struct with a particular name and fields. Read more

source

#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting the name of a struct field or the discriminant of an enum variant. Read more

source

#### fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type needs to deserialize a value whose type doesn’t matter because it is ignored. Read more

source

#### fn is_human_readable(&self) -> bool

Determine whether `Deserialize` implementations should expect to deserialize their human-readable form. Read more

source

### impl<'de> Deserializer<'de> for Value

#### type Error = Error

The error type that can be returned if some error occurs during deserialization. Read more

source

#### fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Require the `Deserializer` to figure out how to drive the visitor based on what data type is in the input. Read more

source

#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i8` value.

source

#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i16` value.

source

#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i32` value.

source

#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i64` value.

source

#### fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i128` value. Read more

source

#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u8` value.

source

#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u16` value.

source

#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u32` value.

source

#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u64` value.

source

#### fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `u128` value. Read more

source

#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f32` value.

source

#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f64` value.

source

#### fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an optional value. Read more

source

#### fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an enum value with a particular name and possible variants. Read more

source

#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a newtype struct with a particular name. Read more

source

#### fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `bool` value.

source

#### fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `char` value.

source

#### fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a string value and does not benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a string value and would benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a byte array and would benefit from taking ownership of buffered data owned by the `Deserializer`. Read more

source

#### fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit value.

source

#### fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit struct with a particular name. Read more

source

#### fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a sequence of values.

source

#### fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a sequence of values and knows how many values there are without looking at the serialized data. Read more

source

#### fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a tuple struct with a particular name and number of fields. Read more

source

#### fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a map of key-value pairs.

source

#### fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a struct with a particular name and fields. Read more

source

#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting the name of a struct field or the discriminant of an enum variant. Read more

source

#### fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error> where
V: Visitor<'de>,

Hint that the `Deserialize` type needs to deserialize a value whose type doesn’t matter because it is ignored. Read more

source

#### fn is_human_readable(&self) -> bool

Determine whether `Deserialize` implementations should expect to deserialize their human-readable form. Read more

source

### impl Display for Value

source

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Display a JSON value as a string.

    let json = json!({ "city": "London", "street": "10 Downing Street" });

    // Compact format:
    //
    // {"city":"London","street":"10 Downing Street"}
    let compact = format!("{}", json);
    assert_eq!(compact,
        "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");

    // Pretty format:
    //
    // {
    //   "city": "London",
    //   "street": "10 Downing Street"
    // }
    let pretty = format!("{:#}", json);
    assert_eq!(pretty,
        "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");

source

### impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value

source

#### fn from(f: &'a [T]) -> Self

Convert a slice to `Value`

##### Examples

    use serde_json::Value;

    let v: &[&str] = &["lorem", "ipsum", "dolor"];
    let x: Value = v.into();

source

### impl<'a> From<&'a str> for Value

source

#### fn from(f: &str) -> Self

Convert string slice to `Value`

##### Examples

    use serde_json::Value;

    let s: &str = "lorem";
    let x: Value = s.into();

source

### impl From<()> for Value

source

#### fn from((): ()) -> Self

Convert `()` to `Value`

##### Examples

    use serde_json::Value;

    let u = ();
    let x: Value = u.into();

source

### impl<'a> From<Cow<'a, str>> for Value

source

#### fn from(f: Cow<'a, str>) -> Self

Convert copy-on-write string to `Value`

##### Examples

    use serde_json::Value;
    use std::borrow::Cow;

    let s: Cow<str> = Cow::Borrowed("lorem");
    let x: Value = s.into();

    use serde_json::Value;
    use std::borrow::Cow;

    let s: Cow<str> = Cow::Owned("lorem".to_string());
    let x: Value = s.into();

source

### impl From<Map<String, Value>> for Value

source

#### fn from(f: Map<String, Value>) -> Self

Convert map (with string keys) to `Value`

##### Examples

    use serde_json::{Map, Value};

    let mut m = Map::new();
    m.insert("Lorem".to_string(), "ipsum".into());
    let x: Value = m.into();

source

### impl From<Number> for Value

source

#### fn from(f: Number) -> Self

Convert `Number` to `Value`

##### Examples

    use serde_json::{Number, Value};

    let n = Number::from(7);
    let x: Value = n.into();

source

### impl<T> From<Option<T>> for Value where
T: Into<Value>,

source

#### fn from(opt: Option<T>) -> Self

Converts to this type from the input type.

source

### impl From<String> for Value

source

#### fn from(f: String) -> Self

Convert `String` to `Value`

##### Examples

    use serde_json::Value;

    let s: String = "lorem".to_string();
    let x: Value = s.into();

source

### impl<T: Into<Value>> From<Vec<T, Global>> for Value

source

#### fn from(f: Vec<T>) -> Self

Convert a `Vec` to `Value`

##### Examples

    use serde_json::Value;

    let v = vec!["lorem", "ipsum", "dolor"];
    let x: Value = v.into();

source

### impl From<bool> for Value

source

#### fn from(f: bool) -> Self

Convert boolean to `Value`

##### Examples

    use serde_json::Value;

    let b = false;
    let x: Value = b.into();

source

### impl From<f32> for Value

source

#### fn from(f: f32) -> Self

Convert 32-bit floating point number to `Value`

##### Examples

    use serde_json::Value;

    let f: f32 = 13.37;
    let x: Value = f.into();

source

### impl From<f64> for Value

source

#### fn from(f: f64) -> Self

Convert 64-bit floating point number to `Value`

##### Examples

    use serde_json::Value;

    let f: f64 = 13.37;
    let x: Value = f.into();

source

### impl From<i16> for Value

source

#### fn from(n: i16) -> Self

Converts to this type from the input type.

source

### impl From<i32> for Value

source

#### fn from(n: i32) -> Self

Converts to this type from the input type.

source

### impl From<i64> for Value

source

#### fn from(n: i64) -> Self

Converts to this type from the input type.

source

### impl From<i8> for Value

source

#### fn from(n: i8) -> Self

Converts to this type from the input type.

source

### impl From<isize> for Value

source

#### fn from(n: isize) -> Self

Converts to this type from the input type.

source

### impl From<u16> for Value

source

#### fn from(n: u16) -> Self

Converts to this type from the input type.

source

### impl From<u32> for Value

source

#### fn from(n: u32) -> Self

Converts to this type from the input type.

source

### impl From<u64> for Value

source

#### fn from(n: u64) -> Self

Converts to this type from the input type.

source

### impl From<u8> for Value

source

#### fn from(n: u8) -> Self

Converts to this type from the input type.

source

### impl From<usize> for Value

source

#### fn from(n: usize) -> Self

Converts to this type from the input type.

source

### impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value

source

#### fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self

Convert an iteratable type to a `Value`

##### Examples

    use serde_json::Value;

    let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
    let x: Value = v.into_iter().collect();

source

### impl<T: Into<Value>> FromIterator<T> for Value

source

#### fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Convert an iteratable type to a `Value`

##### Examples

    use serde_json::Value;

    let v = std::iter::repeat(42).take(5);
    let x: Value = v.collect();

    use serde_json::Value;

    let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
    let x: Value = v.into_iter().collect();

    use std::iter::FromIterator;
    use serde_json::Value;

    let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);

source

### impl FromStr for Value

#### type Err = Error

The associated error which can be returned from parsing.

source

#### fn from_str(s: &str) -> Result<Value, Error>

Parses a string `s` to return a value of this type. Read more

source

### impl<I> Index<I> for Value where
I: Index,

source

#### fn index(&self, index: I) -> &Value

Index into a `serde_json::Value` using the syntax `value[0]` or `value["k"]`.

Returns `Value::Null` if the type of `self` does not match the type of the index, for example if the index is a string and `self` is an array or a number. Also returns `Value::Null` if the given key does not exist in the map or the given index is not within the bounds of the array.

For retrieving deeply nested values, you should have a look at the `Value::pointer` method.

##### Examples

    let data = json!({
        "x": {
            "y": ["z", "zz"]
        }
    });

    assert_eq!(data["x"]["y"], json!(["z", "zz"]));
    assert_eq!(data["x"]["y"][0], json!("z"));

    assert_eq!(data["a"], json!(null)); // returns null for undefined values
    assert_eq!(data["a"]["b"], json!(null)); // does not panic

#### type Output = Value

The returned type after indexing.

source

### impl<I> IndexMut<I> for Value where
I: Index,

source

#### fn index_mut(&mut self, index: I) -> &mut Value

Write into a `serde_json::Value` using the syntax `value[0] = ...` or `value["k"] = ...`.

If the index is a number, the value must be an array of length bigger than the index. Indexing into a value that is not an array or an array that is too small will panic.

If the index is a string, the value must be an object or null which is treated like an empty object. If the key is not already present in the object, it will be inserted with a value of null. Indexing into a value that is neither an object nor null will panic.

##### Examples

    let mut data = json!({ "x": 0 });

    // replace an existing key
    data["x"] = json!(1);

    // insert a new key
    data["y"] = json!([false, false, false]);

    // replace an array value
    data["y"][0] = json!(true);

    // inserted a deeply nested key
    data["a"]["b"]["c"]["d"] = json!(true);

    println!("{}", data);

source

### impl<'de> IntoDeserializer<'de, Error> for Value

#### type Deserializer = Value

The type of the deserializer being converted into.

source

#### fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

source

### impl<'a> PartialEq<&'a str> for Value

source

#### fn eq(&self, other: &&str) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<String> for Value

source

#### fn eq(&self, other: &String) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<Value> for &'a str

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for String

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for Value

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

source

#### fn ne(&self, other: &Value) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for bool

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for f32

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for f64

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for i16

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for i32

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for i64

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for i8

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for isize

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for str

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for u16

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for u32

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for u64

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for u8

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<Value> for usize

source

#### fn eq(&self, other: &Value) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<bool> for &'a Value

source

#### fn eq(&self, other: &bool) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<bool> for &'a mut Value

source

#### fn eq(&self, other: &bool) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<bool> for Value

source

#### fn eq(&self, other: &bool) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<f32> for &'a Value

source

#### fn eq(&self, other: &f32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<f32> for &'a mut Value

source

#### fn eq(&self, other: &f32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<f32> for Value

source

#### fn eq(&self, other: &f32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<f64> for &'a Value

source

#### fn eq(&self, other: &f64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<f64> for &'a mut Value

source

#### fn eq(&self, other: &f64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<f64> for Value

source

#### fn eq(&self, other: &f64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i16> for &'a Value

source

#### fn eq(&self, other: &i16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i16> for &'a mut Value

source

#### fn eq(&self, other: &i16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<i16> for Value

source

#### fn eq(&self, other: &i16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i32> for &'a Value

source

#### fn eq(&self, other: &i32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i32> for &'a mut Value

source

#### fn eq(&self, other: &i32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<i32> for Value

source

#### fn eq(&self, other: &i32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i64> for &'a Value

source

#### fn eq(&self, other: &i64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i64> for &'a mut Value

source

#### fn eq(&self, other: &i64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<i64> for Value

source

#### fn eq(&self, other: &i64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i8> for &'a Value

source

#### fn eq(&self, other: &i8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<i8> for &'a mut Value

source

#### fn eq(&self, other: &i8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<i8> for Value

source

#### fn eq(&self, other: &i8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<isize> for &'a Value

source

#### fn eq(&self, other: &isize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<isize> for &'a mut Value

source

#### fn eq(&self, other: &isize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<isize> for Value

source

#### fn eq(&self, other: &isize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<str> for Value

source

#### fn eq(&self, other: &str) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u16> for &'a Value

source

#### fn eq(&self, other: &u16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u16> for &'a mut Value

source

#### fn eq(&self, other: &u16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<u16> for Value

source

#### fn eq(&self, other: &u16) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u32> for &'a Value

source

#### fn eq(&self, other: &u32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u32> for &'a mut Value

source

#### fn eq(&self, other: &u32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<u32> for Value

source

#### fn eq(&self, other: &u32) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u64> for &'a Value

source

#### fn eq(&self, other: &u64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u64> for &'a mut Value

source

#### fn eq(&self, other: &u64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<u64> for Value

source

#### fn eq(&self, other: &u64) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u8> for &'a Value

source

#### fn eq(&self, other: &u8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<u8> for &'a mut Value

source

#### fn eq(&self, other: &u8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<u8> for Value

source

#### fn eq(&self, other: &u8) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<usize> for &'a Value

source

#### fn eq(&self, other: &usize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl<'a> PartialEq<usize> for &'a mut Value

source

#### fn eq(&self, other: &usize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl PartialEq<usize> for Value

source

#### fn eq(&self, other: &usize) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`.

source

### impl Serialize for Value

source

#### fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,

Serialize this value into the given Serde serializer. Read more

source

### impl Eq for Value

source

### impl StructuralEq for Value

source

### impl StructuralPartialEq for Value

## Auto Trait Implementations

### impl RefUnwindSafe for Value

### impl Send for Value

### impl Sync for Value

### impl Unpin for Value

### impl UnwindSafe for Value

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T> ToString for T where
T: Display + ?Sized,

source

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

source

### impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,