Rustik programlama dili hangi yılda ortaya çıktı? Nereden başlamalı · Rust programlama dili. Programlama dili sözdizimi

Rust'ta yeniyim ama hızla favori programlama dilim haline geliyor. Rust'ta küçük projeler yazmak genellikle daha az ergonomik ve daha uzun sürüyor olsa da (en azından direksiyondayken), program tasarımı hakkındaki düşüncemi zorluyor. Yeni bir şey öğrendikten sonra derleyiciyle olan kavgalarım daha az oluyor.

Rust topluluğu son zamanlarda çabalarının çoğunu Tokio kütüphanesi biçiminde uygulanan eşzamansız I/O'ya odakladı. Ve bu harika.

Web sunucuları ve ilgili şeylerle çalışmamış olan topluluk üyelerinin çoğu, neyi başarmak istediğimiz konusunda net değil. 1.0 gün önce bu konular tartışıldığında benim de bu konu hakkında belirsiz bir fikrim vardı, daha önce bu konu üzerinde hiç çalışmamıştım.

• Ne olduğunu - Eşzamansız G/Ç?
• Koroutinler nedir? eşyordamlar )?
• Hafif iplikler nelerdir( hafif iplikler )?

Gelecek nedir?( vadeli işlemler )?

• Birbirlerine nasıl uyuyorlar?

Size bir beslemeyi indiren küçük bir programın nasıl yazılacağını göstereceğim ( beslemek) JSON formatında, notların bir listesini ayrıştırır ve konsolda biçimlendirilmiş bir biçimde görüntüler.

Bizim için her şey çok kısa bir kodla sonuçlandı. Nasıl? Kesiğin altına bak.

Güvenli olmayan anahtar kelime, Rust dilinin tasarımının ayrılmaz bir parçasıdır. Bu konuya aşina olmayanlar için, güvensiz, basit bir ifadeyle, tür denetimini atlamanın bir yolu olan bir anahtar kelimedir( tip kontrolü) Pas, paslanma.

Güvenli olmayan anahtar kelimenin varlığı ilk başta birçok kişi için sürprizdir. Aslında programların bellek hatalarından dolayı çökmemesi Rust'un bir özelliği değil mi? Eğer bu doğruysa neden tip sistemini atlamanın kolay bir yolu var? Bu bir dil tasarımı hatası gibi görünebilir.

Yine de bana göre güvensiz olmak bir dezavantaj değil. Aslında dilin önemli bir parçasıdır. güvensiz bir tür kaçış valfi görevi görür - bu, tip sistemini basit durumlarda kullanabileceğimiz, ancak yine de kodunuzda kullanmak istediğiniz her türlü akıllı numaraya izin verebileceğimiz anlamına gelir. Sizden yalnızca bu teknikleri (güvenli olmayan kod) güvenli harici soyutlamaların arkasına saklamanızı istiyoruz.

Bu not, güvensiz anahtar kelimesini ve sınırlı "güvensizlik" fikrini tanıtmaktadır. Aslında bu biraz sonra yazmayı umduğum bir notun habercisi. Güvenli olmayan kodda nelerin yapılabileceğini ve yapılamayacağını belirten Rust'un bellek modelini tartışıyor.

Rust'a yeni başlayan biri olarak dizeleri temsil etmenin farklı yolları konusunda kafam karışmıştı. Rust diliyle ilgili kitabın, örneklerde üç farklı türde dize değişkeni kullanan Referanslar ve Ödünç Alma adlı bir bölümü vardır: String, &String ve &str.

str ve String arasındaki farkla başlayalım: String genişletilebilir, yığın tahsisli bir veri yapısıdır; str ise değişmez, sabit uzunlukta bir dizedir. bir yerde akılda.

Birçok programcı nesne yönelimli dillerde nasıl programlanacağını zaten biliyor. Rust, klasik bir nesne yönelimli dil değildir ancak içinde temel OOP araçları kullanılabilir.

Bu yazıda Rust'ta OOP tarzında nasıl programlama yapılacağına bakacağız. Bunu bir örnek kullanarak yapacağız: Bir eğitim görevinde bir sınıf hiyerarşisi oluşturacağız.

Görevimiz geometrik şekillerle çalışmak. Bunları ekranda metin halinde görüntüleyip alanlarını hesaplayacağız. Şekil setimiz dikdörtgen, kare, elips ve dairedir.

Rust, diğer birçok popüler dilden biraz farklı olan zarif bir dildir. Örneğin, sınıfları ve kalıtımı kullanmak yerine Rust, kendi özelliğe dayalı tür sistemini sunuyor. Ancak Rust'la tanışmaya başlayan birçok programcının (benim gibi) genel kabul görmüş tasarım kalıplarına aşina olmadığına inanıyorum.

Bu yazımda tasarım modelini tartışmak istiyorum. yeni tip(yenitip) ve ayrıca tür dönüşümüne yardımcı olan From ve Into özellikleri.

Son zamanlarda tasarım kalıpları ve programlamada kullandığımız teknikler hakkında çok düşünüyorum. Bir projeyi keşfetmeye başlamak ve daha önce birçok kez gördüğünüz tanıdık kalıpları ve stilleri görmek gerçekten harika. Bu, projenin anlaşılmasını kolaylaştırır ve işin hızlandırılmasını mümkün kılar.

Bazen yeni bir proje üzerinde çalışıyorsunuz ve bir şeyi önceki projede yaptığınız gibi yapmanız gerektiğini fark ediyorsunuz. Bu bir işlevsellik ya da kütüphane parçası olmayabilir, düzgün bir makroya ya da küçük bir kaba sığdırılamayacak bir şey olabilir. Sorunu iyi çözen basit bir tasarım modeli veya yapısal konsept olabilir.

Bu tür problemlere sıklıkla uygulanan ilginç bir model "Sonlu Durum Makinesi"dir. Bu ifadenin tam olarak ne anlama geldiğini ve neden bu kadar ilginç olduğunu anlamak için biraz zaman ayırmanızı öneririm.

Aşağıda Rust programlama dilinde taşıma, kopyalama ve ödünç alma işlemlerinin grafiksel bir açıklaması bulunmaktadır. Temel olarak bu kavramlar Rust'a özeldir ve genellikle yeni başlayanlar için tökezleyen bir engeldir.

Karışıklığı önlemek için metni minimumda tutmaya çalıştım. Bu not çeşitli eğitimlerin yerini almaz ve yalnızca görsel bilgilerin algılanmasının daha kolay olduğuna inananlar için hazırlanmıştır. Rust'u yeni öğrenmeye başlıyorsanız ve bu grafikleri yararlı buluyorsanız, kavramları güçlendirmeye yardımcı olması için kodunuzu benzer grafiklerle işaretlemenizi öneririm.

