ცვლადები

ცვლადს ხშირად საწყობს ადარებენ. ის პროგრამისტისთვის ძირეულ ცნებას წარმოადგენს. C#-ში ცვლადის გამოცხადება ასე ხდება.

<მონაცემის ტიპი> <სახელი>;

მაგალითი ასე შეიძლება გამოიყურებოდეს:

string name;

ეს არის ყველაზე საბაზისო ვარიანტი, მაგრამ ამ ცვლადს მნიშნველობა ჯერ არ აქვს მინიჭებული. მნიშნველობის მინიჭება გამოვხადებისთანავე შეგიძლიათ ან მოგვიანებით, აი ასე:

<data type> <name> = <value>;

თუ ეს ცვლადი მეთოდის შიგნით არ არის განსაზღვრული (მაგალითად, კლასის წევრი ცვლადია), შესაძლოა მისი ხილვადობის განსაზღვრა გინდოდეს:

<ხილვადობის განმსაზღვრელი> <მონაცემის ტიპი> <სახელი> = <მნიშვნელობა>;

აი მაგალითი სრული სახით:

private string name = "John Doe";

ხილვადობის ნაწილი კლასებს უკავშირდება, ასე რომ ამ თემის უფრო სრულყოფილი ახსნა კლასებისთვის მიძღვნილ თავში შეგიძლიათ მოიძიოთ. მოდით, ყურადღება ცვლადების ნაწილზე გავამახვილოთ და რამდენიმე პრაქტიკული მაგალითი განვიხილოთ:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        string firstName = "John";
        string lastName = "Doe";

        Console.WriteLine("Name: " + firstName + " " + lastName);

        Console.WriteLine("Please enter a new first name:");
        firstName = Console.ReadLine();

        Console.WriteLine("New name: " + firstName + " " + lastName);

        Console.ReadLine();
    }
    }
}

კარგით, აქედან ბევრი რამ უკვე ავხსენით, ამიტომ უფრო საინტერესო ნაწილზე გადავიდეთ. უპირველეს ყოვლისა, string ტიპის რამდენიმე ცვლადი გამოვაცხადოთ. string-ი უბრალოდ ტექსტს შეიცავს. როგორც ხედავთ ჩვენ მას პირდაპირ მივანიჭეთ ტექსტური მნიშვნელობა. შემდეგ ტექსტის ხაზი კონსოლში გამოგვაქვს, სადაც ვიყენებთ ორ ცვლადს. string-ის სხვადასხვა ნაწილების "შეწებება" + სიმბოლოთი ხორციელდება.

შემდეგ, მომხმარებელს ახალი სახელის შემოყვანას ვთხოვთ, ამის შემდეგ ვიყენებთ ReadLine() მეთოდს იმისათვის, რომ მომხმარებელმა კონსოლიდან შემოიყვანოს ტექსტი რომელიც firstName ცვლადში უნდა ჩაიწეროს. როგორც კი მომხმარებელი Enter ღილაკს დააჭერს, firstName ცვლადს ახალი მნიშნველობა მიენიჭება. შემდეგ ხაზზე ისევ ვბეჭდავთ სახელს რათა ვაჩვენოთ განხორციელებული ცვლილებები. ჩვენ ახლახანს გამოვიყენეთ ჩვენი პირველი ცვლადი და ცვლადების ერთ-ერთი ყველაზე მნიშვნელოვანი თვისება: პროგრამის მსვლელობის დროს მნიშვნელობის ცვლილების უნარი.

კიდევ ერთი საინტერესო მაგალითი მათემატიკური ოპერაციების შესრულებაა. აი ერთ-ერთი, რომელიც ძირითადად წინა მაგალითში გამოყენებულ კოდზეა დაფუძნებული:

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

