# Struct serde_json::value::Number

source · `pub struct Number { /* private fields */ }`

## Expand description

Represents a JSON number, whether integer or floating point.

## Implementations§

source§### impl Number

### impl Number

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

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

Returns true if the `Number`

is an integer between `i64::MIN`

and
`i64::MAX`

.

For any Number 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

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

Returns true if the `Number`

is an integer between zero and `u64::MAX`

.

For any Number 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

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

Returns true if the `Number`

can be represented by f64.

For any Number 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>

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

If the `Number`

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>

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

If the `Number`

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);
```

## Trait Implementations§

source§### impl<'de> Deserialize<'de> for Number

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

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

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

source§### impl<'de, 'a> Deserializer<'de> for &'a Number

### impl<'de, 'a> Deserializer<'de> for &'a Number

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

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

`Deserializer`

to figure out how to drive the visitor based
on what data type is in the input. Read moresource§#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting an `i8`

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

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

`Deserialize`

type is expecting an `i16`

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

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

`Deserialize`

type is expecting an `i32`

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

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

`Deserialize`

type is expecting an `i64`

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

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

`Deserialize`

type is expecting a `u8`

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

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

`Deserialize`

type is expecting a `u16`

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

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

`Deserialize`

type is expecting a `u32`

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

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

`Deserialize`

type is expecting a `u64`

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

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

`Deserialize`

type is expecting a `f32`

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

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

`Deserialize`

type is expecting a `f64`

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

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

`Deserialize`

type is expecting a `bool`

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

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

`Deserialize`

type is expecting a `char`

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

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

`Deserialize`

type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting an optional value. Read moresource§#### fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a unit value.source§#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a unit struct with a
particular name.source§#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a newtype struct with a
particular name.source§#### fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a sequence of values.source§#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a tuple struct with a
particular name and number of fields.source§#### fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`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, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a struct with a particular
name and fields.source§#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting an enum value with a
particular name and possible variants.source§#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting the name of a struct
field or the discriminant of an enum variant.source§#### fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§#### fn is_human_readable(&self) -> bool

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

`Deserialize`

implementations should expect to
deserialize their human-readable form. Read moresource§### impl<'de> Deserializer<'de> for Number

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

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

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

`Deserializer`

to figure out how to drive the visitor based
on what data type is in the input. Read moresource§#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting an `i8`

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

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

`Deserialize`

type is expecting an `i16`

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

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

`Deserialize`

type is expecting an `i32`

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

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

`Deserialize`

type is expecting an `i64`

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

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

`Deserialize`

type is expecting a `u8`

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

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

`Deserialize`

type is expecting a `u16`

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

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

`Deserialize`

type is expecting a `u32`

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

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

`Deserialize`

type is expecting a `u64`

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

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

`Deserialize`

type is expecting a `f32`

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

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

`Deserialize`

type is expecting a `f64`

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

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

`Deserialize`

type is expecting a `bool`

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

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

`Deserialize`

type is expecting a `char`

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

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

`Deserialize`

type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
`Deserializer`

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

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

`Deserialize`

type is expecting an optional value. Read moresource§#### fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a unit value.source§#### fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a unit struct with a
particular name.source§#### fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a newtype struct with a
particular name.source§#### fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a sequence of values.source§#### fn deserialize_tuple<V>(
self,
len: usize,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§#### fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a tuple struct with a
particular name and number of fields.source§#### fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`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, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting a struct with a particular
name and fields.source§#### fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting an enum value with a
particular name and possible variants.source§#### fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type is expecting the name of a struct
field or the discriminant of an enum variant.source§#### fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>where
V: Visitor<'de>,

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

`Deserialize`

type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§#### fn is_human_readable(&self) -> bool

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

`Deserialize`

implementations should expect to
deserialize their human-readable form. Read more