2.5. Коротко о Dart: часть вторая

Автор: Даниил Артамонов

В предыдущей статье мы начали наш короткий обзор Dart — поговорили о переменных, коллекциях и строках.

Мы сфокусируемся на функциях и null-safety — системе, которая предотвращает ошибки доступа к null на этапе компиляции.

Но в первую очередь поговорим про:

  • тернарный оператор;
  • класс enhanced enum;
  • typedef;
  • модификаторы доступа.

Давайте приступим!

Тернарный оператор

В определённых ситуациях if-else избыточен, тогда на помощь приходит тернарный оператор:

bool isEvenFull(int value) {
 bool result;

 if (value % 2 == 0) {
  result = true;
 } else {
  result = false;
 }

 return result;
}

//Может быть чуть короче
bool isEvenShort(int value) {
 return value % 2 == 0 ? true : false;
}

Класс еnhanced enum

В Dart есть знакомые многим enum-типы, объявить простейший enum можно так:

enum Color {red, green, blue}

В версии языка 2.17 разработчики добавили enhanced enum.

Enhanced enum — класс со своими полями, методами и конструкторами, но с определёнными ограничениями:

  • Поля класса должны быть final, включая те, что подмешаны через with;
  • Все конструкторы должны быть константными;
  • Все factory-конструкторы могут вернуть только один из объявленных экземпляров Enum;
  • Нельзя переопределить index, hashCode или оператор равенства ==;
  • Нельзя использовать имя values для членов класса, потому что это конфликтует с геттером values из API стандартных enum;
  • В начале enum нужно объявить все возможные значения. При этом в целом значений должно быть не менее одного.

Enhanced enum может пригодиться во многих случаях.

К примеру, при работе с иконками:

enum MyIcon {
  close(path: 'assets/close', width: 200),
  car(path: 'assets/car', width: 300),
  driver(path: 'assets/driver', width: 300);

  const MyIcon({
    required this.path,
    required this.width,
  });

  factory MyIcon.withName(String name) =>
      values.firstWhere((v) => v.name.contains(name), orElse: () => close);

  final String path;
  final double width;

  String getThemedPath(bool isDarkTheme) =>
      isDarkTheme ? '${path}_night.webp' : '$path.webp';
}

typedef

Это ключевое слово позволяет переименовать какой-то тип.

typedef JSON = Map<String, Object?>;
typedef Converter = String Function(int value); // Что это такое? см. Функции

String convertToString(int value, Converter converter) => converter?.call(value);

class MyModel {
 final int value;

 MyModel(this.value);

  factory MyModel.fromJson(JSON json) => MyModel(json['value'] ?? 0);
}

Модификаторы доступа

В отличие от других языков, в Dart нет модификаторов доступа: public, private и protected.

Есть только возможность ограничить видимость переменной, функции или класса с помощью нижнего подчеркивания _.

Оно буквально ограничивает видимость за пределами файла, в котором была объявлена переменная или функция. Но есть исключение — нотации part of/part. На них не будем долго задерживаться, но скажем, что они позволяют разбить один файл «на части» с общей видимостью, как будто это один файл.

Например, мы можем ограничить видимость полей и методов класса. Так никто не сможет получить доступ к ним за пределами файла-объявления:

class MyClass{
 final _privateField = "Hi, im private";

 void _privateFunction(){
  print(_privateField);
 }
}

Чтобы лучше понять фразу «видимость за пределами контекста», давайте рассмотрим пример:

void main() {
  final classObject = MyClass();
  classObject._privateField;
  classObject._privateFunction();

  SecondClass().printPrivateFunction();
}

class MyClass {
  final _privateField = "Hi, im private";

  void _privateFunction() {
    print(_privateField);
  }
}

class SecondClass {
  void printPrivateFunction() {
    MyClass()._privateFunction();
  }
}

Результат выполнения

Hi, im private
Hi, im private

MyClassвместе с main() и SecondClass объявлены внутри одного файла, поэтому приватные части MyClass видны другим членам файла или контекста.

Если же кто-то попытается из другого файла вызвать _privateFunction(), то у него ничего не выйдет.

null-safety

Dart поддерживает sound null-safety как необязательную функцию на версиях с 2.12 по 2.19 и как обязательную часть с версии 3. Это значит, что разработчик защищен от NullReferenceException, так называемой «ошибки на миллиард долларов».

Подробнее о реализации null-safety в Dart можно прочитать в документации. Мы же остановимся на основах.

С включенным null-safety в Dart все переменные не могут иметь значение null, если об этом не сказано явно с помощью оператора ?:

String nonNullVariable = "Hello, world!";
// При попытке присвоить null будет ошибка
nonNullVariable = null;

String? nullableVariable = "Hello, world!";
// Теперь ничего не мешает присвоить null
nullableVariable = null;

Сам компилятор постоянно следит за разработчиком и подсвечивает потенциально опасные места:

