Rust Sistem Programlama Dili (Rust Language)

Rust Sistem Programlama Dili (Rust Language)

 

Rust çok eşzamanlı ve son derece güvenli sistemler için geliştirilmiş bir dil yani büyük sistem bütünlüğünü koruyan sınırlar yaratmak ve sürdürmek için bir dil olarak tasarlanmıştır.   Bu, güvenlik, bellek düzeni kontrolü ve eşzamanlılık üzerinde bir vurgu ile belirlenen bir özellikli yol açmıştır. İdiyomatik Rust’un performansı idiyomik C++’un performansıyla karşılaştırılabilir.

Rust benzer C ve C ++ tarafından sınırlanan kod blokları ile kıvırcık parantez ve kontrol akımı gibi anahtar kelimeler if, else, while ve for. Bununla birlikte, tüm C veya C ++ anahtar sözcükleri uygulanmaz ve bazı Rust işlevleri  ( match örüntü eşleme için anahtar kelimenin kullanımı gibi ), bu dillerden gelen programcılara daha az aşina olacaktır.

C ve C ++ ‘ya olan yüzeysel benzerliğe rağmen, Rust’un daha derin bir anlamdaki sözdizimi, ML dil ailesine daha yakındır. Bir fonksiyon gövdesinin neredeyse her parçası bir ifadedir hatta kontrol akış operatörleri. Örneğin, sıradan if İfade ayrıca C’nin üçlü koşullu yerini alır . Bir fonksiyonun bir return ifadeyle bitmesi gerekmez bu durumda fonksiyondaki son ifade dönüş değerini yaratır.

 

// This is a comment, and will be ignored by the compiler
// You can test this code by clicking the "Run" button over there ->
// or if prefer to use your keyboard, you can use the "Ctrl + Enter" shortcut

// This code is editable, feel free to hack it!
// You can always return to the original code by clicking the "Reset" button ->

// This is the main function
fn main() {
 // The statements here will be executed when the compiled binary is called

// Print text to the console
 println!("Hello World!");
}
fn main() {
 // This is an example of a line comment
 // Notice how there are two slashes at the beginning of the line
 // And that nothing written inside these will be read by the compiler

// println!("Hello, world!");

// Run it. See? Now try deleting the two slashes, and run it again.

/* 
 * This is another type of comment, the block comment. In general,
 * the line comment is the recommended comment style however the
 * block comment is extremely useful for temporarily disabling
 * a large chunk of code. /* Block comments can be /* nested, */ */
 * so it takes only a few keystrokes to comment out all the lines
 * in this main() function. /*/*/* Try it yourself! */*/*/
 */

/*
 Note, the previous column of `*` was entirely for style. There's
 no actual need for it.
 */

// Observe how block comments allow easy expression manipulation
 // which line comments do not. Deleting the comment delimiters
 // will change the result:
 let x = 5 + /* 90 + */ 5;
 println!("Is `x` 10 or 100? x = {}", x);
}
fn main() {
    // Variables can be type annotated.
    let logical: bool = true;

    let a_float: f64 = 1.0;  // Regular annotation
    let an_integer   = 5i32; // Suffix annotation

    // Or a default will be used.
    let default_float   = 3.0; // `f64`
    let default_integer = 7;   // `i32`
    
    // A type can also be inferred from context 
    let mut inferred_type = 12; // Type i64 is inferred from another line
    inferred_type = 4294967296i64;
    
    // A mutable variable's value can be changed.
    let mut mutable = 12; // Mutable `i32`
    mutable = 21;
    
    // Error! The type of a variable can't be changed.
    mutable = true;
    
    // Variables can be overwritten with shadowing.
    let mutable = true;
}


 

 
fn main() {
// Variables can be type annotated.
let logical: bool = true;
 
let a_float: f64 = 1.0; // Regular annotation
let an_integer = 5i32; // Suffix annotation
 
// Or a default will be used.
let default_float = 3.0; // `f64`
let default_integer = 7; // `i32`
Abdurrahman Kasım TÖK
// A type can also be inferred from context
let mut inferred_type = 12; // Type i64 is inferred from another line
inferred_type = 4294967296i64;
 
// A mutable variable’s value can be changed.
let mut mutable = 12; // Mutable `i32`
mutable = 21;
 
// Error! The type of a variable can’t be changed.
mutable = true;
 
// Variables can be overwritten with shadowing.
let mutable = true;
}
 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Compiling playground v0.0.1 (file:///playground) error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `let` --> src/main.rs:13:5 | 11 | jkvhjcjb | - expected one of 8 possible tokens here 12 | // A type can also be inferred from context 13 | let mut inferred_type = 12; // Type i64 is inferred from another line | ^^^ unexpected token error[E0425]: cannot find value `jkvhjcjb` in this scope --> src/main.rs:11:5 | 11 | Abdurrahman Kasım TÖK | ^^^^^^^^ not found in this scope error: aborting due to 2 previous errors error: Could not compile `playground`. To learn more, run the command again with --verbose.

 

 

About the author: Abdurrahman Kasım TÖK

#Bisiklet #Teknoloji #Yazılım #Researcher #Insider #Mkutup #UTM

You must be logged in to post a comment.