మొజిల్లా ప్రాజెక్ట్ ద్వారా స్థాపించబడిన సిస్టమ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ రస్ట్ 1.53 విడుదల, కానీ ఇప్పుడు స్వతంత్ర లాభాపేక్ష లేని సంస్థ రస్ట్ ఫౌండేషన్ ఆధ్వర్యంలో అభివృద్ధి చేయబడింది, ప్రచురించబడింది. భాష మెమరీ భద్రతపై దృష్టి పెడుతుంది, ఆటోమేటిక్ మెమరీ నిర్వహణను అందిస్తుంది మరియు చెత్త సేకరించేవాడు లేదా రన్‌టైమ్‌ను ఉపయోగించకుండా అధిక పని సమాంతరతను సాధించడానికి మార్గాలను అందిస్తుంది (రన్‌టైమ్ ప్రాథమిక లైబ్రరీ యొక్క ప్రాథమిక ప్రారంభ మరియు నిర్వహణకు తగ్గించబడుతుంది).
రస్ట్ యొక్క ఆటోమేటిక్ మెమరీ మేనేజ్‌మెంట్ పాయింటర్‌లను మానిప్యులేట్ చేసేటప్పుడు లోపాలను తొలగిస్తుంది మరియు తక్కువ-స్థాయి మెమరీ మానిప్యులేషన్ నుండి ఉత్పన్నమయ్యే సమస్యల నుండి రక్షిస్తుంది, ఉదాహరణకు మెమరీ ప్రాంతాన్ని విడుదల చేసిన తర్వాత యాక్సెస్ చేయడం, శూన్య పాయింటర్ డెరిఫరెన్స్‌లు, బఫర్ ఓవర్‌రన్‌లు మొదలైనవి. లైబ్రరీలను పంపిణీ చేయడానికి, అసెంబ్లీని నిర్ధారించడానికి మరియు డిపెండెన్సీలను నిర్వహించడానికి, ప్రాజెక్ట్ కార్గో ప్యాకేజీ మేనేజర్‌ను అభివృద్ధి చేస్తోంది. లైబ్రరీలను హోస్ట్ చేయడానికి crates.io రిపోజిటరీకి మద్దతు ఉంది.
ప్రధాన ఆవిష్కరణలు:
- శ్రేణుల కోసం, IntoIterator లక్షణం అమలు చేయబడింది, ఇది విలువల ద్వారా శ్రేణి మూలకాల పునరావృతాన్ని నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది: i కోసం [1, 2, 3] { .. }
ఇటరేటర్లను ఆమోదించే పద్ధతులకు శ్రేణులను పాస్ చేయడం కూడా సాధ్యమే, ఉదాహరణకు: సెట్ = BTreeSet::from_iter([1, 2, 3]); కోసం (a, b) some_iterator.chain([1]).zip([1, 2, 3]) { ..}
ఇంతకుముందు, IntoIterator శ్రేణి సూచనల కోసం మాత్రమే అమలు చేయబడింది, అనగా. విలువలను మళ్ళించడానికి సూచనలు (“&[1, 2, 3]”) లేదా “[1, 2, 3].iter()”ని ఉపయోగించడం అవసరం. array.into_iter() నుండి (&array).into_iter()కి మునుపటి కంపైలర్ మార్పిడి కారణంగా ఏర్పడిన అనుకూలత సమస్యల వల్ల శ్రేణుల కోసం IntoIterator అమలుకు ఆటంకం ఏర్పడింది. ఈ సమస్యలు పరిష్కార మార్గంతో పరిష్కరించబడ్డాయి - IntoIterator లక్షణం యొక్క అమలు లేనట్లుగా కంపైలర్ array.into_iter()ని (&array).into_iter()కి మార్చడాన్ని కొనసాగిస్తుంది, కానీ ".into_iter()ని ఉపయోగించి పద్ధతిని కాల్ చేస్తున్నప్పుడు మాత్రమే )" వాక్యనిర్మాణం మరియు "ఇన్ [1, 2, 3]", "iter.zip([1, 2, 3])", "IntoIterator::into_iter([1, 2, 3]) రూపంలో కాల్‌లను తాకకుండా )".
- "|" వ్యక్తీకరణలను పేర్కొనడం సాధ్యమవుతుంది (లాజికల్ లేదా ఆపరేషన్) టెంప్లేట్ యొక్క ఏదైనా భాగంలో, ఉదాహరణకు, బదులుగా “కొన్ని(1) | కొంత(2)" మీరు ఇప్పుడు "కొన్ని(1 | 2)" అని వ్రాయవచ్చు: మ్యాచ్ ఫలితం { సరే(కొన్ని(1 | 2)) => { ..} లోపం(MyError { రకం: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. }}
- యూనికోడ్ UAX 31 స్పెసిఫికేషన్‌లో నిర్వచించబడిన ఏవైనా జాతీయ అక్షరాలతో సహా ఐడెంటిఫైయర్‌లలో ASCII కాని అక్షరాలను ఉపయోగించడం అనుమతించబడుతుంది, కానీ ఎమోజి అక్షరాలు మినహాయించబడుతుంది. మీరు విభిన్నమైన కానీ సారూప్యమైన అక్షరాలను ఉపయోగిస్తే, కంపైలర్ హెచ్చరికను జారీ చేస్తుంది. const BLÅHAJ: &str = "🦈"; struct 人 {名字: స్ట్రింగ్, } లెట్ α = 1; లెట్స్ = 2; హెచ్చరిక: ఐడెంటిఫైయర్ జత 'ｓ' మరియు 's' మధ్య గందరగోళంగా పరిగణించబడుతుంది
- APIల యొక్క కొత్త భాగం క్రింది స్థిరీకరించబడిన వాటితో సహా స్థిరమైన వర్గానికి బదిలీ చేయబడింది:
- శ్రేణి::from_ref
- శ్రేణి::from_mut
- AtomicBool::fetch_update
- AtomicPtr::fetch_update
- BTreeSet :: నిలుపుకోండి
- BTreeMap::రిటైన్
- BufReader::seek_relative
- cmp::min_by
- cmp::min_by_key
- cmp::max_by
- cmp::max_by_key
- డీబగ్‌స్ట్రక్ట్::finish_non_exhaustive
- వ్యవధి::ZERO
- వ్యవధి::MAX
- వ్యవధి::is_zero
- వ్యవధి::saturating_add
- వ్యవధి::సంతృప్త_ఉప
- వ్యవధి::సంతృప్త_ముల్
- f32:: is_subnormal
- f64:: is_subnormal
- శ్రేణుల కోసం IntoIterator
- {integer} ::BITS
- io::Error::మద్దతు లేదు
- నాన్ జీరో*:: లీడింగ్_సున్నాలు
- నాన్ జీరో*:: trailing_zeros
- ఎంపిక :: చొప్పించు
- ఆర్డరింగ్::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_uppercase
- OsStr::is_ascii
- OsStr::eq_ignore_ascii_case
- చూడదగిన::peek_mut
- Rc:: increment_strong_count
- Rc::decrement_strong_count
- స్లైస్:: IterMut:: as_slice
- స్లైస్::IterMut కోసం AsRef<[T]>
- ఇంప్ల్ స్లైస్ ఇండెక్స్ (బౌండ్ , బౌండ్ )
- వెక్:: లోపల_నుండి_పొడవండి
- wasm64-unknown-unknown ప్లాట్‌ఫారమ్‌కు మూడవ స్థాయి మద్దతు అమలు చేయబడింది. మూడవ స్థాయి ప్రాథమిక మద్దతును కలిగి ఉంటుంది, కానీ ఆటోమేటెడ్ టెస్టింగ్ లేకుండా, అధికారిక బిల్డ్‌లను ప్రచురించడం లేదా కోడ్‌ని నిర్మించవచ్చో లేదో తనిఖీ చేయడం.
- కార్గో ప్యాకేజీ నిర్వాహకుడు డిఫాల్ట్‌గా Git రిపోజిటరీ (HEAD) యొక్క ప్రధాన శాఖకు "ప్రధాన" పేరును ఉపయోగించేందుకు తరలించబడింది. మాస్టర్‌కు బదులుగా మెయిన్ అనే పేరును ఉపయోగించే రిపోజిటరీలలో హోస్ట్ చేయబడిన డిపెండెన్సీలకు ఇకపై బ్రాంచ్ = "మెయిన్" కాన్ఫిగర్ చేయవలసిన అవసరం లేదు.
- కంపైలర్‌లో, LLVM యొక్క కనీస వెర్షన్ కోసం అవసరాలు LLVM 10కి పెంచబడ్డాయి.
అదనంగా, రస్ట్ లాంగ్వేజ్‌లో కాంపోనెంట్‌లను డెవలప్ చేయడం కోసం టూల్స్ యొక్క Linux కెర్నల్‌లో ఇంటిగ్రేషన్ డెవలప్‌మెంట్ కోసం నిధుల కేటాయింపును మేము గమనించవచ్చు. ISRG సంస్థ (ఇంటర్నెట్ సెక్యూరిటీ రీసెర్చ్ గ్రూప్) ఆధ్వర్యంలో ప్రోస్సిమో ప్రాజెక్ట్ ఫ్రేమ్‌వర్క్‌లో పని జరుగుతుంది, ఇది లెట్స్ ఎన్‌క్రిప్ట్ ప్రాజెక్ట్ స్థాపకుడు మరియు HTTPS మరియు భద్రతను పెంచడానికి సాంకేతికతల అభివృద్ధిని ప్రోత్సహిస్తుంది. అంతర్జాలం. రస్ట్-ఫర్-లైనక్స్ ప్రాజెక్ట్ రచయిత మిగ్యుల్ ఓజెడా యొక్క పని కోసం Google ఈ నిధులను అందిస్తుంది. గతంలో, ISRG మరియు Google కర్ల్ యుటిలిటీ కోసం ప్రత్యామ్నాయ HTTP బ్యాకెండ్‌ను రూపొందించడానికి మరియు Apache http సర్వర్ కోసం కొత్త TLS మాడ్యూల్ అభివృద్ధికి ఇప్పటికే నిధులు సమకూర్చాయి.
మైక్రోసాఫ్ట్ మరియు గూగుల్ ప్రకారం, దాదాపు 70% దుర్బలత్వాలు అసురక్షిత మెమరీ నిర్వహణ వలన సంభవిస్తాయి. పరికర డ్రైవర్ల వంటి కెర్నల్ భాగాలను అభివృద్ధి చేయడానికి రస్ట్ భాషని ఉపయోగించడం వలన అసురక్షిత మెమరీ నిర్వహణ వలన కలిగే దుర్బలత్వాల ప్రమాదాన్ని తగ్గిస్తుంది మరియు మెమరీ ప్రాంతాన్ని విడుదల చేసిన తర్వాత యాక్సెస్ చేయడం మరియు బఫర్ హద్దులను అధిగమించడం వంటి లోపాలను తొలగిస్తుంది.
రిఫరెన్స్ చెకింగ్, ఆబ్జెక్ట్ యాజమాన్యం మరియు ఆబ్జెక్ట్ లైఫ్‌టైమ్ (స్కోప్)ను ట్రాక్ చేయడం, అలాగే కోడ్ అమలు సమయంలో మెమరీ యాక్సెస్ యొక్క ఖచ్చితత్వాన్ని మూల్యాంకనం చేయడం ద్వారా కంపైల్ సమయంలో మెమరీ-సేఫ్ హ్యాండ్లింగ్ రస్ట్‌లో అందించబడుతుంది. రస్ట్ పూర్ణాంకాల ఓవర్‌ఫ్లోల నుండి రక్షణను కూడా అందిస్తుంది, ఉపయోగించే ముందు వేరియబుల్ విలువలను తప్పనిసరిగా ప్రారంభించడం అవసరం, ప్రామాణిక లైబ్రరీలో లోపాలను మెరుగ్గా నిర్వహిస్తుంది, డిఫాల్ట్‌గా మార్పులేని సూచనలు మరియు వేరియబుల్స్ భావనను వర్తింపజేస్తుంది, లాజికల్ లోపాలను తగ్గించడానికి బలమైన స్టాటిక్ టైపింగ్‌ను అందిస్తుంది.
మూలం: opennet.ru