ใน Rust โมดูล std::os นำเสนอสิ่งที่เป็นนามธรรมเหนือฟังก์ชันการทำงานของระบบปฏิบัติการ ช่วยให้เราสามารถโต้ตอบกับระบบปฏิบัติการพื้นฐานเพื่อทำงานกับตัวแปรสภาพแวดล้อม การทำงานของระบบไฟล์ การจัดการกระบวนการ และอื่นๆ
ในตัวอย่างนี้ เราจะกล่าวถึงการดำเนินการพื้นฐานบางอย่างที่คุณสามารถทำได้บน Unix โดยใช้โมดูล Rust std::os
เป็นการดีที่ต้องจำไว้ว่านี่เป็นโมดูลที่ครอบคลุมและมีประเภทและฟังก์ชันมากมายสำหรับการดำเนินการที่เกี่ยวข้องกับ Unix ดังนั้น โปรดพิจารณาเอกสารสำหรับอ้างอิงเกี่ยวกับกระบวนการที่เกี่ยวข้อง
ระบบปฏิบัติการสนิมใน Linux
ใน Linux เราสามารถเข้าถึงฟังก์ชันและประเภทเฉพาะของ Unix ที่ให้บริการโดยโมดูล std::os::unix ซึ่งเป็นโมดูลย่อยของโมดูล std::os ใน Rust
โมดูลนี้เป็นส่วนหนึ่งของไลบรารีมาตรฐานของ Rust และด้วยเหตุนี้คุณจึงไม่ต้องการให้คุณติดตั้งลังภายนอกหรือการอ้างอิงใดๆ
ให้เราพูดถึง API พื้นฐานและการดำเนินการบางอย่างที่เราสามารถทำได้บนระบบ Linux จากโมดูลนี้
การเข้าถึงตัวแปรสภาพแวดล้อม
เราสามารถเข้าถึงตัวแปรสภาพแวดล้อมโดยใช้โมดูล std::env ตัวอย่างเช่น std::env::var(“PATH”) ดึงค่าของตัวแปรสภาพแวดล้อม PATH
พิจารณาโปรแกรมตัวอย่างต่อไปนี้:
ใช้ std::env;ใช้ std::ffi::OsString;
มือฉ ( ) {
// เข้าถึงตัวแปรสภาพแวดล้อมเฉพาะ
ถ้า อนุญาต ตกลง ( ค่า ) = env::var ( 'WAYLAND_DISPLAY' ) {
พิมพ์ ! ( 'WAYLAND_DISPLAY={}' , ค่า ) ;
}
// วนซ้ำตัวแปรสภาพแวดล้อมทั้งหมด
สำหรับ ( คีย์, ค่า ) ใน env::wars_us ( ) {
อนุญาต key_string = key.to_string_lossy ( ) ;
อนุญาต value_string = ค่า.to_string_lossy ( ) ;
พิมพ์ ! ( '{}:{}' ,key_string,value_string ) ;
}
// เข้าถึงตัวแปรสภาพแวดล้อมเฉพาะ เช่น หนึ่ง ` ออสสตริง `
ถ้า อนุญาต บาง ( ค่า ) = env::var_us ( 'ประเภทโฮสต์' ) {
// แปลง ` ออสสตริง ` ถึง ก ` สตริง ` ถ้า จำเป็น
ถ้า อนุญาต บาง ( ค่า_str ) = value.to_str ( ) {
พิมพ์ ! ( 'ประเภทโฮสต์={}' ,value_str ) ;
}
}
}
ในตัวอย่างที่ให้มา เราเริ่มต้นด้วยการนำเข้าโมดูลที่จำเป็น ในกรณีนี้ เราสนใจ std::env และ std::ff::OsString
ในการเข้าถึงตัวแปรสภาพแวดล้อมเฉพาะ เราสามารถใช้ฟังก์ชัน env::var และส่งผ่านชื่อของค่าที่เราต้องการดึงข้อมูล ในกรณีนี้ เราจะได้ค่าของตัวแปร WAYLAND_DISPLAY
ฟังก์ชันส่งคืนค่าของตัวแปรเป็นประเภทผลลัพธ์
เรายังสามารถวนซ้ำตัวแปรสภาพแวดล้อมทั้งหมดโดยใช้ฟังก์ชัน env::vars_os ซึ่งจะส่งคืนตัววนซ้ำพร้อมคู่คีย์-ค่าของตัวแปรสภาพแวดล้อม โปรดทราบว่าค่าจะถูกส่งกลับเป็นประเภท OsString จากนั้นเราสามารถแปลงเป็นค่าสตริงได้โดยใช้ฟังก์ชัน to_string_lossy
เรายังสามารถเข้าถึงตัวแปรสภาพแวดล้อมเฉพาะได้โดยใช้ฟังก์ชัน env::var_os สิ่งนี้ควรส่งคืนประเภท
ผลลัพธ์ที่ได้จะเป็นดังนี้:
WAYLAND_DISPLAY =เวย์แลนด์- 0โฮสต์ =x86_64
การดำเนินการ FS โดยใช้โมดูล OS
อย่างที่คุณเดาได้ โมดูล OS มีฟังก์ชันและวิธีการต่างๆ เพื่อดำเนินการเกี่ยวกับระบบไฟล์
ใช้โปรแกรมต่อไปนี้ที่สาธิตการดำเนินการต่างๆ ที่เราสามารถทำได้โดยใช้โมดูล std::os ใน Linux:
ใช้ std::fs;มือฉ ( ) {
// อ่าน ไฟล์
ถ้า อนุญาต ตกลง ( เนื้อหา ) = fs::read_to_string ( '/โฮม/เดเบียน/.bashrc' ) {
พิมพ์ ! ( 'ทุบตี: {}' เนื้อหา ) ;
}
// สร้างไดเร็กทอรีใหม่
ถ้า อนุญาต เอ่อ ( ผิดพลาด ) = fs::create_dir ( '/โฮม/เดเบียน/new_dir' ) {
eprintln ! ( 'สร้างไดเร็กทอรีไม่สำเร็จ: {}' ผิดพลาด ) ;
}
// ลบ ก ไฟล์
ถ้า อนุญาต เอ่อ ( ผิดพลาด ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'ไม่สามารถลบไฟล์: {}' ผิดพลาด ) ;
}
}
จากตัวอย่าง เราสาธิตวิธีอ่านเนื้อหาของไฟล์โดยใช้เมธอด fs::read_to_string() เมธอดใช้พาธไปยังไฟล์เป้าหมายและส่งคืนเนื้อหาไฟล์เป็นสตริง
เรายังสามารถสร้างไดเร็กทอรีใหม่โดยใช้ฟังก์ชัน fs::create_dir() และส่งพาธไปยังไดเร็กทอรีเป้าหมายเป็นพารามิเตอร์
สุดท้าย เราสามารถลบไฟล์ที่ต้องการโดยใช้ฟังก์ชัน fs::remove_file() และส่งไฟล์เป้าหมายเป็นพารามิเตอร์
บันทึก: ตัวอย่างที่ให้มาเป็นตัวอย่างพื้นฐานเกี่ยวกับวิธีการดำเนินการกับระบบไฟล์บน Linux โดยใช้โมดูล std::fs สนิมมีชุดของวิธีการและฟังก์ชันที่ครอบคลุมซึ่งแสดงไว้ที่นี่ โปรดดูเอกสารประกอบเพื่อเรียนรู้เพิ่มเติม
การจัดการกระบวนการโดยใช้โมดูล OS
อย่างที่คุณเดาได้ โมดูล OS มีโมดูลย่อยและคุณลักษณะต่างๆ เพื่อทำงานร่วมกับกระบวนการต่างๆ ในระบบ
ใช้รหัสตัวอย่างต่อไปนี้:
ใช้ std::process:: { สั่งการ, ทางออก } ;มือฉ ( ) {
// เรียกใช้ ล สั่งการ
อนุญาต เอาต์พุต = คำสั่ง :: ใหม่ ( 'ล' )
.arg ( '-ที่' )
.เอาต์พุต ( )
.คาดหวัง ( 'ล้มเหลวในการดำเนินการคำสั่ง' ) ;
ถ้า เอาต์พุต สถานะ ความสำเร็จ ( ) {
อนุญาต stdout = สตริง :: from_utf8_lossy ( & output.stdout ) ;
พิมพ์ ! ( 'เอาต์พุตคำสั่ง: \n {}' แย่จัง ) ;
} อื่น {
อนุญาต stderr = สตริง::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'คำสั่งล้มเหลว: \n {}' ,สเตรเดอร์ ) ;
ทางออก ( 1 ) ;
}
}
ในตัวอย่างที่กำหนด เราเริ่มต้นด้วยการนำเข้าโมดูลที่จำเป็น ในกรณีนี้ เราต้องการเมธอด 'command' และ 'exit' จากโมดูลย่อย std::process
จากนั้นเราจะใช้ฟังก์ชัน Command::new() เพื่อเรียกใช้คำสั่ง “ls” และส่งอาร์กิวเมนต์ไปยังคำสั่ง
หากสำเร็จ คำสั่งควรส่งคืนรายการไดเร็กทอรีสำหรับไดเร็กทอรีการทำงานปัจจุบันดังนี้:
บทสรุป
เราได้สำรวจวิธีการใช้ฟังก์ชันและวิธีการต่างๆ ที่ได้รับจากโมดูล std::os และโมดูลย่อยเพื่อดำเนินการหลายอย่างในระบบที่คล้าย Linux และ Unix โปรดจำไว้ว่าโมดูล std::os เป็นโมดูลที่กว้างขวางซึ่งมีชุดคุณลักษณะที่กว้างกว่าโมดูลที่สาธิตในบทช่วยสอนนี้