Peano sayılarını kullanarak doğal sayı aritmetiğini uygulamak, programlama öğretiminde popüler bir görevdir. Bunları Rust'ta uygulamanın mümkün olup olmadığını merak ediyordum.

Bu nedenle benim görevim, tip kontrolü ile doğal sayıları yazmak ve eklemek.

Wikipedia'ya göre, "Peano'nun aksiyomları, 19. yüzyılda İtalyan matematikçi Giuseppe Peano tarafından ortaya atılan, doğal sayılar için aksiyom sistemlerinden biridir."

Doğal sayıları girip kullanabileceğiniz iki tanesiyle ilgileniyoruz:

• 1 bir doğal sayıdır
• Doğal sayıdan sonra gelen sayı da bir doğal sayıdır.

Bunu aynen pas kullanarak yazalım:

1 2 3 4

enum Nat(Sıfır, Succ(Nat))

Nat ya sıfırdır ya da bir sonraki doğal sayıdır.

Yorum: Futures-rs projesi yeniden düzenlendi ve birçok şeyin adı değiştirildi. Mümkün oldukça linkler güncellendi.

Vadeli işlemlere başlama

Bu belge, vadeli işlemlerin ve iş parçacıklarının sıfır maliyetli uygulamalarını sağlayan Rust için vadeli işlem programlama dili kapsayıcısını keşfetmenize yardımcı olacaktır. Vadeli işlemler C++, Java ve Scala gibi diğer birçok programlama dilinde mevcuttur ve vadeli işlemler kapsayıcısı bu dillerin kütüphanelerinden ilham alır. Bununla birlikte, ergonomiktir ve aynı zamanda Rust'un doğasında bulunan sıfır maliyetli soyutlama felsefesine de uygundur: gelecekleri oluşturmak ve oluşturmak için hiçbir bellek tahsisine gerek yoktur ve bunları yöneten Görev için yalnızca bir tahsis gereklidir. Vadeli işlemlerin Rust'taki eşzamansız, şekillendirilebilir, yüksek performanslı I/O'nun temeli olması amaçlanıyor ve erken performans ölçümleri, vadeli işlemler üzerine kurulu basit bir HTTP sunucusunun gerçekten hızlı olduğunu gösteriyor.

Bu belgeler birkaç bölüme ayrılmıştır:

• "Selam Dünya!";
• gelecek türü;
• Akış yazın;
• belirli vadeli işlemler ve akış (Akış);
• vadeli işlemleri iade etmek;
• Görev ve gelecek;
• yerel görev verileri.

Yorum: Futures-rs projesi yeniden düzenlendi ve birçok şeyin adı değiştirildi. Mümkün oldukça linkler güncellendi.

Rust ekosistemindeki en büyük boşluklardan biri hızlı ve verimliydi eşzamansız G/Ç. Mio kütüphanesinden sağlam bir temele sahibiz, ancak bu çok düşük seviyeli: durum makinelerini manuel olarak oluşturmamız ve geri aramalarla denge kurmamız gerekiyor.

Daha iyi ergonomiye sahip, daha üst düzey bir şey istiyoruz, ancak bunun da iyi bir özelliği var. şekillendirilebilirlik birlikte çalışan eşzamansız soyutlamalardan oluşan bir ekosistemi destekler. Kulağa çok tanıdık geliyor: Uygulamada da aynı amaç güdülüyordu vadeli işlemler(veya vaatler) birçok dilde sözdizimsel şekeri formda destekler eşzamansız/beklemede yukarıda.

İşlemciler tarafından desteklenen ilkel tamsayı türleri, gerçek hayatta işlemeye alışık olduğumuz sonsuz tamsayılar kümesinin sınırlı bir yaklaşımıdır. Bu sınırlı gösterim her zaman "gerçek" sayılarla eşleşmez, örneğin 255_u8 + 1 == 0 . Çoğu zaman programcı bu farkı unutur ve bu da kolayca hatalara yol açabilir.

Rust, hatalara karşı dayanıklı olmayı amaçlayan, bunların en sinsisini (bellek hataları) önlemeye odaklanan, aynı zamanda programcının diğer sorunlardan kaçınmasına yardımcı olmaya çalışan bir programlama dilidir: hataların göz ardı edilmesi ve göreceğimiz gibi tamsayı taşmaları.

Demir hakkında biraz

Iron, Rust programlama dilinde yazılmış ve başka bir tanınmış kütüphane olan hyper'ın üzerine inşa edilmiş üst düzey bir web çerçevesidir. Iron, Rust'un bize sağladığı tüm avantajlardan yararlanmak üzere tasarlandı. Iron, çekirdeğindeki işlemlerin engellenmesinden kaçınmaya çalışır.

Felsefe

Demir mümkün olduğu kadar genişletilebilir olma ilkesi üzerine inşa edilmiştir. Kendi işlevselliğini genişletmek için konseptler sunuyor:

• "ara" özellikler - istek işlemede uçtan uca işlevselliği uygulamak için kullanılır;
• değiştiriciler - istekleri ve yanıtları en ergonomik şekilde değiştirmek için kullanılır.

Makale boyunca değiştiricilerin ve ara türlerin temel kısımlarına aşina olacaksınız.

Proje Oluşturma

Öncelikle Cargo'yu kullanarak şu komutu kullanarak bir proje oluşturalım:

Derledikten sonra ilgili yürütülebilir dosyayı alıyoruz:

1 2 3

$ Rusc merhaba.rs $ du -h merhaba 632K merhaba

Basit bir baskı için 632 kilobayt mı? Rust, C/C++'ın yerini alma potansiyeline sahip bir sistem dili olarak konumlanıyor, değil mi? Öyleyse neden benzer bir programı en yakın rakibinizde denemiyorsunuz?

Çevremizde çöp toplayıcının avantajlarından birinin yüksek performanslı, kilitlenmeyen veri yapılarını geliştirme kolaylığı olduğuna dair yaygın bir inanış vardır. Bunlarda manuel bellek yönetimi yapmak kolay değil ancak GC bu sorunu kolayca çözüyor.

Bu yazı, Rust kullanarak eşzamanlı veri yapıları için aşağıdaki özelliklere sahip bir bellek yönetimi API'si oluşturmanın mümkün olduğunu gösterecektir:

• GC'nin yaptığı gibi kilitsiz bir veri yapısının uygulanmasını mümkün kılacak;
• Bellek yönetimi şemasının kötüye kullanılmasına karşı statik koruma oluşturur;
• GC'ye benzer bir ek yüke sahip olacak (ve daha öngörülebilir).

Aşağıda göstereceğim testlerde Rust, kilitsiz kuyrukların Java uygulamalarından kolayca daha iyi performans gösteriyor ve Rust uygulamasının yazılması da kolay.

Yeni Crossbeam kitaplığında, artık veri yapılarınızla kullanıma hazır olan çağ tabanlı bir bellek iyileştirme şeması uyguladım. Bu yazıda kilitsiz veri yapılarından, Epoch algoritmasından ve dahili Rust API'sinden bahsedeceğim.

