మాడ్యూల్ పాఠాలు (1/2)
నిర్మాణాలను నిర్వచించడం మరియు తక్షణం చేయడం
రస్ట్లోని స్ట్రక్ట్లు (లేదా స్ట్రక్చర్లు) అనేది బహుళ సంబంధిత విలువలను సమూహపరచడానికి మిమ్మల్ని అనుమతించే అనుకూల డేటా రకాలు. అవి ఇతర భాషలలోని వస్తువులు లేదా తరగతులను పోలి ఉంటాయి, కానీ వారసత్వం లేకుండా ఉంటాయి.
ఒక నిర్మాణాన్ని నిర్వచించడం
నిర్మాణాన్ని నిర్వచించడానికి, మేము struct కీవర్డ్ని PascalCaseలో పేరుని ఉపయోగిస్తాము. లోపల, మేము ఫీల్డ్ల పేర్లు మరియు రకాలను నిర్వచించాము:
struct User {
username: String,
email: String,
active: bool,
sign_in_count: u64,
}ఒక ఉదాహరణను సృష్టిస్తోంది
structని ఉపయోగించడానికి, మేము పేర్కొన్న అన్ని ఫీల్డ్లను పూరించడం ద్వారా తప్పనిసరిగా ఒక ఉదాహరణను సృష్టించాలి:
fn main() {
let user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice123"),
active: true,
sign_in_count: 1,
};
// Access fields using dot notation
println!("Is user {} active? {}", user1.username, user1.active);
}స్ట్రక్ట్ మ్యుటబిలిటీ
రస్ట్లో, మీరు దాని ఫీల్డ్లలో దేనినైనా సవరించాలనుకుంటే, మొత్తం ఉదాహరణ తప్పనిసరిగా మార్చదగినదిగా (mut) గుర్తించబడాలి. రస్ట్ నిర్దిష్ట ఫీల్డ్లను మాత్రమే మార్చదగినదిగా గుర్తించడాన్ని అనుమతించదు:
fn main() {
let mut user1 = User {
email: String::from("alice@example.com"),
username: String::from("alice123"),
active: true,
sign_in_count: 1,
};
user1.active = false; // Valid because user1 is mutable!
}టుపుల్ స్ట్రక్ట్స్ మరియు యూనిట్ లాంటి స్ట్రక్ట్స్
రస్ట్ క్లాసిక్ నేమ్-ఫీల్డ్ స్ట్రక్ట్లతో పాటు మరో రెండు స్ట్రక్ట్ ఫార్మాట్లకు కూడా మద్దతు ఇస్తుంది:
- Tuple Structs: వాటికి అనుబంధిత పేరు ఉంది కానీ ఫీల్డ్లకు వ్యక్తిగత పేర్లు లేవు, రకాలు మాత్రమే ఉంటాయి. నిర్దిష్ట రకాలను నిర్వచించడానికి మరియు వేరు చేయడానికి అవి ఉపయోగపడతాయి:
Rust
struct Point(i32, i32, i32); let origin = Point(0, 0, 0); - యూనిట్ లాంటి నిర్మాణాలు: అవి ఏ ఫీల్డ్లను నిర్వచించవు. వారు
()యూనిట్ రకం వలె ప్రవర్తిస్తారు. మీరు ఏదైనా డేటాను నిల్వ చేయకుండా ఒక రకంపై ప్రవర్తనలను (లక్షణాలు) అమలు చేయవలసి వచ్చినప్పుడు అవి ఉపయోగకరంగా ఉంటాయి.
మీరే ప్రయత్నించండి
ప్రధాన ఫీల్డ్లతో పైన ఉన్న వినియోగదారు నిర్మాణాన్ని నిర్వచించండి: వినియోగదారు పేరు (స్ట్రింగ్ రకం) మరియు క్రియాశీల (బూల్ రకం).
సూచనను చూపించు
`struct User {username: String, Active: bool }`before`main` అని వ్రాయండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
యూజర్1ని మార్చగలిగేలా మార్చండి (యూజర్1ని మ్యూట్ చేయనివ్వండి) మరియు ప్రింటింగ్ చేయడానికి ముందు సక్రియ ఫీల్డ్ని తప్పుగా మార్చండి.
సూచనను చూపించు
వినియోగదారుని మ్యూట్ చేయనివ్వండి`ని చేయడానికి `mut`to`let user1`ని జోడించి, ఆపై `user1.active = false;`ని చొప్పించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
మూడు i32 ఫీల్డ్లను కలిగి ఉన్న కలర్ అనే టుపుల్ స్ట్రక్ట్ను నిర్వచించండి. ప్రధానంగా, 255, 0 మరియు 100 విలువలతో రంగును తక్షణం చేయండి, దానిని my_color వేరియబుల్కు కేటాయించండి, ఆపై printlnని ఉపయోగించి దాని మొదటి మూలకాన్ని (ఎరుపు విలువ) ముద్రించండి!.
సూచనను చూపించు
`స్ట్రక్ట్ కలర్(i32, i32, i32);`తో టుపుల్ స్ట్రక్ట్ను నిర్వచించండి. ప్రధానంగా, దీన్ని `లెట్ my_color = Color(255, 0, 100);`గా తక్షణం చేయండి మరియు ఎరుపు విలువను `my_color.0`తో ముద్రించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది