जंग

Question

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

let my_shape = Shape::Circle(Point {x: 0.0, y: 0.0}, 10.0); 

में प्रवेश enum मानों को एक्सेस करें मैं सर्कल की दूसरी संपत्ति को प्रिंट करना चाहता हूं, जो यहां 10.0 है। मैंने my_shape.last और my_shape.second की कोशिश की, लेकिन न तो काम किया।

इस मामले में 10.0 प्रिंट करने के लिए मुझे क्या करना चाहिए?

धन्यवाद

Answer 1

मुझे यकीन है कि वहाँ ऐसा करने के लिए एक बेहतर तरीका है नहीं कर रहा हूँ, लेकिन आप पैटर्न मिलान का उपयोग कर सकते हैं:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
    rectangle(point, point) 
} 

fn main() { 
    let my_shape = circle({x: 0.0, y: 0.0}, 10.0); 
    alt my_shape { 
     circle(_, value) { 
      std::io::println(#fmt("value: %f", value)); 
     } 
    } 
} 

उदाहरण आउटपुट:

value: 10 

Answer 2

यहाँ है ऐसा करने का एक और तरीका:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
} 

fn main() { 
    let circle(_, radius) = circle({x: 0.0, y: 0.0}, 10.0); 
    std::io::println(#fmt("value: %f", radius)); 
} 

यह केवल तभी काम करता है जब लेट पैटर्न अचूक है, उदाहरण के लिए, यदि आपके द्वारा मिलान किए गए एनम प्रकार में केवल एक संस्करण है। यह काम करने के लिए, मुझे अप्रयुक्त rectangle संस्करण को हटाना पड़ा।

ऐसे मामलों में जहां आपके पास एक से अधिक प्रकार हैं, आप शायद पूर्ण alt अभिव्यक्ति चाहते हैं, क्योंकि आप संभावित रूप से केवल एक प्रकार के आकार से अधिक संभाल रहे हैं।

Answer 3

जंग ट्यूटोरियल से (जोर जोड़ा):

कई वेरिएंट के साथ enum प्रकार के लिए, destructuring एक ही रास्ता उनकी सामग्री पर प्राप्त करने के लिए है। सभी संस्करण कंस्ट्रक्टर्स क्षेत्र की इस परिभाषा के रूप में, पैटर्न के रूप में इस्तेमाल किया जा सकता:

fn area(sh: shape) -> float { 
    alt sh { 
     circle(_, size) { float::consts::pi * size * size } 
     rectangle({x, y}, {x: x2, y: y2}) { (x2 - x) * (y2 - y) } 
    } 
} 

http://doc.rust-lang.org/doc/tutorial.html#enum-patterns

आप कार्यों कि कई प्रकार के पर काम करने में सक्षम हैं लिखने के लिए सक्षम होने के लिए चाहते हैं, तो अलग प्रतिनिधित्व के साथ, इंटरफेस पर एक नजर है:

http://doc.rust-lang.org/doc/tutorial.html#interfaces

Answer 4

आप केवल matchin में रुचि रखते हैं के रूप में जी किसी एक प्रकार का है, तो आप एक if let अभिव्यक्ति का उपयोग कर सकते हैं:

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

fn main() { 
    let my_shape = Shape::Circle(Point { x: 0.0, y: 0.0 }, 10.0); 

    if let Shape::Circle(_, radius) = my_shape { 
     println!("value: {}", radius); 
    } 
} 

इसका मतलब यह है "अगर my_shape एक Circle में destructured जा सकता है, पहले सूचकांक के साथ कुछ भी नहीं है, लेकिन radius से पीछे नहीं सूचकांक के मूल्य के लिए बाध्य" ।