റസ്റ്റ് 1.61 പ്രോഗ്രാമിംഗ് ലാംഗ്വേജ് റിലീസ്

മോസില്ല പ്രോജക്റ്റ് സ്ഥാപിച്ചതും എന്നാൽ ഇപ്പോൾ സ്വതന്ത്ര ലാഭേച്ഛയില്ലാത്ത സംഘടനയായ റസ്റ്റ് ഫൗണ്ടേഷന്റെ കീഴിൽ വികസിപ്പിച്ചതുമായ റസ്റ്റ് 1.61 പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ പ്രകാശനം പ്രസിദ്ധീകരിച്ചു. ഭാഷ മെമ്മറി സുരക്ഷയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുകയും ഗാർബേജ് കളക്ടറിന്റെയും റൺടൈമിന്റെയും ഉപയോഗം ഒഴിവാക്കിക്കൊണ്ട് ഉയർന്ന ജോലി സമാന്തരത കൈവരിക്കുന്നതിനുള്ള മാർഗങ്ങൾ നൽകുകയും ചെയ്യുന്നു (റൺടൈം അടിസ്ഥാന ലൈബ്രറിയുടെ അടിസ്ഥാന സമാരംഭവും പരിപാലനവും ആയി ചുരുക്കിയിരിക്കുന്നു).

റസ്റ്റിന്റെ മെമ്മറി ഹാൻഡ്‌ലിംഗ് രീതികൾ പോയിന്ററുകൾ കൈകാര്യം ചെയ്യുമ്പോഴുള്ള പിശകുകളിൽ നിന്ന് ഡെവലപ്പറെ രക്ഷിക്കുകയും ലോ-ലെവൽ മെമ്മറി ഹാൻഡ്‌ലിംഗ് കാരണം ഉണ്ടാകുന്ന പ്രശ്‌നങ്ങളിൽ നിന്ന് സംരക്ഷിക്കുകയും ചെയ്യുന്നു, അതായത് മെമ്മറി ഏരിയ സ്വതന്ത്രമാക്കിയതിന് ശേഷം ആക്‌സസ് ചെയ്യുക, നൾ പോയിന്ററുകൾ ഒഴിവാക്കുക, ബഫർ ഓവർറൺ മുതലായവ. ലൈബ്രറികൾ വിതരണം ചെയ്യുന്നതിനും ബിൽഡുകൾ നൽകുന്നതിനും ഡിപൻഡൻസികൾ കൈകാര്യം ചെയ്യുന്നതിനും, പ്രോജക്റ്റ് കാർഗോ പാക്കേജ് മാനേജർ വികസിപ്പിക്കുന്നു. ലൈബ്രറികൾ ഹോസ്റ്റുചെയ്യുന്നതിന് crates.io റിപ്പോസിറ്ററി പിന്തുണയ്ക്കുന്നു.

റഫറൻസ് പരിശോധന, ഒബ്‌ജക്റ്റ് ഉടമസ്ഥതയുടെ ട്രാക്ക് സൂക്ഷിക്കൽ, ഒബ്‌ജക്റ്റ് ലൈഫ് ടൈം (സ്കോപ്പുകൾ) ട്രാക്ക് ചെയ്യൽ, കോഡ് എക്‌സിക്യൂഷൻ സമയത്ത് മെമ്മറി ആക്‌സസിന്റെ കൃത്യത വിലയിരുത്തൽ എന്നിവയിലൂടെ കംപൈൽ സമയത്ത് റസ്റ്റിൽ മെമ്മറി സുരക്ഷ നൽകുന്നു. റസ്റ്റ് പൂർണ്ണസംഖ്യ ഓവർഫ്ലോയ്‌ക്കെതിരെ സംരക്ഷണം നൽകുന്നു, ഉപയോഗിക്കുന്നതിന് മുമ്പ് വേരിയബിൾ മൂല്യങ്ങൾ നിർബന്ധമായും ആരംഭിക്കേണ്ടതുണ്ട്, സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ പിശകുകൾ നന്നായി കൈകാര്യം ചെയ്യുന്നു, സ്ഥിരസ്ഥിതിയായി മാറ്റമില്ലാത്ത റഫറൻസുകളുടെയും വേരിയബിളുകളുടെയും ആശയം പ്രയോഗിക്കുന്നു, ലോജിക്കൽ പിശകുകൾ കുറയ്ക്കുന്നതിന് ശക്തമായ സ്റ്റാറ്റിക് ടൈപ്പിംഗ് വാഗ്ദാനം ചെയ്യുന്നു.

