В чем разница между функциями анонимной и обычной?

Разница между анонимными и обычными функциями в Dart

Обычная функция (Named Function) и анонимная функция (Anonymous/Lambda Function) — это два способа определения функций в Dart, различающиеся синтаксисом и способом использования.

Обычная функция (Named Function)

Обычная функция имеет имя, которое можно использовать для вызова из любого места кода.

// Базовая обычная функция
int add(int a, int b) {
  return a + b;
}

// Использование
print(add(5, 3)); // 8

// С несколькими параметрами
String greet(String name, int age) {
  return 'Hello, $name! You are $age years old.';
}

print(greet('Alice', 25)); // Hello, Alice! You are 25 years old.

// С параметрами по умолчанию
String createMessage(String name, {String greeting = 'Hello'}) {
  return '$greeting, $name!';
}

print(createMessage('Bob')); // Hello, Bob!
print(createMessage('Bob', greeting: 'Hi')); // Hi, Bob!

// С именованными параметрами
Widget buildButton({
  required String label,
  required VoidCallback onPressed,
  Color? color,
}) {
  return ElevatedButton(
    onPressed: onPressed,
    style: ElevatedButton.styleFrom(backgroundColor: color),
    child: Text(label),
  );
}

// С возвращаемым типом Future
Future<String> fetchData(String url) async {
  final response = await http.get(Uri.parse(url));
  return response.body;
}

Характеристики обычной функции:

• Имеет имя — можно вызвать по названию
• Видна повсюду — можно вызвать из любого места (если в области видимости)
• Легко читать — имя описывает, что делает функция
• Легко отлаживать — видна в stack trace
• Переиспользуемая — можно вызвать много раз
• Может быть async — поддерживает async/await

// Обычная функция с async
Future<List<User>> loadUsers() async {
  final response = await api.fetchUsers();
  return response.users;
}

// Использование
var users = await loadUsers();

Анонимная функция (Lambda/Anonymous Function)

Анонимная функция не имеет имени и обычно используется как значение для передачи в другие функции или присваивания переменной.

// Базовая анонимная функция
var add = (int a, int b) {
  return a + b;
};

print(add(5, 3)); // 8

// Стрелочная функция (Arrow function) - краткий синтаксис
var multiply = (int a, int b) => a * b;

print(multiply(4, 5)); // 20

// С одним параметром - скобки опциональны
var square = (int x) => x * x;
var squareAlt = (x) => x * x; // Тип может быть опущен

print(square(5)); // 25

// Без параметров
var greeting = () => 'Hello';
print(greeting()); // Hello

// С несколькими строками кода
var process = (int number) {
  var doubled = number * 2;
  var squared = doubled * doubled;
  return squared;
};

print(process(3)); // (3*2)^2 = 36

// Без явного типа возврата
var complexOperation = (String name, int age) {
  print('Processing $name with age $age');
  return 'Result';
};

Характеристики анонимной функции:

• Нет имени — только синтаксис "(параметры) => тело"
• Используется как значение — часто передаётся как аргумент
• Компактный синтаксис — особенно со стрелочной нотацией
• Локальная область — часто используется в узком контексте
• Может быть async — поддерживает async/await

Использование анонимных функций

В методах высшего порядка (Higher-order functions):

// map - преобразование элементов
var numbers = [1, 2, 3, 4, 5];
var doubled = numbers.map((x) => x * 2).toList(); // [2, 4, 6, 8, 10]

// where - фильтрация
var evens = numbers.where((x) => x % 2 == 0).toList(); // [2, 4]

// forEach - обход
numbers.forEach((x) => print(x));

// reduce - агрегация
var sum = numbers.reduce((a, b) => a + b); // 15

// sort с компаратором
numbers.sort((a, b) => b - a); // Сортировка в обратном порядке

В callback функциях (Flutter):

ElevatedButton(
  onPressed: () => print('Button pressed'), // Анонимная функция
  child: Text('Click me'),
)

TextField(
  onChanged: (value) {
    print('Text changed: $value');
  },
)

FloatingActionButton(
  onPressed: () {
    setState(() {
      _counter++;
    });
  },
  child: Icon(Icons.add),
)

В Future/async:

// Анонимная функция в then
future.then((result) => print('Result: $result'))
      .catchError((error) => print('Error: $error'));

// Или более явно
future.then((result) {
  print('Result: $result');
  return processResult(result);
});

Сравнение

Практические примеры

Когда использовать обычную функцию:

// Функция используется много раз
String formatUserName(String firstName, String lastName) {
  return '$firstName ${lastName.toUpperCase()}';
}

print(formatUserName('John', 'Doe')); // John DOE
print(formatUserName('Alice', 'Smith')); // Alice SMITH

// Сложная логика
Future<bool> validateUser(User user) async {
  final isEmailValid = await checkEmail(user.email);
  final isPasswordStrong = user.password.length > 8;
  final isAgeValid = user.age >= 18;
  
  return isEmailValid && isPasswordStrong && isAgeValid;
}

// Нужна повторная отладка
List<Product> filterProducts({
  required List<Product> products,
  required double maxPrice,
  required String category,
}) {
  return products
      .where((p) => p.category == category)
      .where((p) => p.price <= maxPrice)
      .toList();
}

Когда использовать анонимную функцию:

// Простая трансформация данных
var prices = products.map((p) => p.price).toList();

// Фильтрация по простому критерию
var activeUsers = users.where((u) => u.isActive).toList();

// Обработчик события
button.onPressed = () => _handleButtonPress();

// Сортировка
users.sort((a, b) => a.name.compareTo(b.name));

// Простой callback
fetchData().then((data) => updateUI(data));

// Итерация
items.forEach((item) => print(item.name));

Лучшие практики

Используй обычную функцию если:

• Функция используется в более одного места
• Функция содержит сложную логику (более 1-2 строк)
• Функция нужна для документирования поведения
• Функция нужна для отладки и stack trace

Используй анонимную функцию если:

• Это одноразовое использование
• Логика очень простая (1-2 строки)
• Функция передаётся как аргумент
• Контекст ясен без имени функции

Золотое правило: Если функция достаточно сложная для того, чтобы её сложно было понять с первого взгляда, создай обычную функцию с понятным именем. Простые преобразования и фильтры — отличные кандидаты для анонимных функций.