মূল কন্টেন্টে যান
মডিউল 1 · 1-এর পাঠ 2কোর্সে 1/14~10 min
মডিউল পাঠ (1/2)

চলক এবং পরিবর্তনশীলতা

মরিচায়, পরিবর্তনশীল এবং মেমরি ব্যবস্থাপনা দুটি মৌলিক নীতি দ্বারা পরিচালিত হয়: নিরাপত্তা এবং নিয়ন্ত্রণ। এই কারণে, অন্যান্য অনেক প্রোগ্রামিং ভাষার বিপরীতে, রাস্টের ভেরিয়েবলগুলি ডিফল্টরূপে অপরিবর্তনীয়।

এর মানে হল যে একবার একটি মান একটি ভেরিয়েবলের সাথে বরাদ্দ করা হলে, এটি পরিবর্তন করা যাবে না। আপনি যদি এটি সংশোধন করার চেষ্টা করেন, কম্পাইলার একটি ত্রুটি উত্থাপন করবে।

অপরিবর্তনীয় ভেরিয়েবল এবং mut কীওয়ার্ড

একটি পরিবর্তনশীল ঘোষণা করতে, আমরা let কীওয়ার্ড ব্যবহার করি:

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

আপনি যদি একটি ভেরিয়েবলের মান পরিবর্তন করতে চান, তাহলে আপনাকে অবশ্যই let এর ঠিক পরে mut কীওয়ার্ড ব্যবহার করে এটিকে পরিবর্তিত করতে হবে:

Rust
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);

mut উপসর্গটি ব্যবহার করে কম্পাইলার এবং যে কেউ কোড পড়ছেন তাদের কাছে স্পষ্টভাবে যোগাযোগ করে যে মানটি কার্যকর করার সময় পরিবর্তিত হবে।

ছায়াময়

মরিচা শ্যাডোয়িং-এর ধারণাকেও অনুমতি দেয়, যা আবার let কীওয়ার্ড ব্যবহার করে একই নামের একটি ভেরিয়েবলের পুনরায় ঘোষণা। নতুন পরিবর্তনশীল "ছায়া" (বা কভার) আগেরটি:

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

mut এর বিপরীতে, ছায়া আপনাকে করতে দেয়:

  1. একই নাম রাখার সময় একটি ভেরিয়েবলের ডেটা টাইপ পরিবর্তন করুন।
  2. পরিবর্তনের পর পরিবর্তনশীলের অপরিবর্তনীয়তা বজায় রাখুন।
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

ছায়া ও সুযোগের উপযোগিতা

ছায়াকরণ একই ব্লকে সীমাবদ্ধ নয়; এটি অস্থায়ীভাবে একটি মান ওভাররাইড করতে নেস্টেড ব্লকের ({}) মধ্যে ব্যবহার করা যেতে পারে। অভ্যন্তরীণ ব্লক শেষ হলে, মূল পরিবর্তনশীলটি আবার দৃশ্যমান হয়:

Rust
let x = 5;
{
    let x = x * 2; // Shadowing valid only inside the block
    println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5

এই প্রক্রিয়াটি অত্যন্ত নিরাপদ এবং দক্ষ কারণ এটি সম্পূর্ণরূপে কম্পাইল-টাইমে ঘটে, কোনো রানটাইম পারফরম্যান্স ওভারহেড ছাড়াই টাইপ নিরাপত্তা নিশ্চিত করে।


নিজে চেষ্টা করে দেখুন

ব্যায়াম#rust.m1.l1.e1
প্রচেষ্টা: 0লোড হচ্ছে...

5 এর প্রারম্ভিক মান সহ x নামের একটি পরিবর্তনযোগ্য ভেরিয়েবল ঘোষণা করুন। এরপর, x এর সাথে 10 যোগ করুন এবং println ব্যবহার করে এটিকে স্ক্রিনে প্রিন্ট করুন! ম্যাক্রো

সম্পাদক লোড হচ্ছে...
ইঙ্গিত দেখান

ভেরিয়েবলটিকে `let mut x = 5;` দিয়ে ঘোষণা করুন, তারপর `x += 10;` (বা `x = x + 10;`) দিয়ে বৃদ্ধি করুন এবং অবশেষে `println!('{}', x);` দিয়ে প্রিন্ট করুন।

সমাধান 3 প্রচেষ্টার পরে উপলব্ধ

ব্যায়াম#rust.m1.l1.e2
প্রচেষ্টা: 0লোড হচ্ছে...

10 এর মান সহ একটি অপরিবর্তনীয় ভেরিয়েবল y ঘোষণা করুন। এর আগের মানকে 2 দ্বারা গুণ করতে let দিয়ে এটিকে আবার ঘোষণা করে Shadow y, এবং অবশেষে println ব্যবহার করে প্রিন্ট করুন!

সম্পাদক লোড হচ্ছে...
ইঙ্গিত দেখান

Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.

সমাধান 3 প্রচেষ্টার পরে উপলব্ধ

ব্যায়াম#rust.m1.l1.e3
প্রচেষ্টা: 0লোড হচ্ছে...

Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.

সম্পাদক লোড হচ্ছে...
ইঙ্গিত দেখান

Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.

সমাধান 3 প্রচেষ্টার পরে উপলব্ধ