പ്രധാന കണ്ടുപിടുത്തങ്ങൾ:

• പ്രധാന ഫംഗ്ഷനിൽ നിന്ന് നിങ്ങളുടെ സ്വന്തം റിട്ടേൺ കോഡുകൾ നിർവചിക്കുന്നത് സാധ്യമാണ്. യഥാർത്ഥത്തിൽ, റസ്റ്റിന്റെ പ്രധാന ഫംഗ്‌ഷന് "()" (യൂണിറ്റ്) തരം മാത്രമേ നൽകാനാകൂ, അത് ഡെവലപ്പർ "പ്രോസസ്:: എക്‌സിറ്റ്(കോഡ്)" ഫംഗ്‌ഷൻ എന്ന് വ്യക്തമായി വിളിക്കുന്നില്ലെങ്കിൽ എല്ലായ്‌പ്പോഴും വിജയകരമായ എക്‌സിറ്റ് നിലയെ സൂചിപ്പിക്കുന്നു. റസ്റ്റ് 1.26-ൽ, പ്രധാന ഫംഗ്‌ഷനിലെ അസ്ഥിരമായ ടെർമിനേഷൻ സ്വഭാവം ഉപയോഗിച്ച്, C പ്രോഗ്രാമുകളിലെ EXIT_SUCCESS, EXIT_FAILURE കോഡുകൾക്ക് അനുസൃതമായ "Ok", "Err" എന്നീ മൂല്യങ്ങൾ തിരികെ നൽകാൻ സാധിച്ചു. റസ്റ്റ് 1.61-ൽ, ടെർമിനേഷൻ സ്വഭാവം സുസ്ഥിരമാക്കി, ഒരു പ്രത്യേക റിട്ടേൺ കോഡിനെ പ്രതിനിധീകരിക്കുന്നതിന് ഒരു പ്രത്യേക എക്സിറ്റ്കോഡ് തരം നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു, ഇത് മുൻകൂട്ടി നിശ്ചയിച്ച സ്ഥിരാങ്കങ്ങളായ SUCCESS and FailURE, കൂടാതെ രീതി മുതൽ പ്ലാറ്റ്ഫോം-നിർദ്ദിഷ്ട റിട്ടേൺ തരങ്ങളെ സംഗ്രഹിക്കുന്നു. ഒരു ഇഷ്‌ടാനുസൃത റിട്ടേൺ കോഡ് തിരികെ നൽകാൻ. std:: process:: ExitCode ഉപയോഗിക്കുക; fn main() -> ExitCode {if !check_foo() {Return ExitCode::from(8); } ExitCode::SUCCESS }
• "const fn" എന്ന പദപ്രയോഗം ഉപയോഗിച്ച് നിർവചിച്ചിരിക്കുന്ന ഫംഗ്‌ഷനുകളുടെ അധിക കഴിവുകൾ സ്ഥിരപ്പെടുത്തിയിരിക്കുന്നു, ഇത് സാധാരണ ഫംഗ്‌ഷനുകൾ എന്ന് മാത്രമല്ല, സ്ഥിരാങ്കങ്ങൾക്ക് പകരം ഏത് സന്ദർഭത്തിലും ഉപയോഗിക്കാനും കഴിയും. ഈ ഫംഗ്ഷനുകൾ കംപൈൽ സമയത്താണ് കണക്കാക്കുന്നത്, റൺടൈമിൽ അല്ല, അതിനാൽ അവ സ്ഥിരാങ്കങ്ങളിൽ നിന്ന് മാത്രം വായിക്കാനുള്ള കഴിവ് പോലുള്ള ചില നിയന്ത്രണങ്ങൾക്ക് വിധേയമാണ്. പുതിയ പതിപ്പിൽ, കോൺസ്റ്റ് ഫംഗ്‌ഷനുകൾക്കുള്ളിൽ ഫംഗ്‌ഷൻ പോയിന്ററുകളുള്ള അടിസ്ഥാന പ്രവർത്തനങ്ങൾ അനുവദനീയമാണ് (പോയിന്ററുകൾ സൃഷ്‌ടിക്കാനും പാസിംഗ് ചെയ്യാനും കാസ്‌റ്റുചെയ്യാനും അനുവാദമുണ്ട്, പക്ഷേ പോയിന്റർ ഉപയോഗിച്ച് ഒരു ഫംഗ്‌ഷനെ വിളിക്കുന്നില്ല); ടി: കോപ്പി പോലുള്ള കോൺസ്റ്റ് ഫംഗ്‌ഷനുകളുടെ ജനറിക് പാരാമീറ്ററുകൾക്കുള്ള സ്വഭാവ പരിധികൾ; ചലനാത്മകമായി അയയ്‌ക്കാവുന്ന സ്വഭാവസവിശേഷതകൾ (dyn Trait); ഫംഗ്‌ഷൻ ആർഗ്യുമെന്റുകൾക്കും റിട്ടേൺ മൂല്യങ്ങൾക്കുമുള്ള ഇംപ്ൽ സ്വഭാവ തരങ്ങൾ.
• std::io എന്നതിലെ Stdin, Stdout, Stderr എന്നിവയെ സ്ട്രീം കൈകാര്യം ചെയ്യുന്നു, ലോക്ക് ചെയ്‌തിരിക്കുമ്പോൾ ഇപ്പോൾ സ്റ്റാറ്റിക് ലൈഫ് ടൈം ("'സ്റ്റാറ്റിക്") ഉണ്ട്, "let out = std::io::stdout().lock();" ഒരു ഹാൻഡിൽ ലഭിക്കുകയും ഒരു എക്സ്പ്രഷനിൽ ഒരു ലോക്ക് സജ്ജീകരിക്കുകയും ചെയ്യുക.
• API-യുടെ ഒരു പുതിയ ഭാഗം സ്ഥിരതയുള്ള വിഭാഗത്തിലേക്ക് നീക്കി, സ്വഭാവസവിശേഷതകളുടെ രീതികളും നടപ്പിലാക്കലുകളും സുസ്ഥിരമാക്കിയിരിക്കുന്നു:
  • പിൻ::static_mut
  • പിൻ::static_ref
  • Vec::retain_mut
  • VecDeque::retain_mut
  • കഴ്‌സറിനായി എഴുതുക<[u8; N]>
  • 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 and <*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

