రస్ట్‌లో, std::os మాడ్యూల్ ఆపరేటింగ్ సిస్టమ్ యొక్క కార్యాచరణపై ఒక సంగ్రహణను అందిస్తుంది. ఎన్విరాన్మెంట్ వేరియబుల్స్, ఫైల్ సిస్టమ్ ఆపరేషన్స్, ప్రాసెస్ మేనేజ్‌మెంట్ మరియు మరిన్నింటితో పని చేయడానికి అంతర్లీన ఆపరేటింగ్ సిస్టమ్‌తో పరస్పర చర్య చేయడానికి ఇది మమ్మల్ని అనుమతిస్తుంది.
ఈ ఉదాహరణలో, Rust std ::os మాడ్యూల్‌ని ఉపయోగించి మీరు Unixలో నిర్వహించగల కొన్ని ప్రాథమిక కార్యకలాపాలను మేము కవర్ చేస్తాము.
ఇది విస్తృతమైన మాడ్యూల్ అని గుర్తుంచుకోవడం మంచిది మరియు ఇది వివిధ Unix-సంబంధిత కార్యకలాపాల కోసం అనేక రకాలు మరియు విధులను కలిగి ఉంటుంది. కాబట్టి, దయచేసి సంబంధిత ప్రక్రియలపై సూచన కోసం డాక్యుమెంటేషన్‌ను పరిగణించండి.
Linuxలో రస్ట్ OS
Linuxలో, రస్ట్‌లోని std::os మాడ్యూల్ యొక్క ఉప-మాడ్యూల్ అయిన std::os::unix మాడ్యూల్ ద్వారా అందించబడిన Unix-నిర్దిష్ట ఫంక్షన్‌లు మరియు రకాలను మనం యాక్సెస్ చేయవచ్చు.
ఈ మాడ్యూల్ రస్ట్ స్టాండర్డ్ లైబ్రరీలో భాగం మరియు అందువల్ల మీరు ఏదైనా బాహ్య క్రేట్ లేదా డిపెండెన్సీలను ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు.
ఈ మాడ్యూల్ నుండి మనం Linux సిస్టమ్‌లో నిర్వహించగల కొన్ని ప్రాథమిక API మరియు కార్యకలాపాలను కవర్ చేద్దాం.
ఎన్విరాన్మెంట్ వేరియబుల్స్‌ని యాక్సెస్ చేస్తోంది
std::env మాడ్యూల్‌ని ఉపయోగించి మనం ఎన్విరాన్మెంట్ వేరియబుల్స్‌ని యాక్సెస్ చేయవచ్చు. ఉదాహరణకు, std::env::var(“PATH”) PATH ఎన్విరాన్మెంట్ వేరియబుల్ విలువను తిరిగి పొందుతుంది.
కింది ఉదాహరణ ప్రోగ్రామ్‌ను పరిగణించండి:
std ఉపయోగించండి ::env;std::ffi::OsStringని ఉపయోగించండి;
fn చేతి ( ) {
// నిర్దిష్ట పర్యావరణ వేరియబుల్‌ని యాక్సెస్ చేయండి
ఉంటే వీలు అలాగే ( విలువ ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , విలువ ) ;
}
// అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్‌పై మళ్లించండి
కోసం ( కీ, విలువ ) లో env:: wars_us ( ) {
వీలు key_string = key.to_string_lossy ( ) ;
వీలు value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , key_string, value_string ) ;
}
// నిర్దిష్ట పర్యావరణ వేరియబుల్‌ని యాక్సెస్ చేయండి వంటి ఒక ` OsString `
ఉంటే వీలు కొన్ని ( విలువ ) = env::var_us ( 'హోస్టైప్' ) {
// మార్చు ` OsString ` a కు ` స్ట్రింగ్ ` ఉంటే అవసరం
ఉంటే వీలు కొన్ని ( విలువ_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
ఇచ్చిన ఉదాహరణలో, మేము అవసరమైన మాడ్యూళ్ళను దిగుమతి చేయడం ద్వారా ప్రారంభిస్తాము. ఈ సందర్భంలో, మేము std::env మరియు std::ff::OsStringపై ఆసక్తి కలిగి ఉన్నాము.
నిర్దిష్ట ఎన్విరాన్మెంట్ వేరియబుల్‌ని యాక్సెస్ చేయడానికి, మేము env::var ఫంక్షన్‌ని ఉపయోగించవచ్చు మరియు మనం పొందాలనుకుంటున్న విలువ పేరును పాస్ చేయవచ్చు. ఈ సందర్భంలో, మేము WAYLAND_DISPLAY వేరియబుల్ విలువను పొందుతాము.
ఫంక్షన్ వేరియబుల్ విలువను ఫలిత రకంగా అందిస్తుంది.
మేము env::vars_os ఫంక్షన్‌ని ఉపయోగించి అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్‌పై కూడా పునరావృతం చేయవచ్చు. ఇది ఎన్విరాన్మెంట్ వేరియబుల్స్ యొక్క కీ-విలువ జతలతో ఇటరేటర్‌ను అందిస్తుంది. విలువలు OsString రకంగా అందించబడతాయని గమనించడం మంచిది. మేము వాటిని to_string_lossy ఫంక్షన్ ఉపయోగించి స్ట్రింగ్ విలువలకు మార్చవచ్చు.
మేము env::var_os ఫంక్షన్‌ని ఉపయోగించి నిర్దిష్ట పర్యావరణ వేరియబుల్‌లను కూడా యాక్సెస్ చేయవచ్చు. ఇది మేము to_str() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌గా మార్చగల
ఫలిత అవుట్పుట్ క్రింది విధంగా ఉంది:
WAYLAND_DISPLAY =మార్గం- 0HOSTYPE =x86_64
OS మాడ్యూల్ ఉపయోగించి FS కార్యకలాపాలు
మీరు ఊహించినట్లుగా, OS మాడ్యూల్ ఫైల్‌సిస్టమ్-సంబంధిత కార్యకలాపాలను నిర్వహించడానికి వివిధ విధులు మరియు పద్ధతులను అందిస్తుంది.
Linuxలో std::os మాడ్యూల్‌ని ఉపయోగించి మనం నిర్వహించగల వివిధ కార్యకలాపాలను ప్రదర్శించే క్రింది ప్రోగ్రామ్‌ను తీసుకోండి:
std ఉపయోగించండి :: fs;fn చేతి ( ) {
// చదవండి a ఫైల్
ఉంటే వీలు అలాగే ( విషయాలు ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , విషయాలు ) ;
}
// కొత్త డైరెక్టరీని సృష్టించండి
ఉంటే వీలు తప్పు ( తప్పు ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'డైరెక్టరీని సృష్టించడం విఫలమైంది: {}' , తప్పు ) ;
}
// తొలగించు a ఫైల్
ఉంటే వీలు తప్పు ( తప్పు ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'ఫైల్‌ని తీసివేయడంలో విఫలమైంది: {}' , తప్పు ) ;
}
}
ఇచ్చిన ఉదాహరణలో, fs ::read_to_string() పద్ధతిని ఉపయోగించి ఫైల్‌లోని కంటెంట్‌లను ఎలా చదవవచ్చో మేము ప్రదర్శిస్తాము. పద్ధతి లక్ష్య ఫైల్‌కు మార్గాన్ని తీసుకుంటుంది మరియు ఫైల్ కంటెంట్‌లను స్ట్రింగ్‌గా అందిస్తుంది.
మేము fs::create_dir() ఫంక్షన్‌ని ఉపయోగించి కొత్త డైరెక్టరీని కూడా సృష్టించవచ్చు మరియు పారామీటర్‌గా టార్గెట్ డైరెక్టరీకి పాత్‌ను పాస్ చేయవచ్చు.
చివరగా, మేము fs::remove_file() ఫంక్షన్‌ని ఉపయోగించి నిర్దిష్ట ఫైల్‌ను తీసివేయవచ్చు మరియు లక్ష్య ఫైల్‌ను పారామీటర్‌గా పాస్ చేయవచ్చు.
గమనిక: అందించిన ఉదాహరణలు std::fs మాడ్యూల్‌ని ఉపయోగించి Linuxలో ఫైల్‌సిస్టమ్ కార్యకలాపాలను ఎలా నిర్వహించాలో కొన్ని ప్రాథమిక ఉదాహరణలు. రస్ట్ ఇక్కడ ప్రదర్శించబడిన పద్ధతులు మరియు విధుల యొక్క సమగ్ర సేకరణను అందిస్తుంది. మరింత తెలుసుకోవడానికి డాక్యుమెంటేషన్‌ని చూడండి.
OS మాడ్యూల్ ఉపయోగించి ప్రాసెస్ మేనేజ్‌మెంట్
మీరు ఊహించినట్లుగా, సిస్టమ్‌లోని ప్రక్రియలతో పని చేయడానికి OS మాడ్యూల్ సబ్‌మాడ్యూల్స్ మరియు లక్షణాలను అందిస్తుంది.
కింది ఉదాహరణ కోడ్‌ను తీసుకోండి:
std ఉపయోగించండి :: process :: { ఆదేశం, బయటకి దారి } ;fn చేతి ( ) {
// అమలు చేయండి ls ఆదేశం
వీలు output = కమాండ్:: కొత్త ( 'ls' )
.arg ( '-ది' )
.అవుట్పుట్ ( )
.అంచనా ( 'ఆదేశాన్ని అమలు చేయడంలో విఫలమైంది' ) ;
ఉంటే output.status.success ( ) {
వీలు stdout = స్ట్రింగ్::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'కమాండ్ అవుట్పుట్: \n {}' , stdout ) ;
} లేకపోతే {
వీలు stderr = స్ట్రింగ్::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'కమాండ్ విఫలమైంది: \n {}' , stderr ) ;
బయటకి దారి ( 1 ) ;
}
}
ఇచ్చిన ఉదాహరణలో, మేము అవసరమైన మాడ్యూళ్ళను దిగుమతి చేయడం ద్వారా ప్రారంభిస్తాము. ఈ సందర్భంలో, మనకు std :: ప్రాసెస్ సబ్‌మాడ్యూల్ నుండి “కమాండ్” మరియు “నిష్క్రమణ” పద్ధతులు అవసరం.
“ls” కమాండ్‌ను అమలు చేయడానికి మరియు ఆర్గ్యుమెంట్‌లను కమాండ్‌కు పంపడానికి మేము కమాండ్:: న్యూ() ఫంక్షన్‌ను ఉపయోగిస్తాము.
విజయవంతమైతే, కమాండ్ ప్రస్తుత వర్కింగ్ డైరెక్టరీ కోసం డైరెక్టరీ జాబితాను ఈ క్రింది విధంగా అందించాలి:
ముగింపు
Linux మరియు Unix-వంటి సిస్టమ్‌లలో బహుళ ఆపరేషన్‌లను నిర్వహించడానికి std ::os మాడ్యూల్ మరియు సబ్‌మాడ్యూల్స్ అందించిన వివిధ విధులు మరియు పద్ధతులను ఎలా ఉపయోగించాలో మేము అన్వేషించాము. std ::os మాడ్యూల్ అనేది ఈ ట్యుటోరియల్‌లో ప్రదర్శించబడిన వాటి కంటే విస్తృతమైన లక్షణాల సేకరణను కలిగి ఉన్న ఒక విస్తృతమైన మాడ్యూల్ అని గుర్తుంచుకోండి.