Bellek erişim hataları ve bellek sızıntıları, en çok dikkat çeken iki hata kategorisidir; bunların önlenmesi veya en azından oluşumunun azaltılması için çok çaba harcanır. İsimleri benzerlik çağrıştırsa da bazı açılardan taban tabana zıttırlar ve sorunlardan birini çözmek bizi ikinci sorundan kurtarmaz. Yönetilen dillerin yaygın kullanımı bu fikri desteklemektedir: hafızayı boşaltma işini üstlenerek bazı hafıza erişim hatalarını önlerler.

Basit ifadeyle: Bellek erişim ihlali, yanlış veri içeren bir tür eylemdir ve bellek sızıntısı yokluk doğru verilerle belirli eylemler. Tablo halinde:

Programlama dillerini öğrenmekle ilgili birkaç düşüncem var.

Her şeyden önce, bu konuda yanlış yola gidiyoruz. Eminim siz de aynı şekilde hissetmişsinizdir. Yeni bir dil öğrenmeye çalışıyorsunuz ve her şeyin nasıl çalıştığını tam olarak anlamıyorsunuz. Neden bir sözdizimi bir yerde, diğeri başka bir yerde kullanılıyor? Tüm bu tuhaflıklar sinir bozucu ve sonunda her zamanki dilimize dönüyoruz.

Dil algımızın bize acımasız bir şaka yaptığına inanıyorum. Yeni bir dil hakkında en son konuştuğunuz zamanı düşünün. Birisi bundan bahsetti ve bir başkası da hızını, sözdizimini veya mevcut web çerçevesini sordu.

Bu, arabaları tartışmaya çok benzer. Yeni UAZ Rybak'ı duydunuz mu? Ne kadar hızlı? Onu gölün karşısına sürebilir miyim?

Dillerden de benzer şekilde bahsettiğimizde, bunların birbirinin yerine geçebileceğini kastediyoruz. Arabalar gibi. Lada Saransk'ı nasıl kullanacağımı biliyorsam, UAZ Rybak'ı sorunsuz bir şekilde kullanabilirim. Tek fark hız ve gösterge paneli, değil mi?

Ancak bir PHP arabasının neye benzeyeceğini hayal edin. Şimdi bir Lisp arabasının ne kadar farklı olabileceğini hayal edin. Birinden diğerine geçiş, hangi düğmenin ısıtmayı kontrol ettiğini öğrenmekten çok daha fazlasını gerektirir.

Not: Bu makale, okuyucunun Rust FFI (çeviri), endianness ve ioctl konularına aşina olduğunu varsaymaktadır.

C kodu için bağlamalar oluştururken kaçınılmaz olarak union içeren bir yapıyla karşılaşacağız. Rust'ta birleştirme desteği bulunmadığından kendi başımıza strateji oluşturmamız gerekecek. C'de birleşim, farklı veri türlerini aynı bellek alanında saklayan bir türdür. Tam sayıların ve kayan noktalı sayıların ikili gösterimleri arasında dönüşüm, sözde polimorfizmin uygulanması ve bitlere doğrudan erişim gibi birleştirmeyi tercih etmenin birçok nedeni vardır. Sahte polimorfizme odaklanacağım.

"Rust dilinin eleştirisi ve C/C++'ın neden asla ölmeyeceği" makalesini gerçekten beğendik. Yazara makaleyi İngilizceye çevirerek blogumuzda yayınlamamızı önerdik. O da kabul etti ve biz de bu makaleyi Rusça ve İngilizce olarak sunmaktan mutluluk duyuyoruz. Orijinal makale yer almaktadır.

Orijinal makale yayınlandı (Rusça metin). Makale, yazarın onayıyla blogumuzda yayınlandı.

Not: Aşağıda Rust'un hızlı ve güvenli bir dil oluşturma girişimi olduğu varsayımını yapıyorum. Sonuçta Mozilla'nın adamları bunu bir tarayıcı motoru geliştirme aracı olarak yaptılar. Eğer bu sadece başka bir güvenli dilse, o zaman tuhaf bir şeyle karşılaşırız. Zaten bir düzine farklı güvenli dil var, herkes kendi beğenisine göre bir şeyler bulacak. Ve eğer amaç C++'ın yerini almak değilse, o zaman (1) dilde neden güvenli olmayan bir alt küme oluşturuldu? (2) Hafif akışları dilden kaldırmak neden gerekliydi? Uygun değil mi? Yani bu durumda olup bitenlerin hiçbir anlamı kalmıyor.

Eğer linux.org.ru forumunu okuyorsanız, bunun Rust'u sevmemek için bu başlıkta tartışılan 10 tamamen teknik nedenden oluşan liste olmadığını belirtmek isterim. Skype'ta yapılan bir tartışmanın gösterdiği gibi sevgili yoldaş @sum3rman Bu nedenlerin ne kadar “teknik” olarak değerlendirilmesi gerektiği konusunda birden fazla görüş bulunmaktadır. Genel olarak berbat bir liste yaptım ama yine de muhtemelen en ilginç noktalardan bazılarını aktarma riskini alacağım. Aslında burada pek çok basit, teknik olmayan neden var.

C/C++'ın yakın gelecekte hiçbir yere gitmeyeceği gerçeği aklı başında herkes için açıktır. Hiç kimse neredeyse tüm masaüstü uygulamalarını, işletim sistemi çekirdeklerini, derleyicileri, oyun ve tarayıcı motorlarını, sanal makineleri, veritabanlarını, arşivleyicileri, ses ve video codec bileşenlerini, tonlarca diğer C tabanlı kitaplıkları vb. yeniden yazmayacaktır. Bu çok hızlı, hata ayıklanmış, zaman içinde test edilmiş bir koddur. Yeniden yazmak çok, çok pahalı, riskli ve dürüst olmak gerekirse, yalnızca en inatçı Rust hayranlarının çarpık bilincinde anlamlıdır.C/C++ programcılarına olan talep çok uzun zamandır büyük olmuştur ve olacaktır.

Peki yeni kod yazarken Rust'u kullanmaya ne dersiniz?

Bunun “daha ​​doğru” bir C/C++ yapmaya yönelik ilk girişim olmadığını unutmayalım. Mesela D dilini ele alalım. 2001 yılında ortaya çıktı, çok güzel bir dil. Boş pozisyon yok, normal geliştirme aracı yok, özellikle olağanüstü başarı öyküleri yok. OpenMW projesi başlangıçta D ile yazılmıştı ve sonra aniden onu tamamen C++ ile yeniden yazmaya karar verdiler. Geliştiricilerin itiraf ettiği gibi, "harika bir proje, buna katkıda bulunmaktan mutluluk duyarız, ancak bu aptal D'yi bilmiyoruz ve bilmek de istemiyoruz" tarzında birçok mektup aldılar. Vikipedi, D'ye ek olarak, C++'ı bir dereceye kadar öldürmek için Vala, Cyclone, Limbo, BitC gibi birçok başka girişimin de olduğunu bildiriyor. Kaç kişi bu tür dilleri duydu?

