Условные конструкции

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

В языке Dart используются следующие условные конструкции: if..else и switch..case, а также оператор ?:.

Конструкция if-else

Оператор if проверяет истинность условия, и если оно истинно, выполняет блок инструкций. Этот оператор имеет следующую сокращенную форму:

if (условие) инструкция;

В качестве условия может выступать любое выражение, которое возвращает значение типа bool, то есть true или false. Если это выражение возвращает true (то есть выражение истинно), то выполняется последующая инструкция:

void main() {
	const int num1 = 8;
	const int num2 = 5;
	if(num1 > num2){
    	print("num1 больше, чем num2");
	}
	print("конец функции main");
}

Здесь условие представляет выражение num1 > num2. И поскольку первое число num1 больше второго num2, то условие истинно и возвращает значение true. Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а конкретно инструкция

print("num1 больше, чем num2");

После завершения блока if выполняются все остальные инструкции, которые идут после конструкции if. То есть в данном случае вывод программы будет следующим:

num1 больше, чем num2
конец функции main

Рассмотрим противоположный случай - если условие ложно, то есть возвращает false:

void main() {
	const int num1 = 8;
	const int num2 = 15;
	if(num1 > num2){
    	print("num1 больше, чем num2");
	}
	print("конец функции main");
}

Здесь условие ложно, поскольку первое число num1 меньше числа num2. Поэтому инструкции из блока if не выполняются, и соответственно вывод программы будет следующим:

конец функции main

Выражение else

Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы. Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок else:

void main() {
	const int num1 = 8;
	const int num2 = 15;
	if(num1 > num2){
		print("Первое число больше второго");
	}
	else{
		print("Первое число меньше второго");
	}
}

Поскольку здесь условие после оператора if равно false, то будет выполняться блок инструкций после оператора else.

else-if

Но при сравнении чисел мы можем насчитать три состояния: первое число больше второго, первое число меньше второго и числа равны. С помощью выражения else if, мы можем обрабатывать дополнительные условия:

void main() {
    const int num1 = 8;
    const int num2 = 5;
    if(num1 > num2){
        print("Первое число больше второго");
    }
    else if(num1 < num2){
        print("Первое число меньше второго");
    }
    else{
        print("Числа равны");
    }
}

В одной конструкции if можно использововать множество блоков else if с альтернативными условиями:

void main() {
	const int num1 = 8;
	if(num1 == 6){
		print("num1 = 6");
	}
	else if(num1 == 7){
		print("num1 = 6");
	}
	else if(num1 == 8){
		print("num1 = 8");
	}
	else{
		print("Undefined");
	}
}

Конструкция switch

Конструкция switch/case позволяет обработать сразу несколько условий:

void main() {
	const int num = 8;
    switch(num){
                
        case 1: 
            print("число равно 1");
        case 2: 
            print("число равно 2");
        case 3: 
            print("число равно 3");
        default:
            print("число не равно 1, 2, 3");
    }
}

После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора сase. И если совпадение будет найдено, то будет выполняться определенный блок сase.

Стоит отметить, что до версии Dart 3 блок case в общем случае должен был завершаться оператором break, как в следующем случае:

void main() {
	const int num = 8;
    switch(num){
                
        case 1: 
            print("число равно 1");
			break;		// выходим из конструкции switch
        case 2: 
            print("число равно 2");
			break;		// выходим из конструкции switch
        case 3: 
            print("число равно 3");
			break;		// выходим из конструкции switch
        default:
            print("число не равно 1, 2, 3");
    }
}

Начиная с версии Dart 3 оператор break не обязателен.

Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default, как в примере выше. Хотя блок default необязателен.

Также мы можем определить одно действие сразу для нескольких блоков case подряд:

const int num = 3;
int output = 0;
switch(num){
	
	case 1: 
		output = 3;
	case 2: 
	case 3: 
	case 4: 
		output = 6;
	case 5: 
		output = 12;
	default:
		output = 24;
}
print(output);

Внутри блока case можно использовать оператор continue, передав метку для перехода:

int num = 2;
switch(num){
             
    case 1: 
        print("число равно 1");
    case 2: 
        print("число равно 2");
        num++;
        continue N3;	// переход на метку N3
    N3: case 3: 
        print("число равно 3");
    default:
        print("число не равно 1, 2, 3");
}

Здесь оператор continue осуществляет переход на метку N3, которая по сути представляет следующий блок case. Название метки произвольное. В данном случае действие оператора continue похоже на действие оператора goto в некоторых языках программирования. Только в данном случае метка должна вести внутри конструкции switch на один из блоков case или блок default. Поэтому результатом работы вышеприведенной программы будет следующий консольный вывод:

число равно 2
число равно 3

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

Тернарный оператор в некотором роде похож на конструкцию if-else. Он принимает три операнда в следующем виде:

[первый операнд - условие] ? [второй операнд] : [третий операнд]

Первый операнд представляет условие. Если это условие верно (равно true), тогда выбирается/выполняется второй операнд, который помещается после символа ?. Если условие не верно, тогда выбирается/выполняется третий операнд, который помещается после двоеточия.:

void main() {
	const int a = 5;
    const int b = 8 ;
    int c = a > b ? a - b : a + b;	// тернарный оператор
	print(c);	// 13
}

Здесь первым операндом тернарного оператора является условие a > b. Если это условие верно, то возвращается второй операнд - результат выражения a - b. Если условие не верно, то возвращается третий операнд - a + b. И возвращенный операнд присваивается переменной c.

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

void main() {
	const int a = 5;
    const int b = 8 ;
    a > b ? print(a - b) : print(a + b);	// тернарный оператор
}

Здесь тот же первый операнд-условие. Если оно верно, выполняется второй операнд - print(a - b), если нет, то третий операнд - print(a + b).