Kaip deklaruojate kintamuosius ir naudojate var?

Question

Accepted Answer

C# yra statiškai tipizuota — kintamieji turi tipą, žinomą kompiliavimo metu. Kintamąjį galite deklaruoti su aiškiu tipu arba naudoti **`var`** tipo išvadai (kompiliatorius nusprendžia tipą iš reikšmės), tačiau bet kuriuo atveju tipas yra fiksuotas. ## Kintamųjų deklaravimas ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` nusprendžia tipą iš inicijalizavimo — `var age = 30` yra tiksliai `int age = 30`. Labai svarbu, **`var` vis dar yra statiškai tipizuota**: tipas yra fiksuotas kompiliavimo metu (vėliau negalite priskirti eilutės `age`); jis tiesiog išvedamas, o ne dinaminis. ## var reikalinga inicijalizavimo ir tipas lieka fiksuotas ```csharp var x = 5; x = "hi"; // ❌ compile error — x is an int, can't become a string var y; // ❌ error — var needs an initializer to infer from ``` ## Kada naudoti var (stilius) ```csharp var user = new UserService(); // ✅ type is obvious from the right side — var is clean var count = users.Count; int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability ``` Naudokite `var`, kai tipas yra akivaizdus iš dešinės pusės (sumažina pertekliškumą, ypač su ilgais generiniais tipais); naudokite aiškius tipus, kai tai padeda aiškumui. ## Konstantos ir kiti deklaravimai ```csharp const double Pi = 3.14159; // compile-time constant (can't change) readonly int id; // set once (in constructor), then immutable int a = 1, b = 2; // multiple of the same type nint nativeInt; // platform-sized integer ``` ## Bendrieji įmontuoti tipai ```text int, long, short, byte integers float, double, decimal floating point (decimal for money — exact) bool, char, string boolean, character, text object the base of all types ``` ## Kodėl tai svarbu Supratimas apie kintamųjų deklaravimą ir `var` yra pagrindinės kasdieninės C# žinios. Pagrindinė konceptuali idėja yra, kad **`var` yra tipo išvada, o ne dinaminis tipizavimas** — dažna klaidinga sąvoka. Su `var`, kompiliatorius nusprendžia tipą iš inicijalizavimo, tačiau tipas vis dar yra fiksuotas kompiliavimo metu (jūs gausite visus statinio tipizavimo privalumus — tipo tikrinimą, IntelliSense, našumą), tiesiog nerasydami tipo pavadinimo aiškiai. Tai daro `var` patogumo priemone skaitomumui (ypač su plačiais generiniais tipais, tokiais kaip `Dictionary>`) o ne tipo sistemos susilpnijimu. Žinoti, kada naudoti `var` (kai tipas yra akivaizdus iš dešinės pusės, sumažinant pertekliškumą) ir kad naudoti aiškius tipus (kai tai padeda aiškumui), kartu su įmontuotais tipais (ypač **`decimal` pinigams** — tikslus dešimtainis aritmetika, skirtingai nei `double`), konstantomis (`const`, `readonly`), yra kasdieninės C# rašymo žinios. Supratimas, kad C# yra statiškai tipizuota visame (nesvarbu, ar rašote tipą, ar naudojate `var`), ir idiomak aplink kintamųjų deklaravimą, yra pagrindinis žinojimas skaitant ir rašant gražų, teisingą C# kodą, o „var-nėra-dinaminis