void main() {
  // Пусть у нас будет переменная, которая может содержать null
  MyClass? myClass;

  // Получаем ошибку на этапе компиляции
  final value = myClass.foo();
}

class MyClass {
  int foo() {
    return 5;
  }
}

Результат выполнения

main.dart:6:25: Error: Method 'foo' cannot be called on 'MyClass?' because it is potentially null.
 - 'MyClass' is from 'main.dart'.
Try calling using ?. instead.
  final value = myClass.foo();
                        ^^^

Код просто не скомпилируется, если компилятор увидит потенциально опасный вызов.

Выходов из ситуации несколько:

  1. Оператор ?.;
  2. Оператор !.;
  3. Вычисление типа компилятором.

Рассмотрим каждый их них подробнее.

Оператор ? или null-aware

В опасных местах можно пользоваться null-aware. Он буквально говорит компилятору: «Если переменная не null, то вызывай код, иначе — верни null».

final value = myClass?.foo();

Компилятор ругаться перестанет, и мы получим следующее:

Тип value — int?.

myClass не null — value == 5.

myClass не присвоено или null — value == null

Оператор ! или force unwrap

Этот оператор говорит компилятору: «Я уверен, что данное значение не может быть null».

final value = myClass!.foo();
// Чуть длиннее. Осторожно, force unwrap и приведение это не одно и то же!
final value = (myClass as MyClass).foo();

Компилятор ругаться перестанет, и мы получим следующее:

  • Тип value — int.
  • myClass присвоено не null — value == 5.
  • myClass не присвоено или null — код в рантайме выбросит NullReferenceException.

Важно: используйте force unwrap с осторожностью. Это оператор лишает нас кода null-safe, так что в итоге можно не заметить потенциальную NullReferenceException. Предпочтительнее использовать ?. и ??.

Вычисление типа компилятором

Мы можем положить nullable-значение в локальную переменную и специально проверить эту локальную переменную на null.

final myList = <MyClass?>[MyClass(), null];
final firstElement = myList.first; // first == myList[0]

int? value;
if(firstElement != null){
 value = firstElement.foo();
}

В итоге получим следующее:

Тип value — int? или тот, что вы указали при объявлении (например, dynamic);

Первый элемент не null — value == 5;

Первый элемент null — value == null.

Dart не видит, что первый элемент коллекции существует. Так происходит из-за full sound safety, компилятор может гарантировать вычисление только для локальных переменных.

За подробностями можно обратиться к документации или видео от разработчиков.

Бонуcные операторы

В качестве бонуса в языке Dart есть ещё несколько операторов:

?? — оператор null. Выполнит код справа-налево, только если значение левого операнда null.

getIntegerOrZero(null); // 0
getIntegerOrZero(5); // 5

int getIntegerOrZero(int? integer) {
 return integer?? 0;
}

...? — оператор null-spread. Распакует коллекцию, только если она не null.

final list = [1, 2, 3];
final List<String>? nullableList;
final myGreatList = [...list, ...?nullableList];

??= — оператор null-aware assignment. Присвоит значение переменной слева, только если она сейчас null.

  int value; // null
  value ??= 5; // 5
  value ??= 6; // value != null -> value все еще 5

С null-safety разобрались. Теперь поговорим о функциях.

Функции

Dart, следуя за тенденциями, предоставляет большой инструментарий по работе с функциями. Рассмотрим его поближе.

Параметры функции

Все виды параметров условно можно распределить на следующей диаграмме.

fluttern

А теперь по порядку.

positional-параметры

Их всегда нужно передать, даже если один из них nullable (то есть необязательный):

void foo(int value, String? value1) {}

void main() {
 foo(5, null);
}

optional positional — параметры, которые необязательно передавать при вызове. Но нельзя, чтобы у таких параметров non-nullable не было значения.

void foo(int value, [String value1]) {} // Это ошибка, у value1 гарантированно должно быть значение

// У optional параметров могут быть значения по-умолчанию. Важно: значение default — всегда константа
void foo(int value, [String value1 = '']) {}

// Либо можно сделать их nullable, тогда их значение по умолчанию — null
void foo(int value, [String? value1]) {}

void main() {
 foo(5);
}

named-параметры

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

void foo1(int value1, bool flag, int value2, int value3) {} // неудобно и сложно

void foo2({int value1, bool flag, int value2, int value3}) {} // удобно и читаемо

void main() {
 foo1(5, true, 2, 1);

 foo2(value1: 5, flag: true, value2: 2, value3: 3);
}

В коде выше foo2 объявлена с ошибкой, поскольку мы можем не передать один из параметров при вызове. При этом значение у параметра не может отсутствовать. На помощь приходит ключевое слово required — оно обязывает при вызове передать именованный параметр:

void foo2({required int value1, required bool flag, required int value2, required int value3}) {} // удобно и читаемо

