Что такое неявное приведение типов в Dart?

Неявное приведение типов в Dart: Type Coercion

Неявное приведение типов (type coercion) — это автоматическое преобразование одного типа данных в другой, которое выполняет компилятор или интерпретатор без явного запроса разработчика. В Dart эта концепция особенно важна из-за его строгой типизации.

Важная особенность Dart

Dart НЕ поддерживает неявное приведение типов!

В отличие от JavaScript или Python, Dart — это strongly typed язык, и автоматических преобразований типов почти нет.

// ОШИБКА! Нельзя неявно преобразовать
int x = '5';        // Type error: String cannot be assigned to int
double y = 5;       // Type error: int cannot be assigned to double
bool z = 1;         // Type error: int cannot be assigned to bool

Где Dart позволяет некоторые преобразования

1. int в double (числовые типы):

double x = 5;       // ОШИБКА!
double y = 5.0;     // OK

// Правильно: явное преобразование
double x = 5.toDouble();  // OK

// Или через double
int number = 42;
double converted = number as double; // Явное приведение
print(converted); // 42.0

2. null в nullable тип:

int? x = null;      // OK — int? может быть null
int y = null;       // ОШИБКА! int не может быть null

3. Подкласс в суперкласс:

class Animal {}
class Dog extends Animal {}

Dog dog = Dog();
Animal animal = dog; // OK — неявное преобразование подкласса

Явное приведение типов

В Dart используется оператор as для явного приведения:

Приведение через as:

// Строка в число
String str = '42';
int number = int.parse(str);    // Правильно
int bad = str as int;           // Runtime error!

// Список в более конкретный тип
List<dynamic> list = [1, 2, 3];
List<int> intList = list as List<int>; // Явное приведение

Методы конвертации:

// String -> int
String str = '123';
int number = int.parse(str);
int number2 = int.tryParse(str) ?? 0; // Безопаснее

// String -> double
String decimal = '3.14';
double pi = double.parse(decimal);

// int -> String
int num = 42;
String text = num.toString();

// int -> double
int value = 5;
double converted = value.toDouble();

Type promotion (Повышение типа)

Это не совсем неявное приведение, но похоже:

Object? value = 'Hello';

// Проверка типа
if (value is String) {
  // Здесь value автоматически String!
  print(value.length); // OK, String метод
  String text = value; // OK
}

// Аналогично с null
String? name = 'Alice';
if (name != null) {
  // Здесь name автоматически String (не null)
  print(name.toUpperCase()); // OK
}

Pattern matching и type narrowing

Современный подход (Dart 3.0+):

union sealed class Result<T> {
  factory Result.success(T data) = Success;
  factory Result.failure(String error) = Failure;
}

class Success<T> extends Result<T> {
  final T data;
  Success(this.data);
}

class Failure<T> extends Result<T> {
  final String error;
  Failure(this.error);
}

// Pattern matching
Result<int> result = Result.success(42);

switch (result) {
  case Success(:final data):
    print('Успех: $data'); // data автоматически правильного типа
  case Failure(:final error):
    print('Ошибка: $error');
}

Null safety и неявные преобразования

Null coalescing (??)

String? name = null;
String displayName = name ?? 'Unknown'; // Не приведение типа

Null assertion (!)

String? value = getValue();
String nonNull = value!; // Неявный переход от nullable к non-nullable

if (value != null) {
  // Здесь тип автоматически String (без !)
  String safe = value;
}

Сравнение: Dart vs JavaScript

JavaScript (есть неявное приведение):

console.log('5' + 3);      // '53' (String concatenation)
console.log('5' - 3);      // 2 (Number operation)
console.log('5' == 5);     // true (неявное приведение)
console.log(null == undefined); // true (неявное приведение)

Dart (строгая типизация):

print('5' + 3.toString()); // '53' (явное преобразование)
print(5 - 3);             // 2 (оба int)
print('5' == 5);          // false (разные типы)
print(null == undefined);  // Ошибка: undefined не существует

Работа с dynamic (избегайте!)

dynamic позволяет обойти типизацию:

dynamic value = '42';
int number = value; // Компилируется, но рискованно!

// Runtime error, если value не может быть преобразован
value = 'abc';
int bad = value; // Crash!

Правильнее использовать is check:

dynamic value = '42';

if (value is int) {
  int number = value; // Безопасно
} else if (value is String) {
  int number = int.parse(value); // Явное преобразование
}

Безопасное преобразование в реальном коде

JSON парсинг:

void parseJson(Map<String, dynamic> json) {
  // Небезопасно
  // String name = json['name'];
  
  // Правильно
  String name = json['name'] as String?? 'Unknown';
  int age = (json['age'] as int?) ?? 0;
  
  // Еще безопаснее
  final name = json['name'];
  if (name is String) {
    print('Имя: $name');
  }
}

API ответы:

class UserResponse {
  final String id;
  final String name;
  final int age;
  
  UserResponse.fromJson(Map<String, dynamic> json) :
    id = json['id'] as String,
    name = json['name'] as String,
    age = json['age'] as int;
}

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

1. Не полагайтесь на неявные преобразования:

// Плохо
int value = getData(); // Может быть null или wrong type

// Хорошо
int? value = getData();
if (value != null) {
  // использовать value
}

2. Используйте type checking перед приведением:

// Плохо
var result = (response as List<User>)[0];

// Хорошо
if (response is List<User> && response.isNotEmpty) {
  var user = response[0];
}

3. Используйте методы парсинга вместо приведения:

// Плохо
int number = stringValue as int; // Crash!

// Хорошо
int number = int.tryParse(stringValue) ?? 0;

4. Избегайте dynamic когда возможно:

// Плохо
void process(dynamic data) {
  if (data is String) print(data.length);
}

// Хорошо
void process(Object data) {
  if (data is String) print(data.length);
}

Запомните: Dart НЕ позволяет неявное приведение типов — это делает код безопаснее и предотвращает скрытые ошибки.