मैं HashMap शाब्दिक कैसे बनाऊं?

Question 1

मैं जंग में एक हाशपापल शाब्दिक कैसे बना सकता हूं? अजगर में मैं ऐसा कर सकता हूं:

hashmap = {
   'element0': {
       'name': 'My New Element',
       'childs': {
           'child0': {
               'name': 'Child For Element 0',
               'childs': {
                   ...
               }
           }
       }
   },
   ...
}

और इस तरह जाओ:

type Node struct {
    name string
    childs map[string]Node
}

hashmap := map[string]Node {
    "element0": Node{
        "My New Element",
        map[string]Node {
            'child0': Node{
                "Child For Element 0",
                map[string]Node {}
            }
        }
    }
}

Question 2

Rust में मैप शाब्दिक सिंटैक्स नहीं है। मुझे इसका सटीक कारण नहीं पता है , लेकिन मुझे उम्मीद है कि यह तथ्य है कि कई डेटा संरचनाएं हैं जो मैपलाइक (जैसे कि दोनों ) BTreeMapऔर जैसे कार्य करते हैं, HashMapएक को चुनना मुश्किल होगा।

हालाँकि, आप अपने लिए काम करने के लिए एक मैक्रो बना सकते हैं, जैसा कि यह दिखाया गया है कि यह जंग हाशप मैक्रो अब काम क्यों नहीं करती है? । यहाँ है कि मैक्रो ने थोड़ा सा सरलीकरण किया है और पर्याप्त संरचना के साथ खेल के मैदान में इसे चलाने योग्य बनाया जा सकता है :

macro_rules! map(
    { $($key:expr => $value:expr),+ } => {
        {
            let mut m = ::std::collections::HashMap::new();
            $(
                m.insert($key, $value);
            )+
            m
        }
     };
);

fn main() {
    let names = map!{ 1 => "one", 2 => "two" };
    println!("{} -> {:?}", 1, names.get(&1));
    println!("{} -> {:?}", 10, names.get(&10));
}

यह मैक्रो एक अनावश्यक इंटरमीडिएट को आवंटित करने से बचता है Vec, लेकिन इसका उपयोग नहीं करता है, क्योंकि इसमें HashMap::with_capacityकुछ बेकार हो सकते हैं जैसे HashMapकि मान जोड़े जाते हैं। मैक्रो का एक और अधिक जटिल संस्करण जो मानों को गिनता है, संभव है, लेकिन प्रदर्शन लाभ शायद कुछ नहीं हैं जो मैक्रो के अधिकांश उपयोग से लाभ होगा।

जंग के एक रात के संस्करण में, आप दोनों अनावश्यक आवंटन (और वसूली) से बच सकते हैं और साथ ही एक मैक्रो की आवश्यकता भी हो सकती है:

#![feature(array_value_iter)]

use std::array::IntoIter;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::iter::FromIterator;

fn main() {
    let s = Vec::from_iter(IntoIter::new([1, 2, 3]));
    println!("{:?}", s);

    let s = BTreeSet::from_iter(IntoIter::new([1, 2, 3]));
    println!("{:?}", s);

    let s = HashSet::<_>::from_iter(IntoIter::new([1, 2, 3]));
    println!("{:?}", s);

    let s = BTreeMap::from_iter(IntoIter::new([(1, 2), (3, 4)]));
    println!("{:?}", s);

    let s = HashMap::<_, _>::from_iter(IntoIter::new([(1, 2), (3, 4)]));
    println!("{:?}", s);
}

इस तर्क को एक मैक्रो में भी लपेटा जा सकता है:

#![feature(array_value_iter)]

use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};

macro_rules! collection {
    // map-like
    ($($k:expr => $v:expr),* $(,)?) => {
        std::iter::Iterator::collect(std::array::IntoIter::new([$(($k, $v),)*]))
    };
    // set-like
    ($($v:expr),* $(,)?) => {
        std::iter::Iterator::collect(std::array::IntoIter::new([$($v,)*]))
    };
}

fn main() {
    let s: Vec<_> = collection![1, 2, 3];
    println!("{:?}", s);

    let s: BTreeSet<_> = collection! { 1, 2, 3 };
    println!("{:?}", s);

    let s: HashSet<_> = collection! { 1, 2, 3 };
    println!("{:?}", s);

    let s: BTreeMap<_, _> = collection! { 1 => 2, 3 => 4 };
    println!("{:?}", s);

    let s: HashMap<_, _> = collection! { 1 => 2, 3 => 4 };
    println!("{:?}", s);
}

यह सभी देखें:

हैशमैप, हैशसेट, ट्रेमैप और ट्रीसेट मैक्रोज़ जोड़ें

Question 3

मैं मैपलेट टोकरा सुझाता हूं ।

प्रलेखन से उद्धृत करने के लिए:

विशिष्ट प्रकार के कंटेनर कंटेनर के लिए मैक्रो।

use maplit::hashmap;

let map = hashmap!{
    "a" => 1,
    "b" => 2,
};

=>मानचित्रण टोकरा मानचित्रण मैक्रो के लिए वाक्यविन्यास का उपयोग करता है । :नियमित macro_rules!मैक्रोज़ में प्रतिबंधों के कारण विभाजक के रूप में उपयोग करना संभव नहीं है ।

