Rust இல், std ::os தொகுதியானது இயக்க முறைமையின் செயல்பாட்டின் மீது சுருக்கத்தை வழங்குகிறது. சூழல் மாறிகள், கோப்பு முறைமை செயல்பாடுகள், செயல்முறை மேலாண்மை மற்றும் பலவற்றுடன் பணிபுரிய அடிப்படை இயங்குதளத்துடன் தொடர்பு கொள்ள இது நம்மை அனுமதிக்கிறது.
இந்த எடுத்துக்காட்டில், Rust std ::os தொகுதியைப் பயன்படுத்தி Unix இல் நீங்கள் செய்யக்கூடிய சில அடிப்படை செயல்பாடுகளை நாங்கள் உள்ளடக்குவோம்.
இது ஒரு விரிவான தொகுதி என்பதை நினைவில் கொள்வது நல்லது, மேலும் இது பல்வேறு Unix தொடர்பான செயல்பாடுகளுக்கான பல வகைகள் மற்றும் செயல்பாடுகளை கொண்டுள்ளது. எனவே, தொடர்புடைய செயல்முறைகள் பற்றிய குறிப்புக்கான ஆவணங்களைக் கவனியுங்கள்.
லினக்ஸில் ரஸ்ட் ஓஎஸ்
லினக்ஸில், ரஸ்டில் உள்ள std::os தொகுதியின் துணைத் தொகுதியான std::os::unix module மூலம் வழங்கப்படும் Unix-குறிப்பிட்ட செயல்பாடுகள் மற்றும் வகைகளை நாம் அணுகலாம்.
இந்த தொகுதி ரஸ்ட் நிலையான நூலகத்தின் ஒரு பகுதியாகும், எனவே நீங்கள் எந்த வெளிப்புற கிரேட் அல்லது சார்புகளையும் நிறுவ வேண்டியதில்லை.
இந்த தொகுதியிலிருந்து ஒரு லினக்ஸ் கணினியில் நாம் மேற்கொள்ளக்கூடிய சில அடிப்படை 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 ) ;
}
// குறிப்பிட்ட சூழல் மாறியை அணுகவும் என ஒரு ` ஆஸ்ஸ்ட்ரிங் `
என்றால் அனுமதிக்க சில ( மதிப்பு ) = env::var_us ( 'HOSTTYPE' ) {
// மாற்றவும் ` ஆஸ்ஸ்ட்ரிங் ` ஒரு ` லேசான கயிறு ` என்றால் தேவை
என்றால் அனுமதிக்க சில ( மதிப்பு_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 செயல்பாட்டைப் பயன்படுத்தி குறிப்பிட்ட சூழல் மாறிகளையும் நாம் அணுகலாம். இது ஒரு
இதன் விளைவாக வெளியீடு பின்வருமாறு:
WAYLAND_DISPLAY =வழிப்பாதை- 0HOSTYPE =x86_64
OS தொகுதியைப் பயன்படுத்தி FS செயல்பாடுகள்
நீங்கள் யூகிக்க முடியும் என, OS தொகுதி பல்வேறு செயல்பாடுகள் மற்றும் கோப்பு முறைமை தொடர்பான செயல்பாடுகளைச் செய்வதற்கான முறைகளை வழங்குகிறது.
லினக்ஸில் std::os தொகுதியைப் பயன்படுத்தி நாம் செய்யக்கூடிய பல்வேறு செயல்பாடுகளை விளக்கும் பின்வரும் நிரலை எடுத்துக் கொள்ளுங்கள்:
std ஐப் பயன்படுத்தவும் :: fs;fn கை ( ) {
// படிக்க ஏ கோப்பு
என்றால் அனுமதிக்க சரி ( உள்ளடக்கங்கள் ) = 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 தொகுதியைப் பயன்படுத்தி லினக்ஸில் கோப்பு முறைமை செயல்பாடுகளை எவ்வாறு செய்வது என்பதற்கான சில அடிப்படை எடுத்துக்காட்டுகள் வழங்கப்பட்டுள்ளன. ரஸ்ட் இங்கே நிரூபிக்கப்பட்ட முறைகள் மற்றும் செயல்பாடுகளின் விரிவான தொகுப்பை வழங்குகிறது. மேலும் அறிய ஆவணங்களைப் பார்க்கவும்.
OS தொகுதியைப் பயன்படுத்தி செயல்முறை மேலாண்மை
நீங்கள் யூகிக்க முடியும் என, OS தொகுதியானது கணினியில் உள்ள செயல்முறைகளுடன் பணிபுரிய துணை தொகுதிகள் மற்றும் அம்சங்களை வழங்குகிறது.
பின்வரும் உதாரணக் குறியீட்டை எடுத்துக் கொள்ளுங்கள்:
std ஐப் பயன்படுத்தவும் :: செயல்முறை :: { கட்டளை, வெளியேறு } ;fn கை ( ) {
// இயக்கவும் ls கட்டளை
அனுமதிக்க வெளியீடு = கட்டளை:: புதியது ( 'ls' )
.arg ( '-தி' )
.வெளியீடு ( )
.எதிர்பார்க்கிறேன் ( 'கட்டளையை செயல்படுத்துவதில் தோல்வி' ) ;
என்றால் வெளியீடு.நிலை.வெற்றி ( ) {
அனுமதிக்க stdout = சரம்:: from_utf8_lossy ( & output.stdout ) ;
println ! ( 'கட்டளை வெளியீடு: \n {}' , stdout ) ;
} வேறு {
அனுமதிக்க stderr = சரம்:: from_utf8_lossy ( & output.stderr ) ;
அச்சிடுதல் ! ( 'கட்டளை தோல்வியடைந்தது: \n {}' , stderr ) ;
வெளியேறு ( 1 ) ;
}
}
கொடுக்கப்பட்ட எடுத்துக்காட்டில், தேவையான தொகுதிகளை இறக்குமதி செய்வதன் மூலம் தொடங்குகிறோம். இந்த வழக்கில், நமக்கு std :: process submodule இலிருந்து 'கட்டளை' மற்றும் 'வெளியேறு' முறைகள் தேவை.
“ls” கட்டளையை இயக்கவும், கட்டளைக்கு வாதங்களை அனுப்பவும் கட்டளை:: புதிய () செயல்பாட்டைப் பயன்படுத்துகிறோம்.
வெற்றியடைந்தால், கட்டளையானது தற்போதைய வேலை செய்யும் கோப்பகத்திற்கான கோப்பகப் பட்டியலைப் பின்வருமாறு வழங்க வேண்டும்:
முடிவுரை
Linux மற்றும் Unix போன்ற அமைப்புகளில் பல செயல்பாடுகளைச் செய்ய, std ::os தொகுதி மற்றும் துணைத் தொகுதிகள் வழங்கும் பல்வேறு செயல்பாடுகள் மற்றும் முறைகளை எவ்வாறு பயன்படுத்துவது என்பதை நாங்கள் ஆராய்ந்தோம். std ::os தொகுதி என்பது இந்த டுடோரியலில் காட்டப்பட்டுள்ள அம்சங்களை விட பரந்த அளவிலான அம்சங்களைக் கொண்ட ஒரு விரிவான தொகுதி என்பதை நினைவில் கொள்ளவும்.