Что такое late init в Dart?

Late Init в Dart: Отложенная инициализация

Ключевое слово late в Dart позволяет объявлять переменные без немедленной инициализации, откладывая это на позже. Это мощный инструмент, но нужно понимать когда и как его использовать правильно.

1. Что такое late?

late — модификатор переменной, который говорит компилятору: "Я гарантирую, что инициализирую эту переменную ДО её использования, но не прямо сейчас".

// ❌ Ошибка: переменная final без значения
class User {
  final String name; // Ошибка компилятора!
}

// ✅ Правильно: используем late
class User {
  late final String name; // Инициализируется позже
}

// ✅ Или указываем значение сразу
class User {
  final String name; // С инициализацией
  User(this.name);
}

2. Основной случай: Зависимостьи в конструкторе

class UserRepository {
  late final HttpClient httpClient; // Инициализируется в initAsync()
  late final Database database;

  UserRepository() {
    // Конструктор не может быть async
  }

  Future<void> initialize() async {
    // Но можем инициализировать здесь
    httpClient = HttpClient();
    database = await DatabaseHelper.open();
  }

  Future<User> getUser(int id) async {
    // Гарантия: httpClient уже инициализирован
    final response = await httpClient.get('/users/$id');
    return User.fromJson(response);
  }
}

// Использование
var repo = UserRepository();
await repo.initialize(); // Инициализируем зависимости
var user = await repo.getUser(1); // Теперь используем

3. Late поля в StatefulWidget

Это очень частый паттерн во Flutter.

class UserListScreen extends StatefulWidget {
  @override
  State<UserListScreen> createState() => _UserListScreenState();
}

class _UserListScreenState extends State<UserListScreen> {
  late final UserRepository userRepository; // Инициализируется в initState()
  late Future<List<User>> futureUsers; // Отложенное вычисление

  @override
  void initState() {
    super.initState();
    // Инициализируем late переменные
    userRepository = context.read<UserRepository>();
    futureUsers = userRepository.getUsers();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: FutureBuilder<List<User>>(
        future: futureUsers,
        builder: (context, snapshot) {
          // Теперь futureUsers инициализирована
          if (snapshot.hasData) {
            return ListView(
              children: snapshot.data!.map(
                (user) => UserTile(user: user),
              ).toList(),
            );
          }
          return CircularProgressIndicator();
        },
      ),
    );
  }
}

4. Late с вычисляемыми значениями

class Product {
  final String name;
  final double price;
  late final double taxAmount; // Вычисляется один раз
  late final double totalPrice;

  Product(this.name, this.price) {
    // Инициализируем вычисляемые поля
    const taxRate = 0.13;
    taxAmount = price * taxRate;
    totalPrice = price + taxAmount;
  }

  @override
  String toString() {
    // taxAmount и totalPrice уже вычислены
    return '$name: \$${totalPrice.toStringAsFixed(2)}';
  }
}

var product = Product('Laptop', 1000);
print(product.toString()); // Laptop: $1130.00
print(product.taxAmount); // 130.0 (уже вычислено)

5. Late vs Nullable (?)

Это важное различие. late и ? решают разные проблемы.

// ❌ НЕ ЛУЧШИЙ ПОДХОД: использовать nullable
class Database {
  HttpClient? client; // Может быть null

  Future<void> connect() async {
    client = await HttpClient.create();
  }

  Future<String> query(String sql) async {
    // Нужна проверка на null
    if (client == null) throw Exception('Not connected');
    return await client!.query(sql); // ! оператор
  }
}

// ✅ ЛУЧШЕ: использовать late
class Database {
  late final HttpClient client; // Гарантированно инициализирована

  Future<void> connect() async {
    client = await HttpClient.create();
  }

  Future<String> query(String sql) async {
    // Без проверок - компилятор гарантирует инициализацию
    return await client.query(sql);
  }
}

6. Ленивая инициализация (Lazy Initialization)

class HeavyResource {
  final String _name;
  late final String _description; // Вычисляется при первом обращении

  HeavyResource(this._name);

  String get description {
    // Getter автоматически инициализирует при первом вызове
    return _description;
  }

  // Или явно через метод:
  late final _database = _initDatabase();

  Future<Database> _initDatabase() async {
    print('Инициализирую базу...');
    await Future.delayed(Duration(seconds: 2));
    return Database();
  }
}

var resource = HeavyResource('MyResource');
print('Created'); // Создана
await resource._database; // Инициализируется ЗДЕСЬ, при первом обращении

7. Правильное использование Late

✅ ДА:

// 1. Инициализация в initState
class MyWidget extends StatefulWidget {
  @override
  State createState() => _MyWidgetState();
}

class _MyWidgetState extends State<MyWidget> {
  late final controller = TextEditingController();

  @override
  void initState() {
    super.initState();
    controller.addListener(_onChanged);
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) => TextField(controller: controller);
}

// 2. Async инициализация
class Repository {
  late final _dio = Dio();
  late final _config = _loadConfig();

  Future<void> init() async {
    // Убеждаемся, что всё инициализировано
    await _config;
  }

  Future<String> _loadConfig() async {
    return 'config_data';
  }
}

❌ НЕТ:

// 1. Если переменная может остаться неинициализирована
class BadExample {
  late String value; // Если никогда не присваиваем - LateInitializationError!

  void process() {
    print(value); // ❌ Crash: LateInitializationError
  }
}

// 2. Если это параметр конструктора
class BadWidget extends StatelessWidget {
  late final String title; // ❌ Неправильно!
  // Используй final String title вместо этого
}

8. LateInitializationError

Если обратиться к late переменной, которая не инициализирована, будет ошибка.

class User {
  late final String name;

  void printName() {
    print(name); // ❌ LateInitializationError: Field 'name' has not been initialized.
  }
}

var user = User();
user.printName(); // Crash!

Защита:

class User {
  late final String name;

  bool get isInitialized {
    try {
      name; // Пытаемся обратиться
      return true;
    } catch (e) {
      return false;
    }
  }

  void printName() {
    if (isInitialized) {
      print(name);
    } else {
      print('Not initialized');
    }
  }
}

9. Late и Performance

late переменные имеют небольшой overhead при первом обращении.

// Внутри Dart это выглядит примерно так:
class User {
  late final String _nameValue;
  bool _nameInitialized = false;

  String get name {
    if (!_nameInitialized) {
      throw LateInitializationError();
    }
    return _nameValue;
  }

  void initName(String value) {
    _nameValue = value;
    _nameInitialized = true;
  }
}

Небольшой overhead, но лучше использовать final конструктор параметры если возможно.

10. Best Practices

// ✅ ЛУЧШЕ всего:
class UserService {
  final HttpClient httpClient; // Всегда передавай через конструктор

  UserService(this.httpClient);
}

// ✅ КОГДА конструктор async невозможен:
class UserService {
  late final HttpClient httpClient;

  Future<void> initialize() async {
    httpClient = await createHttpClient();
  }
}

// ✅ В StatefulWidget:
class _MyWidgetState extends State<MyWidget> {
  late final _controller = TextEditingController();

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

Вывод

late — это инструмент для отложенной инициализации, который:

• Даёт гибкость — инициализируй когда нужно
• Избегает null — гарантия инициализации
• Требует дисциплины — нужно гарантировать инициализацию
• Полезен в Flutter — особенно в StatefulWidget
• Имеет overhead — небольшой, но есть

Используй late, когда инициализация зависит от контекста или асинхронных операций. Но если возможно, передавай через конструктор — это проще и безопаснее.