കൂടാതെ, ഫേംവെയറിൽ ഉപയോഗിക്കുന്ന Xous മൈക്രോകെർണൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ വികസന വേളയിൽ 100 ​​ആയിരം വരി കോഡ് എഴുതിയതിന് ശേഷം റസ്റ്റ് ഭാഷയുടെ ഇംപ്രഷനുകളുടെ സംഗ്രഹത്തോടുകൂടിയ “റസ്റ്റ്: എ ക്രിട്ടിക്കൽ റിട്രോസ്‌പെക്റ്റീവ്” എന്ന ലേഖനം നിങ്ങൾക്ക് ശ്രദ്ധിക്കാം. പോരായ്മകളിൽ, മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടുള്ള വാക്യഘടന, അപൂർണ്ണതയും ഭാഷയുടെ തുടർച്ചയായ വികസനവും, ആവർത്തിക്കാവുന്ന ബിൽഡുകളുടെ അഭാവം, Crates.io-യിലെ ഡിപൻഡൻസി ട്രസ്റ്റിന്റെ സാധാരണ പ്രശ്നങ്ങൾ, സുരക്ഷിത കോഡ് എഴുതാൻ ഒരു നിശ്ചിത അച്ചടക്കം പാലിക്കേണ്ടതിന്റെ ആവശ്യകത എന്നിവ ഉൾപ്പെടുന്നു. ദ്രുതഗതിയിലുള്ള പ്രോട്ടോടൈപ്പിംഗ് സമയത്ത് കോഡ് റീഫാക്റ്ററിംഗ് ചെയ്യുന്നതിനും "ഹാക്കുകൾ" പുനർനിർമ്മിക്കുന്നതിനുമുള്ള ടൂളുകൾ പ്രതീക്ഷകളെ കവിഞ്ഞ സവിശേഷതകളിൽ ഉൾപ്പെടുന്നു.

അവലംബം: opennet.ru