void main() {
 foo2(value1: 5, flag: true, value2: 2); // ошибка, value3 не передали
}

Так же, как и с positional-параметрами, мы можем задать значения по умолчанию для именованного параметра, тогда можно отказаться от required и не передавать его при вызове:

void foo2({required int value1, required bool flag, required int value2, int value3 = 0}) {} // удобно и читаемо

void main() {
 foo2(value1: 5, flag: true, value2: 2); // ошибки нет, value3 == 0
}

Функции верхнего уровня и переменные

Это понятие носит много имён: глобальные функции, функции высшего порядка, «просто» функции. Для удобства мы будем называть их функциями верхнего уровня. Но суть у них одна — они и переменные могут существовать вне контекста какого-то класса.

Простейший пример такой функции — main(). Это не только точка входа в программу, но ещё и функция верхнего уровня.

// Функция верхнего уровня
void topLevelfunc() {}

// Переменная верхнего уровня
int topLevelVariable = 5;

Независимо от модификатора доступа и места объявления в файле такие функции видны всем членам «библиотеки», а сами они видят такие же функции верхнего порядка и переменные.

Стрелочные функции

Стрелочные функции позволяют описывать функции в одну строку:

int getInteger() => 5; // Код вернет 5

// 1. Стрелочная функция может и не возвращать какого-то конкретного значения
// 2. А void может быть опущен
// И то, и другое - плохой тон, хоть и так можно.
printInteger() => print(getInteger());

// Ниже эквивалентный код без стрелочных функций
int getInteger() {
 return 5;
}

printInteger() {
 print(getInteger());
}

Анонимные функции

Из функционального подхода в Dart перекочевали анонимные функции — их можно воспринимать как объект типа Function.

void main() {
  final expression =
      (String name, int years) => "Hello, my name is $name, i'm $years";

  print(expression('Daniil', 20));
}

Результат выполнения

Hello, my name is Daniil, i'm 20

У типа Function есть метод call, он и есть вызов самой функции. Его полезно использовать, если переменная-функция может быть null.

typedef PrinterFunc = String Function(String name, int years);

void main() {
 PrinterFunc? expression = (String name, int years) => "Hello, my name is $name, i'm $years";

  print(expression?.call('Daniil', 20));
}

Каскадный вызов методов

Функция, позволяет вызывать последовательно методы одной переменной:

final list = [1, 2, 3];
print(list..removeLast()..removeAt(0)); // 2

Результат каскадного вызова — исходное значение. Чтобы это лучше понять, рассмотрим следующий пример: toLowerCase() и toUpperCase() возвращают изменённое значение value, но при каскадном вызове программа не выведет результат этих функций.

final String value = 'Hello, world!';
print(value..toUpperCase()..toLowerCase()); // 'Hello, world!' - исходное значение value
print(value.toUpperCase().toLowerCase()); // 'hello, world!' - результат toLowerCase()

Замыкания

Этот механизм позволяет анонимной функции, объявленной внутри другой, получать доступ к вышестоящему «контексту».

Звучит страшно, так что рассмотрим пример замыкания:

int counter = 1;

typedef RobotBuilder = String Function(String name);

RobotBuilder robotFactory(String specifications) {
  final model = 'Death bot Pluto-$counter';
  counter++;
  return (String name) => '$model, $name, $specifications';
}

void main() {
  final firstRobot = robotFactory('Love cookies!');
  final secondRobot = robotFactory('Love Katya!');
  final thirdrobot = robotFactory('Love bloody pirogi!');

  print(firstRobot('HRAZ'));
  print(secondRobot.call('Sechenov'));
  print(thirdrobot('Nechyaev'));
}

Результат выполнения

Death bot Pluto-1, HRAZ, Love cookies!
Death bot Pluto-2, Sechenov, Love Katya!
Death bot Pluto-3, Nechyaev, Love bloody pirogi!

Функция верхнего уровня robotFactory возвращает анонимную функцию типа RobotBuild. Сама анонимная функция формирует строку из переданного name и доступных из контекста robotFactory переменных model и specifications.

Генераторы

В Dart есть синхронные и асинхронные генераторы. Здесь мы расскажем про синхронные, а асинхронные рассмотрим чуть позже, в одном из следующих статей.

Синхронные генераторы, например, пригодятся, когда вам нужно сгенерировать много тестовых данных:

// Функции помеченные sync* всегда возвращают Iterable
Iterable<int> generateList(int length) sync* {
  int counter = 0;
  while (counter < length) {
    // Функция "запомнит" это место и продолжит выполнение отсюда при последующем вызове
    yield counter++;
  }
}

void main() {
  final myList = <int>[];

  for (final value in generateList(10)) {
    myList.add(value);
  }

  print(myList);
}

Результат выполнения

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Отлично, основы Dart вспомнили. Предлагаем переходить к следующему статье — в нём мы поговорим о том, как в Dart реализовано ООП — Объектно ориентированное программирование.