ჩასვით ეს კოდი ჩვენს Main მეთოდში და სცადეთ თავიდან. ერთადერთი "ხრიკი" რაც აქ გამოვიყენეთ int.Parse() მეთოდია. ეს მეთოდი უბრალოდ კითხულობს ტექსტს და მთელ რიცხვად აქცევს. როგორც ხედავთ ეს აპლიკაცია არაფერს აკეთებს იმისთვის რომ მომხმარებლის მიერ შემოყვანილი მნიშვნელობები შეამოწმოს, და თუ რამე ისეთს შემოიყვანთ რაც რიცხვი არ არის, გამონაკლისი სიტუაცია დაფიქსირდება. ამის შესახებ მოგვიანებით ვისაუბრებთ.

ცვლადები & სიცოცხლის არეალი (scope)

აქამდე, ჩვენ მხოლოდ ლოკალურ ცვლადებს ვიყენებდით. ლოკალური ცვლადები ისეთ ცვლადებს ეწოდებათ, რომლებიც რომელიმე მეთოდის შიგნით არიან შექმნილი და გამოყენებული. C# მეთოდის შიგნით გამოცხადებული ცვლადებს სხვა მეთოდი ვერ გამოიყენებს - სწორედ ამიტომ ეწოდებათ მათ ლოკალური. თუ სხვა რომელი პროგრამირების ენას ფლობთ, გეცოდინებათ გლობალური ცვლადების ცნება, რომლებზე წვდომაც ნებისმიერი ადგილიდან შეგიძლიათ, მაგრამ C#-ში გლობალური ცვლადები არ არის მხარდაჭერილი. ამის მაგივრად შეგიძლიათ კლასში ველი გამოაცხადოთ, რომელიც ხელმისაწვდომი იქნება კლასის ყველა მეთოდისთვის. ნება მომეცით ეს მაგალითის გამოყენებით წარმოგიდგინოთ:

using System;

namespace VariableScope
{
    class Program
    {
    private static string helloClass = "Hello, class!";

    static void Main(string[] args)
    {
        string helloLocal = "Hello, local!";
        Console.WriteLine(helloLocal);
        Console.WriteLine(Program.helloClass);
        DoStuff();
    }

    static void DoStuff()
    {
        Console.WriteLine("A message from DoStuff: " + Program.helloClass);
    }
    }
}

ყურადღება მიაქციეთ helloClass წევრი მეთოდის მაგივრად კლასშია გამოცხადებული. ეს საშუალებას მოგვცემს, რომ ამ ველს მივწვდეთ როგორც Main() მეთოდიდან ასევე ჩვენ მიერ შექმნილი DoStuff() მეთოდიდან. მაგრამ ეს არ არის ჭერშმარიტება helloLocal ცვლადისთვის, რომელიც Main() მეთოდის შიგნით არის გამოცხადებული და მხოლოდ ამ კონკრეტული მეთოდის მიერ გამოიყენება.

ცნებას რომელიც ცვლადის გამოცხადების ადგილმდებარეობას განასხვავებს სიცოცხლის არეალს (scoping) უწოდებენ. ის თქვეს კოდს იმ არეულობისგან იცავს რასაც ცვლადების სხვადასხვა ადგილიდან შეცვლა გამოიწვევდა. კიდევ ერთი ტექნიკა რომელიც ამ საკითხში გვეხმარება არის წევრების ხილვადობა (ამ შემთხვევაში ის private საკვანძო სიტყვით არის წარმოდგენილი), რომელსაც კლასებისთვის მიძღვნილ თავში განვიხილავთ.

დასკვნა

ცვლადები სხვადასხვა ტიპის მონაცემების შენახვის საშუალებას გაძლევენ. მაგალითად, ტექსტების, რიცხვების ან საკუთარი ობიექტების. არსებობს ლოკალური ცვლადები, რომლებიც მხოლოდ იმ მეთოდშია ხელმისაწვდომი რომელშიც გამოაცხადეს, ასევე არსებობს კლასის ველები, რომლებიც კლასის ნებისმიერი მეთოდისთვის არის ხელმისაწვდომი და ასევე შესაძლოა კლასის გარედანაც იყოს ხელმისაწვდომი თუ ხილვადობა ამის საშუალებას იძლევა.