Rust 1.61 ការចេញផ្សាយភាសាសរសេរកម្មវិធី

ការចេញផ្សាយភាសាកម្មវិធីគោលបំណងទូទៅ Rust 1.61 ដែលបង្កើតឡើងដោយគម្រោង Mozilla ប៉ុន្តែឥឡូវនេះត្រូវបានបង្កើតឡើងក្រោមការឧបត្ថម្ភពីអង្គការមិនរកប្រាក់ចំណេញឯករាជ្យ Rust Foundation ត្រូវបានបោះពុម្ពផ្សាយ។ ភាសាផ្តោតលើសុវត្ថិភាពនៃការចងចាំ និងផ្តល់នូវមធ្យោបាយដើម្បីសម្រេចបាននូវភាពស្របគ្នានៃការងារខ្ពស់ ខណៈពេលដែលជៀសវាងការប្រើប្រាស់ឧបករណ៍ប្រមូលសំរាម និងពេលដំណើរការ (ម៉ោងរត់ត្រូវបានកាត់បន្ថយទៅជាការចាប់ផ្តើមជាមូលដ្ឋាន និងការថែទាំបណ្ណាល័យស្តង់ដារ)។

វិធីសាស្ត្រគ្រប់គ្រងអង្គចងចាំរបស់ Rust ជួយសង្រ្គោះអ្នកអភិវឌ្ឍន៍ពីកំហុសនៅពេលរៀបចំទ្រនិច និងការពារពីបញ្ហាដែលកើតឡើងដោយសារការគ្រប់គ្រងអង្គចងចាំកម្រិតទាប ដូចជាការចូលប្រើតំបន់អង្គចងចាំបន្ទាប់ពីវាត្រូវបានដោះលែង ការពន្យារទ្រនិចចង្អុលទទេ ការដំណើរការលើសចំណុះ។ល។ ដើម្បីចែកចាយបណ្ណាល័យ ផ្តល់ការកសាង និងគ្រប់គ្រងភាពអាស្រ័យ គម្រោងអភិវឌ្ឍកម្មវិធីគ្រប់គ្រងកញ្ចប់ទំនិញ។ ឃ្លាំង crates.io ត្រូវបានគាំទ្រសម្រាប់ការបង្ហោះបណ្ណាល័យ។

សុវត្ថិភាពនៃអង្គចងចាំត្រូវបានផ្តល់ជូននៅក្នុង Rust នៅពេលចងក្រងតាមរយៈការត្រួតពិនិត្យឯកសារយោង ការរក្សាដាននៃភាពជាម្ចាស់វត្ថុ ការតាមដានអាយុកាលរបស់វត្ថុ (វិសាលភាព) និងការវាយតម្លៃភាពត្រឹមត្រូវនៃការចូលប្រើអង្គចងចាំអំឡុងពេលដំណើរការកូដ។ ច្រែះក៏ផ្តល់ការការពារប្រឆាំងនឹងចំនួនគត់លើសចំណុះ ទាមទារការចាប់ផ្តើមចាំបាច់នៃតម្លៃអថេរមុនពេលប្រើ ដោះស្រាយកំហុសបានប្រសើរជាងនៅក្នុងបណ្ណាល័យស្តង់ដារ អនុវត្តគោលគំនិតនៃសេចក្តីយោងដែលមិនអាចផ្លាស់ប្តូរបាន និងអថេរតាមលំនាំដើម ផ្តល់នូវការវាយអក្សរឋិតិវន្តខ្លាំង ដើម្បីកាត់បន្ថយកំហុសឡូជីខល។

ការច្នៃប្រឌិតសំខាន់ៗ៖

