રસ્ટ 1.53 રિલીઝ. Google Linux કર્નલમાં રસ્ટ સપોર્ટ ઉમેરવા માટે ભંડોળ આપશે

સિસ્ટમ પ્રોગ્રામિંગ લેંગ્વેજ રસ્ટ 1.53, મોઝિલા પ્રોજેક્ટ દ્વારા સ્થપાયેલી, પરંતુ હવે સ્વતંત્ર બિન-લાભકારી સંસ્થા રસ્ટ ફાઉન્ડેશનના આશ્રય હેઠળ વિકસિત, પ્રકાશિત કરવામાં આવી છે. ભાષા મેમરી સલામતી પર ધ્યાન કેન્દ્રિત કરે છે, સ્વચાલિત મેમરી મેનેજમેન્ટ પ્રદાન કરે છે, અને ગાર્બેજ કલેક્ટર અથવા રનટાઈમનો ઉપયોગ કર્યા વિના ઉચ્ચ કાર્ય સમાનતા પ્રાપ્ત કરવાના માધ્યમો પૂરા પાડે છે (રનટાઇમ મૂળભૂત પ્રારંભ અને પ્રમાણભૂત લાઇબ્રેરીની જાળવણી માટે ઘટાડવામાં આવે છે).

રસ્ટનું ઓટોમેટિક મેમરી મેનેજમેન્ટ પોઈન્ટર્સની હેરફેર કરતી વખતે ભૂલોને દૂર કરે છે અને લો-લેવલ મેમરી મેનીપ્યુલેશનથી ઊભી થતી સમસ્યાઓ સામે રક્ષણ આપે છે, જેમ કે મેમરી રિજનને મુક્ત કર્યા પછી એક્સેસ કરવું, નલ પોઈન્ટર ડિરેફરન્સ, બફર ઓવરરન્સ વગેરે. લાઇબ્રેરીઓનું વિતરણ કરવા, એસેમ્બલીની ખાતરી કરવા અને નિર્ભરતાઓનું સંચાલન કરવા માટે, પ્રોજેક્ટ કાર્ગો પેકેજ મેનેજર વિકસાવી રહ્યો છે. crates.io રીપોઝીટરી હોસ્ટિંગ લાઈબ્રેરીઓ માટે આધારભૂત છે.

મુખ્ય નવીનતાઓ:

• એરે માટે, IntoIterator લક્ષણ અમલમાં મૂકવામાં આવ્યું છે, જે તમને મૂલ્યો દ્વારા એરે તત્વોના પુનરાવર્તનને ગોઠવવા માટે પરવાનગી આપે છે: i માટે [1, 2, 3] { .. }

  પુનરાવર્તકોને સ્વીકારતી પદ્ધતિઓ પર એરે પસાર કરવાનું પણ શક્ય છે, ઉદાહરણ તરીકે: let set = BTreeSet::from_iter([1, 2, 3]); some_iterator.chain([1]).zip([1, 2, 3]) માં (a, b) માટે { .. }

  પહેલાં, IntoIterator માત્ર એરે સંદર્ભો માટે જ લાગુ કરવામાં આવ્યું હતું, એટલે કે. મૂલ્યો પર પુનરાવર્તન કરવા માટે સંદર્ભોનો ઉપયોગ જરૂરી છે (“&[1, 2, 3]”) અથવા “[1, 2, 3].iter()”. array.into_iter() થી (&array).into_iter() માં અગાઉના કમ્પાઇલર રૂપાંતરણને કારણે સુસંગતતા સમસ્યાઓ દ્વારા એરે માટે IntoIterator ના અમલીકરણમાં અવરોધ આવ્યો હતો. આ સમસ્યાઓનું નિરાકરણ વર્કઅરાઉન્ડ સાથે કરવામાં આવ્યું હતું - કમ્પાઇલર array.into_iter() ને (&array).into_iter() માં કન્વર્ટ કરવાનું ચાલુ રાખશે જાણે કે IntoIterator લક્ષણનો કોઈ અમલ ન હોય, પરંતુ માત્ર ત્યારે જ જ્યારે ".into_iter( નો ઉપયોગ કરીને પદ્ધતિને કૉલ કરો. )" વાક્યરચના અને "[1, 2, 3] માં", "iter.zip([1, 2, 3])", "IntoIterator::into_iter([1, 2, 3]) સ્વરૂપમાં કૉલ્સને સ્પર્શ કર્યા વિના )"

