Function serde_json::de::from_str
source · pub fn from_str<'a, T>(s: &'a str) -> Result<T>where
T: Deserialize<'a>,
Expand description
Deserialize an instance of type T
from a string of JSON text.
Example
use serde::Deserialize;
#[derive(Deserialize, Debug)]
struct User {
fingerprint: String,
location: String,
}
fn main() {
// The type of `j` is `&str`
let j = "
{
\"fingerprint\": \"0xF9BA143B95FF6D82\",
\"location\": \"Menlo Park, CA\"
}";
let u: User = serde_json::from_str(j).unwrap();
println!("{:#?}", u);
}
Errors
This conversion can fail if the structure of the input does not match the
structure expected by T
, for example if T
is a struct type but the input
contains something other than a JSON map. It can also fail if the structure
is correct but T
’s implementation of Deserialize
decides that something
is wrong with the data, for example required struct fields are missing from
the JSON map or some number is too big to fit in the expected primitive
type.
Examples found in repository?
More examples
src/value/de.rs (line 118)
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
where
V: MapAccess<'de>,
{
match visitor.next_key_seed(KeyClassifier)? {
#[cfg(feature = "arbitrary_precision")]
Some(KeyClass::Number) => {
let number: NumberFromString = visitor.next_value()?;
Ok(Value::Number(number.value))
}
#[cfg(feature = "raw_value")]
Some(KeyClass::RawValue) => {
let value = visitor.next_value_seed(crate::raw::BoxedFromString)?;
crate::from_str(value.get()).map_err(de::Error::custom)
}
Some(KeyClass::Map(first_key)) => {
let mut values = Map::new();
values.insert(first_key, tri!(visitor.next_value()));
while let Some((key, value)) = tri!(visitor.next_entry()) {
values.insert(key, value);
}
Ok(Value::Object(values))
}
None => Ok(Value::Object(Map::new())),
}
}
}
deserializer.deserialize_any(ValueVisitor)
}
}
impl FromStr for Value {
type Err = Error;
fn from_str(s: &str) -> Result<Value, Error> {
super::super::de::from_str(s)
}