Dart: ფუნქციები (functions)

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

Dart-ში ნებისმიერი ფუნქცია შეგვიძლია მივანიჭოთ ცვლადს, ან გადავცეთ სხვა ფუნქციას, როგორც არგუმენტი.

ფუნქციას რომელიც არ აბრუნებს არაფერს აუცილებელია მივანიჭოთ void ტიპი

მაგალითი:

void sayHello() {
  print('Hello, world!');
}

void main() {
  sayHello(); // დაიბეჭდება: Hello, world!
}

განვიხილოთ ფუნქცია, რომელიც აბრუნებს int ტიპის მნიშვნელობას

მაგალითი:

int add(int a, int b) {
  return a + b; // აბრუნებს int ტიპის მნიშვნელობას
}

void main() {
  int sum = add(5, 3);
  print(sum); // დაიბეჭდება: 8
}

სინტაქსურად dart-ს არც თუ ისე ცოტა მსგავსება აქვს ჩვენთვის კარგად ნაცნობ ჯავასკრიპტთან, როგორც ჯავასკრიპტში დარტშიც გვაქვს ე.წ. ისრიანი ფუნქციები (arrow functions).

მაგალითი:

int multiply(int a, int b) => a * b;

void main() {
  int result = multiply(4, 2);
  print(result); // დაიბეჭდება: 8
}

როგორც მაგალითიდან ჩანს multiply ფუნქცია ჩაწერილია 1 ხაზში მსგავსად ჯავასკრიპტის სინტაქსისა.

Optional parameters

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

მაგალითი:

void greet(String name, [String greeting = 'Hello']) {
  print('$greeting, $name!');
}

void main() {
  greet('Alice');        // დაიბეჭდება: Hello, Alice!
  greet('Bob', 'Hi');    // დაიბეჭდება: Hi, Bob!
}

Named parameters

ჯავაკრიპტისგან განსხვავებით dart-ში ასევე გვაქვს ე.წ. სახელიანი პარამეტრები (named parameters), რაც გულისხმობს იმას, რომ პარამეტრს შეგვიძლია მივანიჭოთ სახელი. named parameter-ების გამოსაყენებლად გამოიყენება {} სინტაქსი.

მაგალითი:

void greet({String name = 'User', String greeting = 'Hello'}) {
  print('$greeting, $name!');
}

void main() {
  greet();                           // დაიბეჭდება: Hello, User!
  greet(name: 'Alice');              // დაიბეჭდება: Hello, Alice!
  greet(greeting: 'Hi', name: 'Bob'); // დაიბეჭდება: Hi, Bob!
}

ანონიმური ფუნქციები

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

მაგალითი:

void main() {
  var list = ['apples', 'bananas', 'oranges'];
  
  list.forEach((item) {
    print(item);
  });
  // დაიბეჭდება:
  // apples
  // bananas
  // oranges
}

Higher-Order Functions

ფუნქციებს, რომლებიც პარამეტრად იღებენ სხვა ფუნქციას ან აბრუნებენ ფუნქციას ეწოდებათ ე.წ. higher-order ფუნქციები. (უმაღლესი თანრიგის ფუნქციები. პ.ს. არ ვიცი რამდენად სწორად ითარგმნება 🙁 )

void main() {
  List<int> numbers = [1, 2, 3, 4, 5];
  
  List<int> doubled = numbers.map((num) => num * 2).toList();
  
  print(doubled); // დაიბეჭდება: [2, 4, 6, 8, 10]
}