Dart: ცვლადები

მოცემულ გაკვეთილში განვიხილავთ Dart-ში ცვლადებს.

განვიხილოთ პირველი მაგალითი

var name = 'Bob';

დარტის ცვლადებში ინახება მიმთითებლები. როგორც დარტის დოკუმენტაციაში ვკითხულობთ ჩვენ აღწერილი გვაქვს name ცვლადი, რომელიც შეიცავს მიმთითებელს String ტიპის ობიექტის, რომლის მნიშვნელობაც არის "Bob".

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

ამას Dart ავტომატურად აკეთებს და name ცვლადს მიანიჭებს მისი საწყისი მნიშვნელობის ტიპს, ანუ ვინაიდან "Bob" წარმოადგენს String ტიპს name ცვლადიც აღიქმება, როგორც String ტიპის.

იმ შემთხვევაში თუ ცვლადს მინიჭებული აქვს რამდენიმე ტიპის მნიშვნელობები ჩვენ შეგვიძლია მას მივანიჭოთ Object ტიპი, ან dynamic.

მაგალითი:

Object name = 'Bob';

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

მაგალითი:

String name = 'Bob';

Null safety

წინა გაკვეთილში ასევე ვახსენეთ, რომ Dart არის null safety პროგრამირების ენა.

როდესაც ჩვენ ავღწერთ ცვლადს ან პარამეტრს ჩვენ გვაქვს საშუალება მივუთითოთ შესაძლებელია თუ არა მიენიჭოთ მათ null მნიშვნელობა, ამის გამოსაყენებლად ჩვენ შეგვიძლია გამოვიყენოთ ? სიმბოლო

მაგალითი:

String? name  // Nullable type. Can be `null` or string.
String name   // Non-nullable type. Cannot be `null` but can be string.

Dart-ში აუცილებელია ცვლადს მინიჭებული ქონდეს რაიმე საწყისი მნიშვნელობა სანამ მის გამოყენებას დავიწყებთ, ჩვენ უბრალოდ არ შეგვიძლია ავღწეროთ ცვლადი საწყისი მნიშვნელობის გარეშე.

როდესაც ვიყენებთ ? სიმბოლოს ეს ნიშნავს, რომ მისი საწყისი მნიშვნელობა შეგნებულად გვაქვს null.

late ცვლადი

მოცემულ ცვლადს აქვს გამოყენების ორი ვარიანტი

• აღწერს non-nullable ცვლადს, რომლის ინიციალიზაციაც შეგვიძლია მისი აღწერის შემდგომ.
• ცვლადის ზარმაც (lazy) ინიციალიზაციას

მაგალითი:

late String description;

void main() {
  description = 'Feijoada!';
  print(description);
}

final და const ცვლადები

იმ შემთხვევაში თუ არ გვჭირდება ცვლადის აღწერის და მინიჭებული მნიშვნელობის ხელახლა მინიჭება ამ შემთხვევაში შეგვიძლია გამოვიყენოთ ცვლადის ორი ტიპი ესენია: final და const ტიპები.

final ცვლადი შეგვიძლია აღვწეროთ და მივანიჭოთ მნიშვნელობა მხოლოდ ერთხელ, ხოლო const ცვლადი არის კომპილაციის დროს აღწერილი კონსტანტა (მნიშვნელობა არ შეიძლება შეიცვალოს).

მაგალითი:

final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';

იმ შემთხვევაში თუ ვეცდებით name-ს მივანიჭოთ ახალი მნიშვნელობა მივიღებთ შეცდომას

მაგალითი:

name = 'Alice'; // Error: a final variable can only be set once.

იმ შემთხვევაში თუ const ტიპის ცვლადის გამოყენება გვინდა კლასში საჭიროა გამოვიყენოთ static const ჩანაწერი სადაც ვახდენთ ცვლადის აღწერას.

ძირითადი განსხვავებები final და const ცვლადებს შორის

1. შესრულების დრო
   1. const: ცვლადის მნიშვნელობა ცნობილი უნდა იყოს კომპილაციის დროს
   2. final: ცვლადის მნიშვნელობა განისაზღვრება runtime-ის დროს და მისი მინიჭება შეიძლება მხოლოდ 1-ხელ
2. გამოყენების კონტექსტი
   1. const: ცვლადი ძირითადად გამოიყენება მათემატიკური მნიშვნელობებისთვის, რომელებიც არ იცვლება, ასევე გამოიყენება კონფიგურაციის მნიშვნელობებისთვის.
   2. final: ცვლადი გამოიყენება იმ შემთხვევაში როდესაც აღარ გვჭირდება მისი მნიშვნელობის შეცვლა, მაგალითად მომხმარებლის მიერ შეყვანილი ინფორმაცია, და ა.შ.
3. მუტაცია
   1. ორივე ცვლადი არ შეიძლება შეიცვალოს, მაგრამ const ცვლადის instance შეიძლება გაზიარებულ იქნას, როდესაც ყოველ ახალ final ცვლადს აქვს თავისი უნიკალური instacne

const ცვლადის გამოყენების მაგალითი:

class Circle {
  static const double pi = 3.14159; // Compile-time constant

  final double radius;

  Circle(this.radius);

  double get area => pi * radius * radius;
}

void main() {
  final circle = Circle(5);
  print('Area of circle: ${circle.area}'); // Output: Area of circle: 78.53975
}

final ცვლადის გამოყენების მაგალითი:

class User {
  final String name;

  User(this.name);
}

void main() {
  final user1 = User('Alice');
  final user2 = User('Bob');

  print('User 1: ${user1.name}'); // Output: User 1: Alice
  print('User 2: ${user2.name}'); // Output: User 2: Bob
}