• វាអាចធ្វើទៅបានដើម្បីកំណត់លេខកូដត្រឡប់មកវិញរបស់អ្នកពីមុខងារចម្បង។ ដើមឡើយ មុខងារចម្បងរបស់ Rust អាចត្រឡប់តែប្រភេទ "()" (ឯកតា) ដែលតែងតែបង្ហាញពីស្ថានភាពចេញដោយជោគជ័យ លុះត្រាតែអ្នកអភិវឌ្ឍន៍បានហៅមុខងារ "ដំណើរការ::ចេញ(កូដ)" យ៉ាងច្បាស់។ នៅក្នុង Rust 1.26 ដោយប្រើលក្ខណៈបញ្ចប់មិនស្ថិតស្ថេរនៅក្នុងមុខងារចម្បង វាអាចត្រឡប់តម្លៃ “Ok” និង “Err” ដែលត្រូវនឹងលេខកូដ EXIT_SUCCESS និង EXIT_FAILURE នៅក្នុងកម្មវិធី C។ នៅក្នុង Rust 1.61 លក្ខណៈនៃការបញ្ចប់ត្រូវបានធ្វើឱ្យមានស្ថេរភាព ហើយប្រភេទ ExitCode ដាច់ដោយឡែកមួយត្រូវបានស្នើឡើងដើម្បីតំណាងឱ្យលេខកូដត្រឡប់មកវិញជាក់លាក់ ដែលអរូបីប្រភេទនៃការត្រឡប់មកវិញជាក់លាក់នៃវេទិកាដោយផ្តល់នូវចំនួនថេរដែលបានកំណត់ជាមុននូវភាពជោគជ័យ និងបរាជ័យ និងពីវិធីសាស្ត្រ ដើម្បីត្រឡប់លេខកូដត្រឡប់ផ្ទាល់ខ្លួន។ ប្រើ std::process::ExitCode; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(8); } លេខកូដចេញ៖:ជោគជ័យ }
• សមត្ថភាពបន្ថែមនៃមុខងារដែលបានកំណត់ដោយប្រើកន្សោម "const fn" ត្រូវបានធ្វើឱ្យមានស្ថេរភាព ដែលអាចត្រូវបានគេហៅថាមិនត្រឹមតែជាមុខងារធម្មតាប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងប្រើក្នុងបរិបទណាមួយជំនួសឱ្យថេរ។ មុខងារទាំងនេះត្រូវបានគណនានៅពេលចងក្រង មិនមែនពេលដំណើរការទេ ដូច្នេះពួកវាត្រូវទទួលរងការរឹតបន្តឹងមួយចំនួន ដូចជាសមត្ថភាពក្នុងការអានតែពីថេរ។ នៅក្នុងកំណែថ្មី ប្រតិបត្តិការជាមូលដ្ឋានជាមួយនឹងទ្រនិចមុខងារត្រូវបានអនុញ្ញាតនៅក្នុងមុខងារ const (ការបង្កើត ឆ្លងកាត់ និងបញ្ជូនទ្រនិចត្រូវបានអនុញ្ញាត ប៉ុន្តែមិនហៅមុខងារដោយទ្រនិច); trait bounds សម្រាប់ប៉ារ៉ាម៉ែត្រទូទៅនៃអនុគមន៍ const ដូចជា T: Copy; លក្ខណៈដែលអាចបញ្ជូនបានដោយថាមវន្ត (dyn Trait); impl ប្រភេទលក្ខណៈសម្រាប់អាគុយម៉ង់មុខងារ និងតម្លៃត្រឡប់។
• ស្ទ្រីមគ្រប់គ្រង Stdin, Stdout និង Stderr នៅក្នុង std::io ឥឡូវនេះមានអាយុកាលឋិតិវន្ត ("'static") នៅពេលចាក់សោ ដែលអនុញ្ញាតឱ្យមានការសាងសង់ដូចជា "let out = std::io::stdout().lock();" ជាមួយនឹងការទទួលបានចំណុចទាញ និងកំណត់សោនៅក្នុងកន្សោមមួយ។
• ផ្នែកថ្មីនៃ API ត្រូវបានផ្លាស់ទីទៅប្រភេទនៃស្ថេរភាព រួមទាំងវិធីសាស្រ្ត និងការអនុវត្តលក្ខណៈត្រូវបានធ្វើឱ្យមានស្ថេរភាព៖
  • ម្ជុល៖:static_mut
  • ម្ជុល៖:static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • សរសេរសម្រាប់ទស្សន៍ទ្រនិច<[u8; ន]>
  • std::os::unix::net::SocketAddr::from_pathname
  • std ::process::ExitCode
  • std::process::ការបញ្ចប់
  • 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

លើសពីនេះទៀត អ្នកអាចកត់សម្គាល់អត្ថបទ "Rust: A Critical Retrospective" ជាមួយនឹងសេចក្តីសង្ខេបនៃការចាប់អារម្មណ៍នៃភាសា Rust បន្ទាប់ពីសរសេរកូដ 100 ពាន់បន្ទាត់នៅក្នុងវាកំឡុងពេលបង្កើតប្រព័ន្ធប្រតិបត្តិការ Xous microkernel ដែលប្រើក្នុងកម្មវិធីបង្កប់។ គុណវិបត្តិរួមមានវាក្យសម្ព័ន្ធពិបាកយល់ ភាពមិនពេញលេញ និងការអភិវឌ្ឍន៍ភាសាបន្ត កង្វះការស្ថាបនាឡើងវិញ បញ្ហាធម្មតាជាមួយការជឿទុកចិត្តលើការពឹងផ្អែកនៅក្នុង Crates.io និងតម្រូវការដើម្បីរក្សាវិន័យជាក់លាក់មួយដើម្បីសរសេរកូដសុវត្ថិភាព។ លក្ខណៈពិសេសដែលលើសពីការរំពឹងទុករួមមានឧបករណ៍សម្រាប់ refactoring code និង reworking "hacks" បានបន្ថែមក្នុងអំឡុងពេល prototyping យ៉ាងឆាប់រហ័ស។

ប្រភព: opennet.ru