Rust 1.61 Programming Language Release

ພາສາການຂຽນໂປລແກລມທີ່ມີຈຸດປະສົງທົ່ວໄປ Rust 1.61, ສ້າງຕັ້ງຂຶ້ນໂດຍໂຄງການ Mozilla ແຕ່ໃນປັດຈຸບັນໄດ້ຮັບການພັດທະນາພາຍໃຕ້ການອຸປະຖໍາຂອງອົງການເອກະລາດທີ່ບໍ່ຫວັງຜົນກໍາໄລ Rust Foundation, ໄດ້ຖືກປ່ອຍອອກມາ. ພາສາທີ່ເນັ້ນໃສ່ຄວາມປອດໄພຂອງຄວາມຊົງຈໍາແລະສະຫນອງວິທີການເພື່ອບັນລຸຄວາມຂະຫນານຂອງວຽກສູງໃນຂະນະທີ່ຫຼີກເວັ້ນການນໍາໃຊ້ເຄື່ອງເກັບຂີ້ເຫຍື້ອແລະເວລາແລ່ນ (runtime ຫຼຸດລົງເປັນພື້ນຖານເບື້ອງຕົ້ນແລະການຮັກສາຫ້ອງສະຫມຸດມາດຕະຖານ).

ວິທີການຈັດການຫນ່ວຍຄວາມຈໍາຂອງ Rust ຊ່ວຍປະຢັດນັກພັດທະນາຈາກຄວາມຜິດພາດໃນເວລາທີ່ manipulating pointers ແລະປ້ອງກັນບັນຫາທີ່ເກີດຂື້ນເນື່ອງຈາກການຈັດການຫນ່ວຍຄວາມຈໍາລະດັບຕ່ໍາ, ເຊັ່ນ: ການເຂົ້າເຖິງພື້ນທີ່ຫນ່ວຍຄວາມຈໍາຫຼັງຈາກທີ່ມັນໄດ້ຖືກປົດປ່ອຍ, dereferencing null pointers, buffer overruns, ແລະອື່ນໆ. ເພື່ອແຈກຢາຍຫ້ອງສະຫມຸດ, ສະຫນອງການກໍ່ສ້າງແລະການຄຸ້ມຄອງການເພິ່ງພາອາໄສ, ໂຄງການພັດທະນາຜູ້ຈັດການຊຸດສິນຄ້າ. ຄັງເກັບ crates.io ໄດ້ຮັບການສະຫນັບສະຫນູນສໍາລັບການເປັນເຈົ້າພາບຫ້ອງສະຫມຸດ.

ຄວາມປອດໄພຂອງຫນ່ວຍຄວາມຈໍາແມ່ນສະຫນອງໃຫ້ຢູ່ໃນ Rust ໃນເວລາລວບລວມໂດຍຜ່ານການກວດສອບການອ້າງອິງ, ການຕິດຕາມຄວາມເປັນເຈົ້າຂອງວັດຖຸ, ການຕິດຕາມອາຍຸຂອງວັດຖຸ (ຂອບເຂດ), ແລະການປະເມີນຄວາມຖືກຕ້ອງຂອງການເຂົ້າເຖິງຫນ່ວຍຄວາມຈໍາໃນລະຫວ່າງການປະຕິບັດລະຫັດ. Rust ຍັງສະຫນອງການປ້ອງກັນການ overflows integer, ຮຽກຮ້ອງໃຫ້ມີການເລີ່ມຕົ້ນບັງຄັບຂອງຄ່າຕົວແປກ່ອນການນໍາໃຊ້, ຈັດການຄວາມຜິດພາດທີ່ດີກວ່າໃນຫ້ອງສະຫມຸດມາດຕະຖານ, ນໍາໃຊ້ແນວຄວາມຄິດຂອງການອ້າງອິງ immutable ແລະຕົວແປໂດຍຄ່າເລີ່ມຕົ້ນ, ສະຫນອງການພິມຄົງທີ່ທີ່ເຂັ້ມແຂງເພື່ອຫຼຸດຜ່ອນຄວາມຜິດພາດຢ່າງມີເຫດຜົນ.

ນະວັດຕະກໍາຕົ້ນຕໍ:

• ມັນເປັນໄປໄດ້ທີ່ຈະກໍານົດລະຫັດກັບຄືນຂອງທ່ານເອງຈາກຫນ້າທີ່ຕົ້ນຕໍ. ໃນເບື້ອງຕົ້ນ, ຫນ້າທີ່ຕົ້ນຕໍຂອງ Rust ສາມາດສົ່ງຄືນພຽງແຕ່ປະເພດ "()" (ຫນ່ວຍ), ເຊິ່ງສະເຫມີຊີ້ໃຫ້ເຫັນເຖິງສະຖານະການອອກສົບຜົນສໍາເລັດເວັ້ນເສຍແຕ່ວ່ານັກພັດທະນາເອີ້ນວ່າ "ຂະບວນການ:: ອອກ (ລະຫັດ)" ຟັງຊັນ. ໃນ Rust 1.26, ການນໍາໃຊ້ລັກສະນະການສິ້ນສຸດທີ່ບໍ່ຫມັ້ນຄົງໃນຫນ້າທີ່ຕົ້ນຕໍ, ມັນເປັນໄປໄດ້ທີ່ຈະສົ່ງຄືນຄ່າ "Ok" ແລະ "Err", ທີ່ສອດຄ້ອງກັນກັບລະຫັດ EXIT_SUCCESS ແລະ EXIT_FAILURE ໃນໂປຣແກຣມ C. ໃນ Rust 1.61, ລັກສະນະການສິ້ນສຸດໄດ້ຖືກເຮັດໃຫ້ມີຄວາມຫມັ້ນຄົງ, ແລະປະເພດ ExitCode ແຍກຕ່າງຫາກໄດ້ຖືກສະເຫນີໃຫ້ເປັນຕົວແທນຂອງລະຫັດຜົນຕອບແທນສະເພາະ, ເຊິ່ງ abstracts ປະເພດຜົນຕອບແທນສະເພາະຂອງແພລະຕະຟອມໂດຍການສະຫນອງຄ່າຄົງທີ່ທີ່ກໍານົດໄວ້ກ່ອນ SUCCESS ແລະ FAILURE, ແລະວິທີການຈາກ. ເພື່ອສົ່ງຄືນລະຫັດສົ່ງຄືນແບບກຳນົດເອງ. ໃຊ້ std::process::ExitCode; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(8); } ExitCode::SUCCESS }
• ຄວາມສາມາດເພີ່ມເຕີມຂອງຫນ້າທີ່ກໍານົດໂດຍໃຊ້ຄໍາເວົ້າ "const fn" ໄດ້ຖືກສະຖຽນລະພາບ, ເຊິ່ງສາມາດເອີ້ນວ່າບໍ່ພຽງແຕ່ຫນ້າທີ່ປົກກະຕິ, ແຕ່ຍັງໃຊ້ໃນສະພາບການໃດກໍ່ຕາມແທນທີ່ຈະເປັນຄ່າຄົງທີ່. ຟັງຊັນເຫຼົ່ານີ້ຖືກຄິດໄລ່ໃນເວລາລວບລວມ, ບໍ່ແມ່ນໃນເວລາແລ່ນ, ດັ່ງນັ້ນພວກມັນມີຂໍ້ຈໍາກັດບາງຢ່າງເຊັ່ນຄວາມສາມາດໃນການອ່ານພຽງແຕ່ຈາກຄ່າຄົງທີ່. ໃນສະບັບໃຫມ່, ການດໍາເນີນງານພື້ນຖານທີ່ມີຕົວຊີ້ຟັງຊັນແມ່ນອະນຸຍາດໃຫ້ຢູ່ໃນຫນ້າທີ່ const (ການສ້າງ, ການຖ່າຍທອດແລະການໂຍນຕົວຊີ້ແມ່ນອະນຸຍາດໃຫ້, ແຕ່ບໍ່ໃຫ້ໂທຫາຫນ້າທີ່ໂດຍຕົວຊີ້); trait bounds ສໍາລັບຕົວກໍານົດການທົ່ວໄປຂອງຫນ້າທີ່ const ເຊັ່ນ T: Copy; ລັກສະນະທີ່ສາມາດສົ່ງໄດ້ແບບເຄື່ອນໄຫວ (dyn Trait); impl ປະເພດລັກສະນະສໍາລັບການໂຕ້ຖຽງຟັງຊັນແລະຄ່າກັບຄືນ.
• ການຖ່າຍທອດຈັດການ Stdin, Stdout ແລະ Stderr ໃນ std::io ຕອນນີ້ມີອາຍຸຄົງທີ່ ("'static") ເມື່ອຖືກລັອກ, ອະນຸຍາດໃຫ້ມີໂຄງສ້າງເຊັ່ນ "let out = std::io::stdout().lock();" ກັບການໄດ້ຮັບມືຈັບແລະກໍານົດ lock ໃນຫນຶ່ງສະແດງອອກ.
• ພາກສ່ວນໃຫມ່ຂອງ API ໄດ້ຖືກຍ້າຍໄປຢູ່ໃນປະເພດຂອງຄວາມຫມັ້ນຄົງ, ລວມທັງວິທີການແລະການຈັດຕັ້ງປະຕິບັດລັກສະນະຕ່າງໆແມ່ນມີຄວາມຫມັ້ນຄົງ:
  • PIN::static_mut
  • ປັກໝຸດ::static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • ຂຽນສໍາລັບຕົວກະພິບ<[u8; ນ]>
  • std::os::unix::net::SocketAddr::from_pathname
  • std::process::ExitCode
  • std::ຂະບວນການ::ການສິ້ນສຸດ
  • std::thread::JoinHandle::is_finished
• ຄຸນລັກສະນະ "const", ເຊິ່ງກໍານົດຄວາມເປັນໄປໄດ້ຂອງການນໍາໃຊ້ມັນໃນສະພາບການໃດກໍ່ຕາມແທນທີ່ຈະເປັນຄ່າຄົງທີ່, ຖືກນໍາໃຊ້ໃນຫນ້າທີ່:
  • <*const T>::offset ແລະ <*mut T>::offset
  • <*const T>::wrapping_offset ແລະ <*mut T>::wrapping_offset
  • <*const T>::add ແລະ <*mut T>::add
  • <*const T>::sub ແລະ <*mut T>::sub
  • <*const T>::wrapping_add ແລະ <*mut T>::wrapping_add
  • <*const T>::wrapping_sub ແລະ <*mut T>::wrapping_sub
  • <[T]>::as_mut_ptr
  • <[T]>::as_ptr_range
  • <[T]>::as_mut_ptr_range

ນອກຈາກນັ້ນ, ທ່ານສາມາດສັງເກດບົດຄວາມ "Rrust: A Critical Retrospective" ໂດຍສະຫຼຸບຄວາມປະທັບໃຈຂອງພາສາ Rust ຫຼັງຈາກການຂຽນລະຫັດ 100 ພັນເສັ້ນໃນມັນໃນລະຫວ່າງການພັດທະນາລະບົບປະຕິບັດການ Xous microkernel ທີ່ໃຊ້ໃນເຟີມແວ. ຂໍ້ເສຍລວມເຖິງ syntax ຍາກທີ່ຈະເຂົ້າໃຈ, ຄວາມບໍ່ຄົບຖ້ວນແລະການພັດທະນາຢ່າງຕໍ່ເນື່ອງຂອງພາສາ, ການຂາດການສ້າງຊ້ໍາກັນ, ບັນຫາປົກກະຕິກ່ຽວກັບຄວາມໄວ້ວາງໃຈໃນ Crates.io, ແລະຄວາມຕ້ອງການທີ່ຈະຮັກສາລະບຽບວິໄນທີ່ແນ່ນອນເພື່ອຂຽນລະຫັດທີ່ປອດໄພ. ຄຸນນະສົມບັດທີ່ເກີນຄວາມຄາດຫວັງປະກອບມີເຄື່ອງມືສໍາລັບການ refactoring ລະຫັດແລະ reworking "hacks" ເພີ່ມໃນລະຫວ່າງການ prototyping ຢ່າງໄວວາ.

ແຫຼ່ງຂໍ້ມູນ: opennet.ru