• "|" અભિવ્યક્તિઓનો ઉલ્લેખ કરવો શક્ય છે. (તાર્કિક અથવા કામગીરી) નમૂનાના કોઈપણ ભાગમાં, ઉદાહરણ તરીકે, “Some(1) | Some(2)" તમે હવે "Some(1 | 2)" લખી શકો છો: મેચ પરિણામ { Ok(Some(1 | 2)) => {.. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• યુનિકોડ UAX 31 સ્પષ્ટીકરણમાં વ્યાખ્યાયિત કોઈપણ રાષ્ટ્રીય અક્ષરો સહિત ઓળખકર્તાઓમાં બિન-ASCII અક્ષરોના ઉપયોગની પરવાનગી છે, પરંતુ ઇમોજી અક્ષરોને બાદ કરતા. જો તમે જુદા જુદા પરંતુ સમાન અક્ષરોનો ઉપયોગ કરો છો, તો કમ્પાઈલર ચેતવણી આપશે. const BLÅHAJ: &str = "🦈"; રચના 人 { 名字: શબ્દમાળા, } ચાલો α = 1; let'os = 2; ચેતવણી: ઓળખકર્તા જોડી 'ｓ' અને 's' વચ્ચે ગૂંચવણભરી માનવામાં આવે છે
• API નો એક નવો ભાગ સ્થિર કેટેગરીમાં સ્થાનાંતરિત કરવામાં આવ્યો છે, જેમાં નીચેના સ્ટેબિલાઇઝ્ડ છે:
  • array::from_ref
  • array::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BfReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • અવધિ::ZERO
  • અવધિ::MAX
  • અવધિ::શૂન્ય છે
  • અવધિ::સંતૃપ્ત_ઉમેરો
  • અવધિ::સંતૃપ્ત_સબ
  • અવધિ::સંતૃપ્ત_મૂલ
  • f32::is_subnormal
  • f64::is_subnormal
  • એરે માટે IntoIterator
  • {પૂર્ણાંક}::BITS
  • io::ભૂલ::અનસમર્થિત
  • નોનઝીરો*::લીડિંગ_ઝીરો
  • નોનઝીરો*::ટ્રાઇલિંગ_ઝીરો
  • વિકલ્પ::ઇનસર્ટ
  • ક્રમ::is_eq
  • ક્રમ::is_ne
  • ઑર્ડરિંગ::is_lt
  • ઑર્ડરિંગ::is_gt
  • ક્રમ::is_le
  • ઓર્ડર કરી રહ્યા છીએ::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_અપરકેસ
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • પીકેબલ::પીક_મટ
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • સ્લાઈસ::IterMut::as_slice
  • સ્લાઇસ માટે AsRef<[T]>::IterMut
  • માટે impl SliceIndex (બાઉન્ડ , બંધાયેલ )
  • Vec::extend_from_within
• wasm64-unknown-unknown પ્લેટફોર્મ માટે સમર્થનનું ત્રીજું સ્તર લાગુ કરવામાં આવ્યું છે. ત્રીજા સ્તરમાં મૂળભૂત આધારનો સમાવેશ થાય છે, પરંતુ સ્વયંસંચાલિત પરીક્ષણ વિના, સત્તાવાર બિલ્ડ પ્રકાશિત કરવા અથવા કોડ બનાવી શકાય છે કે કેમ તે તપાસ્યા વિના.
• કાર્ગો પેકેજ મેનેજરને મૂળભૂત રીતે ગિટ રિપોઝીટરી (HEAD) ની મુખ્ય શાખા માટે "મુખ્ય" નામનો ઉપયોગ કરવા માટે ખસેડવામાં આવ્યો છે. રીપોઝીટરીઝમાં હોસ્ટ કરેલ અવલંબન કે જે master ને બદલે main નામનો ઉપયોગ કરે છે તેને હવે રૂપરેખાંકિત કરવા માટે branch = "main" ની જરૂર નથી.
• કમ્પાઈલરમાં, LLVM ના ન્યૂનતમ સંસ્કરણ માટેની આવશ્યકતાઓને વધારીને LLVM 10 કરવામાં આવે છે.