ध्यान दें कि जंग मैक्रोज़ लचीले होते हैं जिसमें आप कोष्ठक के लिए उपयोग करते हैं। आप उन्हें के रूप में उपयोग कर सकते हैं hashmap!{}या hashmap![]या hashmap!()। यह टोकरा {}मानचित्र &सेट मैक्रोज़ के सम्मेलन के रूप में सुझाव देता है , यह उनके डिबग आउटपुट से मेल खाता है।

मैक्रो

btreemapBTreeMapकुंजी-मूल्य जोड़े की सूची से बनाएं

btreesetBTreeSetतत्वों की सूची से बनाएं ।

hashmapHashMapकुंजी-मूल्य जोड़े की सूची से बनाएं

hashsetHashSetतत्वों की सूची से बनाएं ।

Question 4

दस्तावेज़HashMap में इसे कैसे प्राप्त किया जाए, इसका एक उदाहरण है :

let timber_resources: HashMap<&str, i32> = [("Norway", 100), ("Denmark", 50), ("Iceland", 10)]
    .iter()
    .cloned()
    .collect();

Question 5

जैसा कि टिप्पणियों में @ जोहान्स ने लिखा है, इसका उपयोग करना संभव है vec![]क्योंकि:

Vec<T>IntoIterator<T>गुण को लागू करता है
HashMap<K, V> औजार FromIterator<Item = (K, V)>

जिसका मतलब है कि आप यह कर सकते हैं:

let map: HashMap<String, String> = vec![("key".to_string(), "value".to_string())]
    .into_iter()
    .collect();

आप उपयोग कर सकते हैं, &strलेकिन आपको जीवनकाल को एनोटेट करने की आवश्यकता हो सकती है यदि यह नहीं है 'static:

let map: HashMap<&str, usize> = vec![("one", 1), ("two", 2)].into_iter().collect();

Question 6

आप velcroटोकरा * का उपयोग कर सकते हैं । यह maplitअन्य उत्तरों में अनुशंसित के समान है, लेकिन अधिक संग्रह प्रकारों के साथ, बेहतर सिंटैक्स (कम से कम मेरी राय में!) और अधिक सुविधाओं के साथ।

यह मानते हुए कि आप Stringइसके बजाय s का उपयोग करना चाहते हैं &str, आपका सटीक उदाहरण इस तरह दिखाई देगा:

use std::collections::HashMap;
use velcro::hash_map;

struct Node {
    name: String
    children: HashMap<String, Node>,
}

let map = hash_map! {
    String::from("element0"): Node {
        name: "My New Element".into(),
        children: hash_map! {
            String::from("child0"): Node {
                name: "child0".into(),
                children: hash_map!{}
            }
        }
    }
};

यह थोड़ा बदसूरत है क्योंकि Stringनिर्माण कैसे किया जाता है। लेकिन कुंजी प्रकार को बदले बिना, इसे थोड़ा साफ किया जा सकता है, जिसके उपयोग hash_map_from!से स्वचालित रूप से रूपांतरण होगा:

use std::collections::HashMap;
use velcro::{hash_map, hash_map_from};

let map: HashMap<String, Node> = hash_map_from! {
    "element0": Node {
        name: "My New Element".into(),
        children: hash_map_from! {
            "child0": Node {
                name: "child0".into(),
                children: hash_map!{}
            }
        }
    }
};

जो गो संस्करण की तुलना में बहुत अधिक क्रिया नहीं है ।

* _{पूर्ण प्रकटीकरण: मैं इस टोकरे का लेखक हूं।}

Question 7

एक तत्व के लिए

यदि आप मानचित्र को एक पंक्ति में केवल एक तत्व के साथ शुरू करना चाहते हैं (और आपके कोड में दृश्य उत्परिवर्तन के बिना), तो आप कर सकते हैं:

let map: HashMap<&'static str, u32> = Some(("answer", 42)).into_iter().collect();

यह Optionएक Iteratorप्रयोग बनने में सक्षम होने की उपयोगिता के लिए धन्यवाद हैinto_iter() ।

वास्तविक कोड में, आपको संभवतः कंपाइलर को टाइप के साथ मदद करने की आवश्यकता नहीं है:

use std::collections::HashMap;

fn john_wick() -> HashMap<&'static str, u32> {
    Some(("answer", 42)).into_iter().collect()
}

fn main() {
    let result = john_wick();

    let mut expected = HashMap::new();
    expected.insert("answer", 42);

    assert_eq!(result, expected);
}

इसे चेन करने का एक तरीका यह भी है कि एक से अधिक तत्वों को कुछ करने की तरह है Some(a).into_iter().chain(Some(b).into_iter()).collect(), लेकिन यह अधिक लंबा है, कम पठनीय है और शायद कुछ अनुकूलन मुद्दे हैं, इसलिए मैं इसके खिलाफ सलाह देता हूं।

Question 8

मैंने फैंसी समाधानों का एक गुच्छा देखा है, लेकिन मुझे बस कुछ सरल चाहिए था। उस छोर तक, यहाँ एक विशेषता है:

use std::collections::HashMap;

trait Hash {
   fn to_map(&self) -> HashMap<&str, u16>;
}

impl Hash for [(&str, u16)] {
   fn to_map(&self) -> HashMap<&str, u16> {
      self.iter().cloned().collect()
   }
}

fn main() {
   let m = [("year", 2019), ("month", 12)].to_map();
   println!("{:?}", m)
}

मुझे लगता है कि यह एक अच्छा विकल्प है, क्योंकि यह अनिवार्य रूप से रूबी और निम द्वारा पहले से ही इस्तेमाल किया गया है: