විචල්ය (Variable) යනු කුමක්ද?

Programming ලෝකයට අඩිය තියන ඔබට නැතුවම බැරි වන, සරලම සහ වැදගත්ම සංකල්පය පිළිබඳ සවිස්තරාත්මක සිංහල මාර්ගෝපදේශය.

පරිගණක විද්‍යාව හෝ තොරතුරු තාක්ෂණය (ICT) ඉගෙන ගන්නා විට ඔබට නිතරම ඇසෙන වචනයක් තමයි **"විචල්ය" (Variable)** කියන්නේ. හරියට ගෙයක් හදන්න ගඩොල් ඕන වෙනවා වගේ, පරිගණක වැඩසටහනක් (Program) හදන්න විචල්යයන් නැතුවම බැහැ. ඇත්තටම මේක හිතන තරම් සංකීර්ණ දෙයක් නෙවෙයි. ඔබ O/L හෝ A/L ICT කරන ශිෂ්‍යයෙක් උනත්, Programming ඉගෙනගන්න පටන් ගත්ත කෙනෙක් උනත්, මේ ලිපිය අවසානයේ ඔබට විචල්යයන් ගැන ඉතාම පැහැදිලි අවබෝධයක් ලැබෙන බවට සහතිකයි!

මේ ලිපියෙන් අපි කතා කරන්නේ:

විචල්යයක් (Variable) යනු කුමක්ද? 🤔

සරලම විදිහට කිව්වොත්, **විචල්යයක් යනු දත්තයක් (data) තාවකාලිකව ගබඩා කර තබා ගැනීමට යොදාගන්නා, නමක් සහිත මතක අවකාශයකි (named storage location).**

මේක තව ටිකක් සරල කරගමු. හිතන්න ඔබේ කාමරයේ බඩු දාන්න පාවිච්චි කරන පෙට්ටියක් (box) ගැන. [Image of a labeled cardboard box]

Programming වලදී විචල්යයක් කියන්නෙත් මේ වගේම දෙයක්. පරිගණකයේ මතකය (Memory/RAM) කියන විශාල ගබඩාවේ, අපේ දත්තයක් (උදා: නමක්, වයසක්, ලකුණු ගණනක්) දාලා තියන්න අපි පොඩි "ඉඩක්" වෙන් කරගන්නවා. ඒ ඉඩට අපි පහසුවෙන් මතක තියාගන්න පුළුවන් නමක් දෙනවා. අන්න ඒකට තමයි අපි **විචල්යයක්** කියන්නේ. "Variable" කියන ඉංග්‍රීසි වචනයේ තේරුම "වෙනස් විය හැකි" යන්නයි. ඒ, විචල්යයක අගය වැඩසටහන ක්‍රියාත්මක වන අතරතුරේදී අපිට අවශ්‍ය විදිහට වෙනස් කරන්න පුළුවන් නිසයි.

මූලික කොටස් දෙක: සෑම විචල්යයකටම ප්‍රධාන කොටස් දෙකක් තියෙනවා:
  1. නාමය (Name / Identifier): අපි ඒ මතක ඉඩ හඳුනාගන්න දෙන නම (උදා: `userName`, `score`, `age`).
  2. අගය (Value): ඒ මතක ඉඩ ඇතුළේ අපි ගබඩා කරන දත්තය (උදා: `"Nimal"`, `100`, `25`).

අපිට විචල්යයන් අවශ්ය වන්නේ ඇයි? 🧐

විචල්යයන් නැතුව program එකක් ලියන්න බැරි තරම්. ඒවායින් ලැබෙන ප්‍රයෝජන කිහිපයක් පහත දැක්වෙනවා.

1. තොරතුරු ගබඩා කිරීම (Storing Information)

පරිගණක වැඩසටහනකට විවිධ දේවල් මතක තියාගන්න සිද්ධ වෙනවා. උදාහරණයක් විදිහට, ඔබ ෆේස්බුක් ලොග් වෙනකොට ඔබේ username එක, ගේම් එකක් ගහනකොට ඔබේ score එක, online shop එකකින් බඩුවක් ගන්නකොට ඒකේ මිල වගේ දේවල් පරිගණකය මතක තියාගන්න ඕන. මේ වගේ තොරතුරු මතකයේ තියාගන්න තමයි විචල්යයන් පාවිච්චි කරන්නේ.


# Python Example
user_name = "Kamal Perera"
current_score = 4500
item_price = 150.75
is_logged_in = True

2. කේතය නැවත භාවිත කිරීම (Reusability)

හිතන්න, ඔබට ඔබේ program එකේ තැන් දහයකදී '3.14159' (π - පයි අගය) කියන අගය භාවිතා කරන්න ඕන කියලා. හැමතැනම ඒ අගය type කරනවා වෙනුවට, `pi = 3.14159` කියලා විචල්යයක් හදාගත්තාම, ඔබට අවශ්‍ය හැම තැනකම `pi` කියන නම විතරක් භාවිතා කරන්න පුළුවන්. පස්සේ කවදාහරි π අගය තවත් දශමස්ථාන ගාණකට නිවැරදි කරන්න ඕන වුනොත්, ඔබ කළ යුත්තේ අර විචල්යය හදපු තැන විතරක් වෙනස් කරන එකයි. තැන් දහයම වෙනස් කරන්න අවශ්‍ය වෙන්නේ නැහැ.

3. කේතය කියවීමට සහ තේරුම් ගැනීමට පහසු කිරීම (Making Code Readable)

හොඳට නමක් දාපු විචල්යයක් දැක්කම, ඒකෙන් මොකක්ද වෙන්නේ කියලා ලේසියෙන්ම තේරුම් ගන්න පුළුවන්. පහත උදාහරණ දෙක බලන්න.

තේරුම් ගැනීමට අපහසු කේතය:


x = 15000
y = 0.1
z = x * y
print(z) # ප්‍රතිදානය: 1500.0

තේරුම් ගැනීමට පහසු කේතය:


salary = 15000
tax_rate = 0.1
tax_amount = salary * tax_rate
print(tax_amount) # ප්‍රතිදානය: 1500.0

දෙකෙන්ම වෙන්නේ එකම දේ උනත්, `salary`, `tax_rate` වගේ තේරුමක් තියෙන නම් භාවිතා කරපුවාම කේතය කියවන ඕනම කෙනෙකුට වෙන්නේ මොකක්ද කියලා ලේසියෙන්ම තේරෙනවා.

විචල්යයක් සාදා ගන්නේ කෙසේද? (Declaring and Initializing) 🛠️

විචල්යයක් නිර්මාණය කිරීමේදී ප්‍රධාන පියවර දෙකක් තියෙනවා. සමහර programming languages වලදී මේ දෙකම එක පාර කරන්න පුළුවන්.

  1. ප්‍රකාශ කිරීම (Declaration): "මම මෙන්න මේ නමින් විචල්යයක් හදනවා" කියලා programming language එකට කියන එක. මේක හරියට පෙට්ටියක් ගෙනල්ලා, ඒකට නමක් ගහනවා වගේ වැඩක්.
  2. ආරම්භක අගයක් ලබා දීම (Initialization): ඒ හදාගත් විචල්යයට මුල්ම අගය දෙන එක. මේක හරියට අර නම ගහපු පෙට්ටියට මුලින්ම මොනවාහරි දෙයක් දානවා වගේ.

මේ ක්‍රියාවලිය විවිධ programming languages වලදී පොඩි පොඩි වෙනස්කම් සහිතව සිද්ධ වෙනවා.

උදාහරණ:

1. Python වලදී:

Python වලදී Declaration සහ Initialization එකටම තමයි කරන්නේ. විචල්යයේ වර්ගය (Data Type) මොකක්ද කියලා කලින් කියන්න අවශ්‍ය නැහැ. දාන අගය අනුව Python ඒක තීරණය කරගන්නවා (Dynamic Typing).


# Declaration and Initialization in one step
name = "Sunil"
age = 30

2. Java හෝ C++ වලදී:

මේ වගේ languages වලදී, විචල්යයක් හදන්න කලින් ඒකේ දාන්න යන දත්ත වර්ගය (Data Type) මොකක්ද කියලා අනිවාර්යයෙන්ම කියන්න ඕන (Static Typing). Declaration සහ Initialization එකට හෝ වෙන වෙනම කරන්න පුළුවන්.


// Declaration
int studentAge; 
String studentName;

// Initialization
studentAge = 21;
studentName = "Amara";

// Declaration and Initialization together
double price = 499.99;

3. JavaScript වලදී:

JavaScript වලදී `let`, `const`, හෝ `var` කියන keywords භාවිතා කරලා විචල්ය ප්‍රකාශ කරනවා.


// Declaration
let score;

// Initialization
score = 100;

// Declaration and Initialization together
let playerName = "Ranjan";

අගයක් පැවරීම සහ නැවත පැවරීම (Assignment and Re-assignment)

විචල්යයකට අගයක් ලබා දීම සඳහා සමාන ලකුණ (`=`) භාවිතා කරනවා. இதை **Assignment Operator** ලෙස හඳුන්වයි.


score = 50  # score විචල්යයට 50 අගය පවරනවා
score = 100 # දැන් score විචල්යයේ අගය 100 ලෙස වෙනස් වෙනවා (නැවත පැවරීම)
score = score + 10 # දැන් score එක 110 වෙනවා (පැවති අගයට 10ක් එකතු කර නැවත පවරනවා)

විචල්ය නම් කිරීමේ නීති (Variable Naming Rules & Conventions) 📜

විචල්යයකට හිතෙන හිතෙන විදිහට නමක් දෙන්න බැහැ. ඒකට අදාළ නීති මාලාවක් සහ හොඳම පුරුදු කිහිපයක් තියෙනවා.

අනිවාර්යයෙන් පිළිපැදිය යුතු නීති (The Rules)

  1. අකුරකින් හෝ යටින් ඉරකින් (underscore `_`) පටන් ගත යුතුය: නමක් ඉලක්කමකින් පටන් ගන්න බැහැ.
    • ✔️ හරි: `name`, `_name`, `name1`
    • ❌ වැරදියි: `1name`
  2. ඉංග්‍රීසි අකුරු (a-z, A-Z), ඉලක්කම් (0-9) සහ යටින් ඉරි (underscore `_`) පමණක් අඩංගු විය හැක: විශේෂ συμβόλων (`@`, `#`, `$`, `%`, `&`, `-`) භාවිතා කරන්න බැහැ.
    • ✔️ හරි: `user_age`, `playerScore1`
    • ❌ වැරදියි: `user-age`, `player@score`
  3. Case-Sensitive වේ: Simple සහ Capital අකුරු වෙනස් විදිහට සලකනවා. `age`, `Age` සහ `AGE` කියන්නේ විචල්ය තුනක්.
  4. Reserved Keywords භාවිතා කළ නොහැක: සෑම programming language එකකටම වෙන් කරගත් වචන (Keywords) තියෙනවා (උදා: `if`, `else`, `for`, `while`, `class`). මේ වචන විචල්ය නාම ලෙස භාවිතා කරන්න බැහැ.

හොඳම පුරුදු සහ සම්ප්රදායන් (Best Practices & Conventions)

මේවා නීති නොවුනත්, ලොව පුරා සිටින programmers ලා පිළිපදින සම්ප්‍රදායන් නිසා ඔබේ කේතය වෘත්තීය මට්ටමකට ගේන්න මේවා අනුගමනය කිරීම ඉතා වැදගත්.

විචල්යයන්ගේ පොදු දත්ත වර්ග (Common Data Types) 🔢🔤

විචල්යයකට දාන්න පුළුවන් දත්ත එකම වර්ගයේ නැහැ. අපි ගබඩා කරන දත්තයේ ස්වභාවය අනුව එය විවිධ වර්ග (Types) වලට බෙදෙනවා. මේවාට **Data Types** කියා කියනවා. ප්‍රධානම Data Types කිහිපයක් මෙන්න.

1. Integer (පූර්ණ සංඛ්යා)

දශමස්ථාන නැති, ධන හෝ ඍණ සම්පූර්ණ සංඛ්‍යා මේ වර්ගයට අයත් වේ. බොහෝ languages වල `int` ලෙස මෙය හඳුන්වයි.


# Python
user_age = 28
number_of_items = 50
year = 2025

# Java
int userAge = 28;
int numberOfItems = 50;

2. Float / Double (ทศම සංඛ්යා)

දශමස්ථාන සහිත සංඛ්‍යා මේ වර්ගයට අයත් වේ. `float` සහ `double` අතර වෙනස වන්නේ `double` එකකට ගබඩා කළ හැකි දශමස්ථාන ගණන (precision) වැඩි වීමයි. එදිනෙදා භාවිතයේදී බොහෝ විට `float` ප්‍රමාණවත් වේ.


# Python
item_price = 199.99
pi_value = 3.14159
height_in_meters = 1.75

# Java
float itemPrice = 199.99f; // f denotes it's a float
double piValue = 3.1415926535;

3. String (අක්ෂර වැල්)

තනි අකුරක්, වචනයක්, වාක්‍යයක් හෝ අක්ෂර එකතුවක් String ලෙස හැඳින්වේ. Strings සෑම විටම උඩු කොමා (Single quotes `' '` හෝ Double quotes `" "`) ඇතුළේ ලිවිය යුතුය. බොහෝ languages වල `str` හෝ `String` ලෙස හඳුන්වයි.


# Python
student_name = "Nimali Silva"
message = 'Hello World!'
email = "nimali@email.com"

# Java
String studentName = "Nimali Silva";

4. Boolean (බුලියන)

යමක් "හරි" ද "වැරදි" ද, "ඔව්" ද "නැහැ" ද, "සත්‍ය" ද "අසත්‍ය" ද යන්න නිරූපණය කිරීමට Boolean data type එක භාවිතා කරයි. මෙයට තිබිය හැක්කේ අගයන් දෙකක් පමණි: **True** (සත්‍ය) හෝ **False** (අසත්‍ය). බොහෝ languages වල `bool` හෝ `boolean` ලෙස හඳුන්වයි. මේවා තීරණ ගැනීමේදී (conditional logic) ඉතා වැදගත් වේ.


# Python
is_logged_in = True
has_permission = False

# Java
boolean isLoggedIn = true;
boolean hasPermission = false;

භාවිතය:


if is_logged_in == True:
    print("Welcome to your profile!")
else:
    print("Please log in first.")

විචල්යයක व्याප්තිය (Variable Scope) 🌐

Scope කියන්නේ ටිකක් advanced සංකල්පයක් උනත්, ICT basics ඉගෙන ගන්න ඔබට මේ ගැන මූලික අවබෝධයක් තිබීම ඉතා වැදගත්. සරලවම, **Scope එකක් කියන්නේ program එකේ යම් විචල්යයක් වලංගු වන (accessible) ප්‍රදේශයයි.**

හිතන්න ඔබේ ගෙදර Wi-Fi router එක ගැන. ඔබට ගේ ඇතුලේ ඉන්නකොට Wi-Fi signal හොඳටම තියෙනවා. ඒත් පාරට බැස්සම signal නැති වෙනවා. ඒ කියන්නේ Wi-Fi එකේ "scope" එක ඔබේ ගෙදරට සීමා වෙලා. විචල්යත් ඒ වගේ තමයි. සමහර විචල්යයන් program එකේ ඕනම තැනක ඉඳන් පාවිච්චි කරන්න පුළුවන්, සමහර ඒවා යම්කිසි කොටසකට විතරක් සීමා වෙලා.

ප්‍රධාන Scope වර්ග දෙකක් තියෙනවා.

1. Global Scope

යම් function එකක් හෝ code block එකක් ඇතුළත නොව, program එකේ ප්‍රධාන මට්ටමේ (main level) හදන විචල්යයන් Global Scope එකට අයත් වේ. මේවා program එකේ **ඕනෑම තැනක සිට** භාවිතා කළ හැක.


# Python Example
player_name = "Ravi"  # This is a global variable

def print_player_name():
    print("Inside the function, player is:", player_name)

print_player_name()
print("Outside the function, player is:", player_name)

# Output:
# Inside the function, player is: Ravi
# Outside the function, player is: Ravi

Global variables පහසු උනත්, විශාල program වලදී এগুলো භාවිතා කිරීමෙන් අනවශ්‍ය ගැටළු (bugs) ඇතිවිය හැකි නිසා, අවශ්‍යම තැනකදී පමණක් භාවිතා කිරීම සුදුසුයි.

2. Local Scope

Function එකක් හෝ code block එකක් (`{}` වරහන් වැනි) **ඇතුළත** හදන විචල්යයන් Local Scope එකට අයත් වේ. මේවා වලංගු වන්නේ ඒවා හදපු function/block එක **ඇතුළත පමණි**. එයින් පිටතදී ඒවා භාවිතා කළ නොහැක.


# Python Example
def calculate_bonus():
    bonus_amount = 5000  # This is a local variable
    print("Bonus inside function is:", bonus_amount)

calculate_bonus()

# The line below will cause an ERROR because 'bonus_amount' is not defined in the global scope.
# print(bonus_amount) 
# NameError: name 'bonus_amount' is not defined

Local variables භාවිතා කිරීමෙන් program එකේ විවිධ කොටස් එකිනෙකට ස්වාධීනව ක්‍රියාත්මක වන නිසා, කේතය වඩාත් පිළිවෙල සහ ආරක්ෂිත වේ.

නියතයන් සහ විචල්යයන් (Constants vs. Variables) ⚖️

විචල්යයක් (Variable) යනු අගය වෙනස් කළ හැකි දෙයක් බව අපි දැන් දන්නවා. නමුත් සමහර වෙලාවට program එකේදී කවදාවත් වෙනස් නොවන අගයන් අපිට භාවිතා කරන්න වෙනවා. උදාහරණයක් විදිහට π අගය (3.14159). මෙවැනි, අගය වෙනස් කළ නොහැකි විචල්යයන් **නියතයන් (Constants)** ලෙස හඳුන්වනවා.

විවිධ languages වලදී Constants හදන විදි වෙනස්.

නියතයන් භාවිතා කිරීමෙන්, වැරදීමකින්වත් එම අගයන් වෙනස් වීම වළක්වා ගන්නත්, කේතය කියවන කෙනාට මෙය ස්ථිර අගයක් බව පහසුවෙන් තේරුම් ගන්නත් පුළුවන්.

ප්රායෝගික උදාහරණ (Practical Examples) 💻

අපි මේ ඉගෙන ගත්ත දේවල් තවත් හොඳින් තහවුරු කරගන්න, සරල උදාහරණ කිහිපයක් බලමු. අපි Python language එක මේ සඳහා භාවිතා කරමු.

උදාහරණය 1: සරල Calculator එකක්

සංඛ්‍යා දෙකක් එකතු කර, අඩු කර, ගුණ කර, බෙදා ප්‍රතිඵලය පෙන්වන program එකක්.


# 1. Declare and initialize variables for two numbers
number1 = 20
number2 = 5

# 2. Perform calculations and store results in new variables
sum_result = number1 + number2
difference_result = number1 - number2
product_result = number1 * number2
division_result = number1 / number2

# 3. Print the results to the screen with descriptive text
print("First Number is:", number1)
print("Second Number is:", number2)
print("------------------------")
print("Sum (එකතුව):", sum_result)
print("Difference (අන්තරය):", difference_result)
print("Product (ගුණිතය):", product_result)
print("Division (බෙදීම):", division_result)

උදාහරණය 2: පරිශීලක තොරතුරු ගබඩා කිරීම

ශිෂ්‍යයෙකුගේ මූලික තොරතුරු විචල්යයන් වල ගබඩා කර, පිළිගැනීමේ පණිවිඩයක් සකසමු.


# Store student information in variables
student_name = "Pavan Gunarathne"
student_age = 17
student_grade = 12
is_ict_student = True # A boolean variable

# Create a welcome message using the variables
welcome_message = "Welcome, " + student_name + "!"
details_message = "You are " + str(student_age) + " years old and you are in Grade " + str(student_grade) + "."

# Print the messages
print(welcome_message)
print(details_message)

# Use the boolean variable in an if-condition
if is_ict_student == True:
    print("We are happy to have you in our ICT class.")
else:
    print("Enjoy your studies in the other streams.")

සැලකිය යුතුයි: මෙහි `str(student_age)` ලෙස භාවිතා කර ඇත්තේ integer අගයක් string එකක් සමග එකතු (concatenate) කිරීමට පෙර එය string බවට පරිවර්තනය කිරීමටයි.

සාරාංශය (Conclusion) ✨

ඉතින්, විචල්ය (Variables) කියන්නේ programming වල හදවත වගේ. ඒවා නැතුව අපිට දත්ත ගබඩා කරන්න, ගණනය කිරීම් කරන්න, හෝ වැඩසටහන් වලට තර්කනයක් (logic) ගොඩනගන්න බැහැ. මෙම ලිපියෙන් ඔබ **ICT basics** වල ඉතාම වැදගත් කොටසක් වන විචල්යයන් ගැන ගැඹුරු අවබෝධයක් ලබාගන්න ඇති කියලා අපි විශ්වාස කරනවා.

අපි ඉගෙන ගත් ප්‍රධාන කරුණු:

දැන් ඔබට විචල්යයන් යනු කුමක්ද යන්න පිළිබඳව පැහැදිලි චිත්‍රයක් තිබෙනවා. ඔබේ programming ගමනේ පළමු සහ වැදගත්ම පියවර ඔබ සාර්ථකව තබා අවසන්! දැන් ඉතිරිව ඇත්තේ මේවා භාවිතා කර පුහුණු වීමයි. ඉහත උදාහරණ ඔබේ පරිගණකයේ ක්‍රියාත්මක කර බලන්න, අගයන් වෙනස් කර ලැබෙන ප්‍රතිඵල අධ්‍යයනය කරන්න.

ඊළඟට මොකක්ද? ඔබ විචල්යයන් ගැන හොඳින්ම දන්නා නිසා, අපේ ඊළඟ ලිපිය වන **"ලූප් (Loops) යනු කුමක්ද?"** කියවන්නට අපි ඔබට ආරාධනා කරනවා. එහිදී අපි එකම කාර්යය නැවත නැවතත් කරන්නේ කෙසේදැයි ඉගෙන ගනිමු!