વધુમાં, અમે રસ્ટ ભાષામાં ઘટકો વિકસાવવા માટેના સાધનોના Linux કર્નલમાં એકીકરણના વિકાસ માટે ભંડોળની જોગવાઈની નોંધ લઈ શકીએ છીએ. આ કામ ISRG સંસ્થા (ઇન્ટરનેટ સિક્યુરિટી રિસર્ચ ગ્રૂપ) ના આશ્રય હેઠળ પ્રોસિમો પ્રોજેક્ટના માળખામાં હાથ ધરવામાં આવશે, જે લેટ્સ એન્ક્રિપ્ટ પ્રોજેક્ટના સ્થાપક છે અને HTTPS ને પ્રોત્સાહિત કરે છે અને સુરક્ષાને વધારવા માટે ટેકનોલોજીના વિકાસને પ્રોત્સાહન આપે છે. ઈન્ટરનેટ. Google દ્વારા ભંડોળ પૂરું પાડવામાં આવશે, જે રસ્ટ-ફોર-લિનક્સ પ્રોજેક્ટના લેખક મિગુએલ ઓજેડાના કામ માટે ચૂકવણી કરશે. અગાઉ, ISRG અને Google એ curl ઉપયોગિતા માટે વૈકલ્પિક HTTP બેકએન્ડ બનાવવા અને Apache HTTP સર્વર માટે નવા TLS મોડ્યુલના વિકાસ માટે પહેલેથી જ ભંડોળ પૂરું પાડ્યું છે.

માઈક્રોસોફ્ટ અને ગૂગલના જણાવ્યા અનુસાર, લગભગ 70% નબળાઈઓ અસુરક્ષિત મેમરી હેન્ડલિંગને કારણે થાય છે. એવી અપેક્ષા રાખવામાં આવે છે કે ઉપકરણ ડ્રાઇવરો જેવા કર્નલ ઘટકો વિકસાવવા માટે રસ્ટ ભાષાનો ઉપયોગ અસુરક્ષિત મેમરી હેન્ડલિંગને કારણે થતી નબળાઈઓનું જોખમ ઘટાડશે અને તેને મુક્ત કર્યા પછી મેમરી વિસ્તારને ઍક્સેસ કરવા અને બફર બાઉન્ડ્સને ઓવરરન કરવા જેવી ભૂલોને દૂર કરશે.

કમ્પાઈલ સમયે રસ્ટમાં રેફરન્સ ચેકિંગ, ઑબ્જેક્ટની માલિકી અને ઑબ્જેક્ટ લાઇફટાઇમ (સ્કોપ)નો ટ્રૅક રાખવા તેમજ કોડ એક્ઝિક્યુશન દરમિયાન મેમરી એક્સેસની સાચીતાના મૂલ્યાંકન દ્વારા મેમરી-સેફ હેન્ડલિંગ પ્રદાન કરવામાં આવે છે. રસ્ટ પણ પૂર્ણાંક ઓવરફ્લો સામે રક્ષણ પૂરું પાડે છે, ઉપયોગ કરતા પહેલા ચલ મૂલ્યોની ફરજિયાત શરૂઆતની જરૂર છે, પ્રમાણભૂત લાઇબ્રેરીમાં ભૂલોને વધુ સારી રીતે હેન્ડલ કરે છે, ડિફોલ્ટ રૂપે અપરિવર્તનશીલ સંદર્ભો અને ચલોનો ખ્યાલ લાગુ કરે છે, લોજિકલ ભૂલોને ઘટાડવા માટે મજબૂત સ્ટેટિક ટાઇપિંગ પ્રદાન કરે છે.

સોર્સ: opennet.ru