Artık tarihten ders çıkarmamızın zamanı geldi diye düşünüyorum. Aklı başında tek bir kişi bile, siz ona en azından normal geliştirme araçlarını gösterene, ona birkaç başarı öyküsü anlatana ve yakınlarda bu dili konuşan bir düzine programcıyı gösterene kadar yeni bir dili bir projeye sürüklemeyecektir. Belki de programcılar, en gençleri dışında, siz onlara normal geliştirme araçları (Racer gibi el sanatları değil), birkaç on binlerce hazır kütüphane ( "deneysel", "istikrarsız" vb. değil), birkaç başarı öyküsü anlatmayın ve şehirlerinde bir düzine açık pozisyon göstermeyin. Tavuk ve yumurta sorunu. Çok nadiren, bu sorun başarılı bir şekilde çözülebilir (şartlı olarak Scala örnek olarak verilebilir), esas olarak bazı büyük şirketlerin (Google, Typesafe) zaman ve para yatırımı nedeniyle, bazı nedenlerden dolayı popülerleştirmekle ilgilenen dil.

Daha önce de belirttiğim gibi, teknik olmayan nedenler tek başına fazlasıyla yeterli. Ancak tamamen meraktan dolayı, bir anlığına onların orada olmadığını hayal etmeye çalışalım. O halde Rust'ta yazmamak için bir neden yok mu? Bunun da en azından çok büyük bir soru olduğu ortaya çıktı.

C/C++ çeşitli nedenlerle eleştiriliyor. Bu arada, C++ kodunu üretimde uzaktan bile göremeyenler tarafından da sıklıkla eleştiri yapılıyor. Sorun kısaca ve net bir şekilde şu şekilde tanımlanabilir: C++ çok hızlıdır (aynı zamanda bellek, pil şarjı vb. gerektirmez), ancak dizilerin sınırlarının ötesine geçmenize, yanlışlıkla erişim sağlamanıza izin vermesi açısından güvenli değildir. serbest bırakılan hafıza parçaları vb. Bir zamanlar bu sorun Java, C#, Python ve diğerleri gibi çok sayıda güvenli dilin ortaya çıkmasına neden oldu. Ancak, C++ ile karşılaştırıldığında bu dillerin çok fazla kaynak gerektirdiği ve çöp toplama sırasında dünyanın kaçınılmaz olarak durdurulması gibi başka dezavantajlara sahip olduğu ortaya çıktı. Bu nedenle insanlar C++ kadar hızlı ama aynı zamanda güvenli bir dil yapma göreviyle uğraşıyorlar. Böyle bir dil Rust'tur.

Rust gerçekten güvenlidir ancak ne yazık ki hızlı olmaktan çok uzaktır. Bu yazının yazıldığı sırada Rust, hız açısından Java, Go ve Haskell ile karşılaştırılabilir durumdaydı:

Zamanla bir şekilde hız aşırtılacağını içtenlikle umuyorum, ancak o zamana kadar hız ve güvenlik açısından Scala veya Go'dan çok daha ilginç değil. Bir dili hızlı ve güvenli hale getirmenin mümkün olup olmadığı ya da dizi sınırlarının aşılıp aşılmadığının sürekli kontrol edilmesi, C-kütüphanelerine bağlanma etrafında güvenli bağlama yapılması vb. gibi soruların herhangi bir dili otomatik olarak C/'den 2 kat daha yavaş hale getirip getirmediği sorusu hala cevapsızdır. C++.

Rust'u tam olarak güvenli kılan şey nedir? Basit bir ifadeyle, yerleşik statik kod analizörüne sahip bir dildir. Yalnızca bellek yönetimiyle ilgili olanları değil, aynı zamanda çoklu iş parçacığıyla ilgili olanları da içeren tüm tipik C++ hatalarını yakalayan, gerçekten çok harika bir statik analizör. Değişken bir nesnenin bağlantısını bir kanal aracılığıyla başka bir iş parçacığına aktardım ve ardından bu bağlantıyı kendim kullanmaya çalıştım - derlenmedi. Bu gerçekten havalı.

Çoğu zaman, kodun yalnızca %10'unun, zamanın %90'ında yürütüldüğü iddiası ileri sürülüyor (bu, anladığım kadarıyla, tamamen genel bir kuraldır; bu konu hakkında hızlı bir şekilde titiz bir araştırma bulamadım). Bu nedenle, programın çoğu güvenli Rust'ta yazılabilir, sıcak kodun %10'u güvenli olmayan alt kümeye yazılır ve mevcut Rust uygulamasının yavaşlığı gerçekten bir sorun değildir. Tamam, ama sonra Rust'a hiç ihtiyaç olmadığı ortaya çıktı çünkü kodun %90'ını Go'da ve %10'unu C'de yazabiliyorum. Yalnızca sihirli çözüm arayanlar ve habersiz teorisyenler Rust'u yalnızca programın %100'ünün tek bir dilde yazılabildiği için kullanacaklardır. Gerçekte bunlar aynı dilin iki lehçesi olmasına rağmen, Java artı C veya Go artı C'nin birleşiminden çok da farklı değildir.

Aslında 10:90 kuralı hala bir yalan. Bu mantıkla WebKit'in %90'ını, VirtualBox'ın %90'ını veya GCC'nin %90'ını Java'da yeniden yazabilir ve aynı sonucu elde edebilirsiniz. Açıkçası durum böyle değil. Konu bazı programlarda bu tutumun çok farklı olduğu olmasa bile, o zaman ellerinize dikkat edin. Programın tamamının güvenli olmayan C/C++ ile yazıldığını ve yürütme süresinin göreceli olarak 0,9*1 (küçük bir sıcak kod kısmı) + ​​0,1*1 (çok sayıda soğuk kod) = 1'e eşit olduğunu varsayalım. bunu Si'deki eklemelere sahip güvenli bir dildeki bir programla karşılaştırın: 0,9*1 + 0,1*2 = 1,1, kabaca farkın %10'u. Bu çok mu yoksa az mı? Ölçeğinize bağlıdır. Google örneğinde, yüzde birkaçı bile milyonlarca dolar tasarruf sağlayabilir (bu makaledeki “Kullanım” başlıklı 5. maddeye bakın). Veya bir sonraki güncellemeyle JVM'nin aniden %10 daha fazla kaynak gerektirmeye başladığını hayal edin! Faizi Amerikan parasına çevirdikten sonra elde edilen rakamda kaç sıfır olacağını tahmin etmeye bile korkuyorum! C ve C++'ın kullanıldığı görevlerde %10 çok fazla.

“Erken optimizasyon tüm kötülüklerin köküdür” sözünü bir mantra gibi tekrarlıyoruz. Ancak kelimenin tam anlamıyla alırsak, her yerde hızlı sıralama yerine kabarcık sıralamasını kullanalım. Programın bu özel yerde yavaşlayacağından emin değiliz! Daha verimli atomik olanı hemen kullanabiliyorsanız, bazı eylemlerin sıradan sayaçlarını aktörlere veya işlem belleğine sarmanın anlamı nedir? Ve genel olarak, önemsiz durumlarda tüm değişkenlerin zorla başlatılmasının, bir dizi ek kontrol yapılmasının vb. hiçbir anlamı yoktur. Yüzde 10 değil yüzde 2-5 ivmelenme elde edelim. Bu da hiç de fena değil, eğer sadece birkaç dakika daha düşünmek gerektiyse. Ve daha önce de öğrendiğimiz gibi, C/C++ ile çözülen problemlerde bu büyük bir fark yaratabilir! Peki, etkin bir nokta bulmanın, kodu yeniden yazmanın (muhtemelen çok fazla kod) ve gerçekten daha hızlı olduğunu kanıtlamanın, performansı önceden düşünmekten daha kolay olduğunu kim söyledi?

Hız-güvenlik dengesini göz ardı edersek dilin tasarımı hakkında da sorularım olacak. Özellikle beş tür işaretçiyle ilgili olarak. Bir yandan, programcı değişkenlerin yığında veya yığında nerede bulunduğunu ve birkaç iş parçacığının onlarla aynı anda çalışıp çalışamayacağını düşündüğünde bu hiç de kötü değil. Ancak öte yandan, bir program yazdığınızı ve değişkenin yığında değil yığında yaşaması gerektiği ortaya çıktığını hayal edin. Box'ı kullanmak için her şeyi yeniden yazarsınız. Yani gerçekten ihtiyacınız olan şeyin Rc veya Arc olduğunu anlıyorsunuz. Tekrar yeniden yazarsın. Ve sonra bunu yığındaki normal bir değişkene yeniden yazarsınız. Bütün bunlar - elinizde normal bir IDE olmadan. Ve normal oyunların faydası olmaz. Ya da sadece "Vec" tarzında >>>", merhaba, Java! Ancak en üzücü olan şey, derleyicinin tüm değişkenlerin ömrünü zaten biliyor olması, tüm bu Box, Arc ve benzeri çıktıları otomatik olarak çıkarabilmesidir. Ancak bazı nedenlerden dolayı işin bu kısmı aktarılmıştır. programcıya val yazmak (üçüncü binyılda!) ve gerektiğinde açıkça Box veya Rc'yi belirtmek çok daha kolay olurdu. Rust geliştiricileri bu anlamda tüm fikri mahvetti.

Bu nedenle özellikle Rust'un uygulama kapsamı büyük ölçüde daraltılmıştır. Aklı başında hiç kimse böyle bir dilde web ve sunucu tarafı yazmaz. Özellikle JVM kapsamında aynı dillere göre önemli avantajlar sağlamadığını düşünürsek. Ve normal hafif ipliklerle (gelecekteki değil) Go, bu görevler için çok daha çekici görünüyor. Futurlarda kendinizi ayağınıza sıkmamak için yine de çalışmayı öğrenmeniz gerekiyor ve “güvenli dil” diyorsunuz. Evet bu dillerin kendine has özellikleri var, dünya aynı durağı alıyor ama bu sorun hem mikroservislere kesilerek hem de diğer tekniklerle çözülebilir. Ve evet, hiç kimse Rust'u JavaScript'e çevirmeyecek, AWS'de düzen için ona komut dosyaları yazmayacak veya onu MongoDB için bir sorgu dili olarak kullanmayacak. Ayrıca Android için yazmaları da pek olası değil, ancak farklı bir nedenden dolayı - birden fazla mimari var ve JVM ile bu çok daha kolay. Aniden Rust'un "tüm görevlere uygun" olduğunu düşündüyseniz sizi hayal kırıklığına uğratmak zorundayım.

Peki, yığına:

• Makrolar, normal istisnaların bulunmamasından kaynaklanan aşırı ayrıntıya karşı bir yedektir. Metaprogramlamanın sorunları hakkında zaten yazmıştım, özellikle bu nedenle Rust için normal bir IDE görmemiz pek mümkün değil. Emin değilim ama öyle görünüyor ki Rust'taki makroların ad alanları bile yok.
• İnsanlar aptaldır ve kargo, Crates.io'yu atlayarak paketleri doğrudan git depolarından çekmeyi gerçekten teşvik eder. Sonuç olarak, Rabar'lı Erlang dünyasında olduğu gibi paketlerde de aynı karışıklığın yaşanma olasılığı yüksek, bu arada Go dünyasında da aynı durum olacak gibi görünüyor.
• Birçok yeni dil gibi Rust da basitleştirme yolunu izliyor. Genel olarak, neden normal bir miras ve istisnalar olmadığını anlıyorum, ancak birinin benim için böyle şeylere karar vermesi, ağızda hoş olmayan bir tat bırakıyor. C++ programcıyı neyin kullanılacağı ve neyin kullanılmayacağı konusunda sınırlamaz.
• Eğer sadeleştirme yolunu izleseydik tüm bu dil uzantılarını bir kenara atmak zorunda kalırdık. Aksi takdirde, Haskell dünyasında olduğu gibi her programcının kendi lehçesinde yazdığı ortaya çıkıyor.
• Akıllı işaretçiler ücretsiz olmaktan çok uzaktır ve öngörülebilir çöp toplama sürelerine yol açmaz. Bazı iş parçacıkları birdenbire çok derin bir veri yapısını serbest bırakma onuruna sahip oldu. Ölü bağlantıların labirentinde yürürken, ona bağlı olan ipler sabırla aptallaşır. Aynı sorun Erlang'da da küçük gruplarda mevcut, bunu ben de defalarca gözlemledim. Akıllı işaretçilerin de kendi sorunları vardır, aynı bellek parçalanması ve sızıntıları. Döngüsel yapıdaki vikpointer'ı unuttum, hepsi bu. Ve bu güvenli olduğunu iddia eden bir dilde. Tahmin edilebilir GC süresi istiyorsanız, uygulamanızın yük altındaki davranışını inceleyin ve GC süresi size uygun değilse harekete geçin (aynı nesne havuzlarını hatırlayın) veya belleği manuel olarak yönetin.
• Rust anlambiliminin ayrıntılı bir tanımını gören var mı? En azından bir hafıza modeli var mı? Ayrıca bana göre programların "doğruluğunu kanıtlayan", kaynak kodunu on farklı şekilde yorumlayabilen "güvenli" bir dil, ha!
• Bunu bir kez daha hatırlatmadan edemeyeceğim. Sorun neredeyse her zaman insanlardadır, teknolojide değil.. Kötü bir C++ koduyla karşılaşırsanız veya Java aniden yavaşlarsa, bunun nedeni teknolojinin kötü olması değil, onu nasıl doğru şekilde kullanacağınızı öğrenmemiş olmanızdır. Siz de Rust'tan memnun olmayacaksınız ama farklı sebeplerden dolayı. Daha popüler araçları kullanmayı ve sevmeyi öğrenmek daha kolay olmaz mıydı?

Genel olarak önümüzdeki 5 yıl boyunca zamanımı Rust yerine C/C++ öğrenmeye ayırmayı tercih ederim. C++- bu bir endüstri standardıdır. Bu dilde 30 yılı aşkın bir süredir çok çeşitli problemler başarıyla çözülmektedir. Rust ve onun gibileri ise geleceği belirsiz, anlaşılmaz oyuncaklar. En azından 2000'li yıllardan bu yana C++'ın yakında öleceği hakkında konuşmalar yapılıyor, ancak C/C++'da yazı yazmaya bu dönemden daha az başlamadı. Tam tersi. Ve dilin geliştiğini (C++11, C++14), bunun için yeni araçların ortaya çıktığını (CLion ve Clang'ı hatırlayalım) ve buna karşılık gelen çok sayıda boş pozisyon olduğunu görüyoruz.

Bir C++ programcısı her zaman makul maaştan daha yüksek bir işi kolaylıkla bulabilir ve gerekirse Rust'ta hızlı bir şekilde yeniden eğitim alabilir. Bunun tersi ise çok çok şüphelidir. Bu arada, yeni bir iş yeri seçerken dil, tek ve belirleyici faktör olmaktan çok uzaktır. Buna ek olarak, deneyimli bir C/C++ programcısı PostgreSQL kaynak kodunu veya Linux çekirdeğini kolayca inceleyebilir, güçlü modern geliştirme araçlarını kullanabilir ve ayrıca elinde çok sayıda kitap ve makale bulunabilir (örneğin OpenGL'de).

Zamanınıza ve sağlığınıza dikkat edin, sandığınız kadarına sahip değilsiniz!

Günümüzde Rust sözdizimi, derleyiciyle birlikte sağlanan sözdizimi dosyaları kullanılarak vim ve emacs'ta desteklenmektedir.
Popüler özel editör Sublime Text 2 ve ücretsiz editör Kate için de sözdizimi paketleri bulunmaktadır. Henüz IDE'de Rust desteği bulunmuyor. Hata ayıklayıcı desteği de yok gibi görünüyor.

Rusc derleyicisiyle birlikte aşağıdaki yardımcı programlar sağlanır:
> pas belgesi- Doxygen gibi kaynak kodundan otomatik olarak belge oluşturmaya yönelik bir yardımcı program;
> paspkg- ek paketleri ve kitaplıkları kolayca kurmanıza olanak tanıyan bir paket yöneticisi;
> paslı- sözde REPL yardımcı programı (okuma-değerlendirme-yazdırma döngüsü). Bu aslında bir Rust ifadesini komut satırından alan, bunu dahili bir LLVM temsilinde derleyen, çalıştıran ve sonucu yazdıran bir test yorumlayıcısıdır;
> pas- parametrelere bağlı olarak diğer yardımcı programları veya derleyiciyi başlatan evrensel bir yardımcı program. Benim için hiçbir zaman işe yaramadı.

Dille ilgili mevcut tüm belgeler www.rust-lang.org resmi web sitesinde toplanmıştır. Ayrıntılı bir kılavuz (http://static.rust-lang.org/doc/tutorial.html) vardır - sözdizimi, bellek modeli, çalışma zamanı sistemi vb. ile ilgili tüm nüansların yanı sıra ilgili belgeler hakkında kapsamlı resmi belgeler yerleşik çekirdek kütüphane ve standart kütüphane std. Tüm belgeler İngilizcedir. Rusça'da güncel materyal yok ve mevcut birkaç inceleme makalesi zaten çok eski.

İdeoloji ve sözdizimi

Rust, kod bloklarını ayırmak için küme parantezleri kullanan C benzeri bir dildir. Dil “çoklu paradigmadır”, yani. Zorunlu prosedürel, nesne yönelimli, eşzamanlı veya işlevsel bir şekilde kod yazmanıza olanak tanır. Rust, desteklenen herhangi bir platformda yerel ikili koda derlenir (arka uç olarak LLVM'yi kullanır). Teorik olarak Rust kodunun C/C++ kodu kadar hızlı olması gerekir. Rust bir sistem dili olarak konumlandırılmıştır ancak "gerçek" sistem dilleri C, C++ veya D gibi montaj kodu blokları için yerleşik desteğe sahip değildir.

Rust'un bellek modeli doğası gereği boş veya sarkan işaretçilere ve arabellek taşmalarına izin vermez. Yalnızca tek bir kod iş parçacığında çalışan isteğe bağlı bir çöp toplayıcı vardır. Dil, hafif çoklu görev ve mesajlaşmayı kullanarak iş parçacıkları arasında iletişim için yerleşik desteğe sahiptir. Paylaşılan hafıza Rust'ta hiç mevcut değil. Tüm değişkenler yığın değişkenlerine, belirli bir iş parçacığı için yığın değişkenlerine ve tüm iş parçacıkları tarafından okunabilen ancak onlar tarafından değiştirilemeyen "değişim" yığın değişkenlerine bölünmüştür. Bu, çok iş parçacıklı programlamanın belası olarak kabul edilen kilitlenmeyi otomatik olarak ortadan kaldırır. Dilin ABI'si C ile uyumludur, dolayısıyla Rust programları ek sarmalayıcılara gerek kalmadan C ile yazılmış kitaplıklara bağlanabilir. Düşük seviyeli sistem programlamanın ihtiyaçları için ve C ile uyumluluğu sağlamak için dil, işaretçilerin doğruluğunu kontrol etmeden özel bir "güvenli olmayan" moda sahiptir. İdeolojisinde Rust, Go diline en yakın dildir. Tıpkı Go'da olduğu gibi, ana vurgu, çok iş parçacıklı programlamanın basitliği ve büyük ölçekli uygulamaların geliştirme hızıdır ve sözdizimi de alışılmadık ve bazı yerlerde biraz şaşırtıcıdır. Aynı zamanda Rust, Go kadar minimalist değil ve bir sistem dili olduğunu iddia ediyor.

Rust'un sözdizimi büyük ölçüde C ve C++'dan ödünç alınmıştır; Go, C#, Haskell, Python ve Ruby'den bazı fikirler de karıştırılmıştır. Dilin sözdizimini kapsamlı bir şekilde açıklamayacağım, yalnızca en ilginç kavramlara odaklanacağım.

Rust popülerlik kazanıyor, ancak çoğu kişi hala değerini ve işlevlerini anlamıyor. Sizlere Rust programlama dilinin temel avantajlarını anlatacağız.

Rust ve diğer dillerin ortak noktaları nelerdir?

Yukarıdaki tanımlara inanmak zor; gerçekçi olmayan bir ifade gibi görünüyor, çünkü daha önce tüm diller taraflardan birini seçiyordu: güvenilirlik veya performans.

Yüksek hızın çarpıcı bir temsilcisi, ancak tahsis edilen belleğe, uzak sunuculara yanlış erişim nedeniyle hataların ne sıklıkla ortaya çıktığını hepimiz biliyoruz ve öngörülemeyen iş sonuçları çıktıları hakkında söylenecek bir şey yok. Birden fazla yazma iş parçacığı nedeniyle sonucu tahmin etmek genellikle zordur.

Güvenilirliğe yönelik önyargı en iyi şekilde dille gösterilir Haskell Doğada derlenen ve yüksek güvenlik performansı sağlayan . Derlenebilecek her şey düzgün çalışacaktır. Ana dezavantaj- bu düşük performanstır, yüksek hız gerektiren bir projenin yazılmasını hayal etmek zordur Haskell.

Geri kalanlar da tarafsız bir konumda, belli bir dengede. Pratikliğe odaklanırlar.

Pas en iyi özellikleri bünyesinde barındırır C++ Ve Haskell ve ayrıca diğer rakiplerden yeterli pratiklik ve işlevselliği de koruyabildi.

Rust dilinin güzelliği nedir?

Rust'un sihirli özellikleri, derleme temelleri ve sahip varlık bilgileri aracılığıyla kullanıma sunulur ( mal sahibi), yalnızca geçici olarak hata ayıklama yapan veya projeyi devralan bir programcı hakkında ( değişken ödünç alma) ve sıradan izleyici hakkında ( değişmez ödünç).

Programlama yaparken Java veya C++, veri türü biraz farklı olsa da bu bilgiyi hafızada tutmanız gerekir. İÇİNDE Pas bu, dil yapıları kullanılarak uygulanır; bu bilgi, derleyicinin kimliği oluşturmasını ve davranış modelini doğru şekilde seçmesini kolaylaştırır. Bir derleyici ile kod yürütme sırasında olası ve sık karşılaşılan sorunların ortadan kaldırılmasını sağlayabilirsiniz.

Bu dil biraz farklı bir yaklaşım gerektirir. Alışılmadık olmasına rağmen algoritma oldukça açık ve etkilidir. Şimdi çalışmaya başlarken çıkmaza girebilecek dilin temellerini tanımlayacağız:

1. Miras sistemi tamamen ortadan kaldırıldı; onun yerine özel bir yapı ve yetenekler kullanıldı, daha detaylı özellikler kullanıldı.
2. İşaretçiler yalnızca ek korumaya tabi olmayan kodda, yani unsafe() işlevinin içinde bulunur. Güvenli kod, bunları değiştirmek için mevcut nesnelere doğru işaretçiyi sağlayan referansları kullanır.
3. Bağlantı statikse ve belirli bir öğeye işaret ediyorsa, örneğin değişmez borç = &Object, bağlantı ölene kadar hiçbir kullanıcı tarafından değiştirilemez.
4. Değişen bir ödünç = &mut Nesne bağlantısı varsa, içerik, bağlantının tüm ömrü boyunca başka hiçbir kullanıcı tarafından okunamaz.
5. Geliştiriciler Mac ve *nix platformlarına odaklanıyor, bu nedenle sistem üzerinde çalışıyor pencereler yalnızca GNU ortamı kullanılarak mümkündür.

Hedef kitle oldukça önemli; Rust dili oldukça aktif bir topluluğa, gelişmiş bir iletişim ve eğitim sistemine sahip. IRC kanalını veya Reddit'i ziyaret etmenizi öneririz. Bu güne kadar zaten yazıldı ve çoğu hala sürekli olarak geliştiriliyor, projelerine GitHub'da ulaşılabilir.

Dil, grafik ve oyun oluşturma yolunu seçen geliştiriciler arasında en popüler olanıdır. Tam teşekküllü bir işletim sistemi oluşturmaya yönelik gelişmeler bile var, ancak bunlar hala geliştirilmeye devam ediyor. Yakın gelecekte istemci programları ve web sunucuları yazma olasılığı var. Yukarıdaki görevlerin tümü tamamen Rust'un yetenekleri dahilindedir.

Ana ve muhtemelen tek dezavantajı aşırı aktif gelişimidir. Yeni sürümler yayınlandıkça sözdizimi bir miktar değişir ve yeni yeteneklere uyum sağlamak için periyodik olarak davranış ve geliştirme mantığının değiştirilmesine ihtiyaç duyulur. Bu durum Rust-1.0 çıkana kadar bir süre daha devam edecek.

Normal sütun " Rust'ta Bu Hafta", Rust "n Stuffs'ta bağlantıda bulunabilir. Her zaman önceki ve geçmiş değişikliklerin yanı sıra dilin gelişimine ilişkin beklentiler hakkında bilgi vardır.

Şimdiye kadar söz konusu programlama dilinin sözdiziminin C/C++ gibi dillerin sözdizimine çok benzediğini fark etmişsinizdir, çünkü her iki durumda da yorumları vurgulamak için iki eğik çizgi kullanılır, kod blokları küme parantezleriyle çevrilidir ve işlev bağımsız değişkenleri parantezlerle çevrilidir. Ayrıca fn anahtar sözcüğünün işlevleri bildirmek için kullanıldığını ve her programın bir main() işlevi olması gerektiğini unutmayın. Bu durumda println işlev adından sonraki ünlem işareti, bir makronun (esasen Rust çalışma zamanı kitaplığından yazdırma işlevinin etrafında kullanışlı bir sarmalayıcı) kullanıldığını gösterir.

Programı derlemek için şu komutu çalıştırmanız yeterlidir:

Rustc merhaba.rs

Sonuç olarak, program kaynak kod dosyasının bulunduğu dizinde merhaba adlı bir ikili dosya görünmelidir; bunu yürütmek için sadece komutu çalıştırın./hello. Ancak bu dosyanın boyutuna dikkat ederseniz biraz şok olacaksınız: 800 KB'yi aşacak. Ve bu kadar basit bir programın çalışması için tüm bunlar gerekli mi? Varsayılan olarak, Rust derleyicisi çalışma zamanı kitaplıklarının çoğunu programa statik olarak bağlar, böylece ikili dosyayı Rust çalışma zamanı kitaplıklarının yüklü olmadığı bir sisteme kopyalayabilir ve herhangi bir sorun olmadan çalıştırabilirsiniz. Ancak derleyiciye optimizasyon ve dinamik bağlantı gerçekleştirmesini de söyleyebilirsiniz:

Rustc -O C tercih-dinamik hello.rs

Artık 8 KB'ye eşit, daha kabul edilebilir boyutta bir ikili dosya elde edeceksiniz, ancak ldd yardımcı programını kullanırsanız, programın doğru çalışması için sistemde libstd-dinamik kitaplığının bulunması gerektiğini göreceksiniz.<версия>.Bu yüzden .

Programlama dili sözdizimi

Artık programları Rust'ta derleyip çalıştırabildiğimize göre, bu programlama dilinin sözdizimini anlamayı ve C, C++ ve diğer benzer programlama dillerinin sözdiziminden farklarını vurgulamayı öneriyorum:

Fn katlayıcı (x: i32) -> i32 ( x * 2 ) fn ana () ( let a: i32 = 5; let b; b = katlayıcı(a); println!("a çarpı 2 ()", b) ; match b ( 1 ... 10 => println!("1'den 10'a kadar"), _ => println!("Başka bir sayı"), ) )

Eğer C/C++ dilleriyle çalışmaya alışkınsanız bu kodun biraz garip olduğunu düşünebilirsiniz ama oldukça mantıklıdır. Main() işleviyle başlayalım: Let'in ilk satırında 32 bitlik bir tamsayı değişkeni a bildirelim ve ona 5 başlangıç ​​değeri atayalım. Değişkenin türünü belirtmeyi atlayabiliriz (i32 standart değişken türüdür) ve ayrıca ona bir başlangıç ​​değeri atmayın ve bu durumda sıfır değeri içerecektir. Bir değişken bildirirseniz ve ona örnekteki a değişkeniyle aynı şekilde belirli bir değer atarsanız, değerini daha sonra değiştiremeyeceğinizi, dolayısıyla aşağıdaki kod parçacığını derlerken bir hata mesajı oluşturulacağını unutmayın:

a: i32 = 5; bir = 10;

Varsayılan olarak Rust'taki değişkenler değişmezdir, yani değerleri başlatıldıktan sonra değişemez. Değişken değişkenleri açıkça benzer şekilde bildirmeniz gerekir:

Mut a: i32 = 5;

Buna neden ihtiyaç var? Bu fazladan bir iş değil mi? Aslında bu doğrudur ama öte yandan programlama dilinin bu özelliği güvenli programların geliştirilmesine yardımcı olur. Yalnızca değerlerinin değişmesi gereken değişkenleri değişken hale getirmelisiniz. Rust, programın nasıl çalıştığını mümkün olduğunca doğru bir şekilde açıklamak için sizi gerektiği kadar ayrıntılı olmaya zorlar: Yukarıdaki satır, gelecekte değerini değiştirme olasılığıyla birlikte, tam olarak 32 bit boyutunda işaretli bir tamsayı değişkeni a'yı bildirir.

Daha sonra, argümanı a değişkeni olan çiftleyici işlevimizi çağırırız ve dönüş değerini b değişkeninde saklarız. Program kodunun başında yer alan doubler fonksiyonunun bildirimine dikkat edin: fonksiyon parametresinin tipini (i32) ve -> sembollerinden sonra dönüş değerinin tipini (i32) gösterir. İşlevin, normal bir Rust kodu bloğu gibi, ardından noktalı virgül bile gelmeyen tek bir işlemi ( x * 2 ) gerçekleştirdiğini görmek de kolaydır; Orada neler oluyor?

Bir fonksiyonun değerini, C'dekiyle aynı şekilde veya bu durumda yapıldığı gibi basitçe ifadeyi fonksiyon kodunun son satırına yerleştirerek döndürebileceğiniz ortaya çıktı. Ve bu sadece bir ifade olduğu için arkasına noktalı virgül koymaya gerek yok.

Sonucu yazdırmak için println!() makrosunu kullandığımız main() fonksiyonuna dönelim; Bir değişkenin değerini karakter dizisi () kullanarak değiştirme tekniğine dikkat edin. Son olarak örnek, Rust programlama dilinin son derece kullanışlı "match" anahtar sözcüğünü göstermektedir; bu anahtar kelime, çok sayıda if/else ifadesi gerçekleştirmeniz gerekiyorsa kod miktarını önemli ölçüde azaltabilir. Bu durumda, 1...10, bir değer aralığının (1'den 10'a kadar) bildirimidir ve alt çizgi (_) karakteri diğer tüm değerlerle eşleşir.

Rust'ta char string türü, dört baytlık karakterlerin yani herhangi bir Unicode karakterin kullanılmasına izin verir ve bu, programlama dilinin tasarım aşamasında farklı diller ve özel karakterlerle çalışacak şekilde uyarlandığı anlamına gelir. Bir başka yararlı veri türü, farklı türdeki değişkenlerin bir koleksiyonu olan bir tanımlama grubudur:

x = (1, 2,0, "Merhaba");

Bu durumda, bir tam sayı değeri, bir kayan değer değeri ve bir dize değeri aynı tanımlama grubuna yerleştirilir. Bu değerler değişmezdir ve aynı şekilde erişilebilir:

Println!("()", x.2);

Sonuç olarak, x kümesinin üçüncü elemanının değeri, yani "Merhaba" dizisinin çıktısı alınacaktır. Rust'ta da desteklenen normal dizilerde olduğu gibi, demetlerin elemanlarının numaralandırması sıfırdan başlar. Bir işlevden birden fazla değer döndürmek için tuple'ları kullanabilirsiniz:

Fn anahtarı(giriş: (i32, i32)) -> (i32, i32) ( (giriş.1, giriş.0)) ) fn main() ( let x = (10, 50); let y = anahtar(x) ; println!("(), ()", y.0, y.1); )

Bu durumda switch() adı verilen bir işlev, iki adet 32 ​​bitlik tamsayı değerinden oluşan bir tuple alır ve bunları giriş değişkeninde saklar. Ayrıca iki tamsayı değerine sahip bir tanımlama grubu döndürür. Bu işlev, bir demetin öğelerini değiştirmenize ve ortaya çıkan demet'i döndürmenize olanak tanıyan basit bir ifade kullanır.

Main() işlevi, 10 ve 50 değerlerini içeren x adında bir demet ve switch() çağrısından döndürülen değerleri içeren y adında bir demet oluşturur. Daha sonra, tuple'ın değerleri ekranda basitçe görüntülenir (50, 10).

Tavsiye: Rust'un yeteneklerini kendiniz keşfetmek için can atıyorsanız, https://doc.rust-lang.org/book adresinde bulunan resmi belgeleri okuyarak başlamanızı öneririz.

Bu, Rust programlama dilinin söz dizimi ve yeteneklerinin kısa bir açıklamasıydı; Bu programlama dili hakkında özel bir makale dizisinde daha fazla bilgi edinmek isterseniz bize bildirin!