├── 9 ООП ├── 9.1_main.dart ├── 9.3_main.dart ├── 9.6_main.dart ├── 9.7_main.dart ├── 9.5_main.dart ├── 9.4_main.dart ├── 9.2_main.dart └── 9.8_main.dart ├── 8. Исключения ├── 8.1_main.dart ├── 8.2_main.dart ├── 8.4_main.dart ├── 8.5_main.dart └── 8.3_main.dart ├── 6. Dart операторы ├── 6.1_main.dart ├── 6.2_main.dart ├── 6.3_main.dart ├── 6.4_main.dart ├── 6.6_main.dart ├── 6.7_main.dart ├── 6.8_main.dart ├── 6.9_main.dart └── 6.5_main.dart ├── 7. Условные конструкции ├── 7.5_main.dart ├── 7.6_main.dart ├── 7.4_main.dart ├── 7.3_main.dart └── 7.1_main.dart ├── 10. Асинхронность в Dart ├── 10.1_main.dart ├── 10.4_main.dart ├── 10.5_main.dart ├── 10.6_main.dart ├── 10.2_main.dart └── 10.3_main.dart ├── 11. SOLID принципы в Dart ├── 11.1_main.dart ├── 11.2_main.dart ├── 11.3_main.dart ├── 11.4_main.dart ├── 11.5_main.dart └── 11.6_main.dart ├── 5. Функциональное программирование ├── 5.1_main.dart ├── 5.3_main.dart ├── 5.2_main.dart ├── 5.4_main.dart ├── 5.7_main.dart ├── 5.5_main.dart ├── 5.8_main.dart └── 5.6_main.dart ├── 3. Базовые типы данных в Dart ├── 3.1_main.dart ├── 3.4_main.dart ├── 3.3.2_main.dart ├── 3.7_main.dart ├── 3.3.1_main.dart ├── 3.6_main.dart ├── 3.2_main.dart ├── 3.5.4_main.dart ├── 3.5.3_main.dart └── 3.5.2_main.dart ├── data-structures ├── linked-list │ ├── linked-list-node.dart │ └── linked-list.dart ├── doubly-linked-list │ ├── doubly-linked-list-node.dart │ └── doubly-linked-list.dart ├── stack │ └── stack.dart ├── heap │ ├── min-heap.dart │ ├── max-heap.dart │ └── heap.dart ├── queue │ └── queue.dart ├── graph │ ├── edge-list.dart │ ├── vertex.dart │ ├── graph.dart │ ├── edge.dart │ ├── adjacency-list-graph.dart │ └── adjacency-matrix-graph.dart ├── tree │ └── tree-node.dart ├── hash-table │ └── hash-table.dart └── binary-tree │ └── binary-tree.dart ├── utils └── swap.dart ├── 1. Введение в Dart ├── 1.1_main.dart ├── 1.2_main.dart └── 1.3_main.dart ├── 2. Переменные и константы ├── 2.4_main.dart ├── 2.2_main.dart ├── 2.3_main.dart └── 2.1_main.dart ├── 4 Generics └── 4.1_main.dart ├── sort ├── bubble-sort.dart ├── insertion-sort.dart ├── selection-sort.dart └── quick-sort.dart ├── LICENSE └── README.md /9 ООП/9.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /9 ООП/9.3_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /9 ООП/9.6_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /9 ООП/9.7_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /8. Исключения/8.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /8. Исключения/8.2_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /8. Исключения/8.4_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /8. Исключения/8.5_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.2_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.3_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.4_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.6_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.7_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.8_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.9_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /6. Dart операторы/6.5_main.dart: -------------------------------------------------------------------------------- 1 | 6.6 -------------------------------------------------------------------------------- /7. Условные конструкции/7.5_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /7. Условные конструкции/7.6_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.4_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.5_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.6_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.2_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.3_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.4_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.5_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /11. SOLID принципы в Dart/11.6_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.1_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.3_main.dart: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.1_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | print("Hello world!"); 3 | } -------------------------------------------------------------------------------- /5. Функциональное программирование/5.2_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | hello(); 3 | hello(); 4 | hello(); 5 | } 6 | 7 | void hello() => print("Hello World!"); -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.4_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | int ageNullable = null; 3 | if (ageNullable == null) { 4 | print("ageNullable variable is true"); 5 | } 6 | } -------------------------------------------------------------------------------- /data-structures/linked-list/linked-list-node.dart: -------------------------------------------------------------------------------- 1 | 2 | class LinkedListNode { 3 | T value; 4 | LinkedListNode next; 5 | 6 | LinkedListNode(this.value, [LinkedListNode next]); 7 | } 8 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.4_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | var list = ['apples', 'bananas', 'oranges']; 3 | list.forEach((item) { 4 | print('${list.indexOf(item)}: $item'); 5 | }); 6 | } -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.3.2_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | var firstName = 'Anna '; 3 | var lastName = 'Muzykina'; 4 | 5 | print('$firstName $lastName'); 6 | print('Anna' + ' ' + 'Muzykina'); 7 | } -------------------------------------------------------------------------------- /utils/swap.dart: -------------------------------------------------------------------------------- 1 | 2 | extension Swap on List { 3 | void swap(int fromIndex, int toIndex) { 4 | var temp = this[fromIndex]; 5 | this[fromIndex] = this[toIndex]; 6 | this[toIndex] = temp; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /data-structures/doubly-linked-list/doubly-linked-list-node.dart: -------------------------------------------------------------------------------- 1 | 2 | class DoublyLinkedListNode { 3 | T value; 4 | DoublyLinkedListNode previous; 5 | DoublyLinkedListNode next; 6 | 7 | DoublyLinkedListNode(this.value, {this.previous, this.next}); 8 | } 9 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.2_main.dart: -------------------------------------------------------------------------------- 1 | import 'dart:io'; 2 | 3 | import 'dart:async'; 4 | 5 | 6 | 7 | void printDailyNewsDigest() { 8 | 9 | File file = new File("dailyNewsDigest.txt"); 10 | 11 | Future future = file.readAsString(); 12 | 13 | future.then((content) { 14 | 15 | print(content); 16 | 17 | }); 18 | } -------------------------------------------------------------------------------- /9 ООП/9.5_main.dart: -------------------------------------------------------------------------------- 1 | abstract class User { 2 | //Устанавливаем переменные и методы экземпляра 3 | 4 | void doSomething(); // Устанавливаем абстрактный метод 5 | } 6 | 7 | class EffectiveUser extends User { 8 | void doSomething(){ 9 | // Предоставляем реализацию, поэтому метод здесь не является абстрактным 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.7_main.dart: -------------------------------------------------------------------------------- 1 | void main(){ 2 | // создать идентификатор или символ для “anySymbolValue” в памяти 3 | Symbol test1 = new Symbol("anySymbolValue"); 4 | print(test1); 5 | print(#test1); 6 | 7 | //добавьте «#», чтобы создать символьный литерал для любого объекта (здесь,случайное значение test2 8 | print(#test2); 9 | } -------------------------------------------------------------------------------- /data-structures/stack/stack.dart: -------------------------------------------------------------------------------- 1 | 2 | extension Stack on List { 3 | T peek() { 4 | return length > 0 ? last : null; 5 | } 6 | 7 | T pop() { 8 | if (length > 0) { 9 | return removeLast(); 10 | } 11 | throw IndexError; 12 | } 13 | 14 | void push(T element) { 15 | add(element); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /1. Введение в Dart/1.1_main.dart: -------------------------------------------------------------------------------- 1 | // Определяем функцию 2 | void printInteger(int aNumber) { 3 | print('The number is $aNumber.'); // Выводим в консоль 4 | } 5 | 6 | // Здесь начинается выполнение приложения  7 | void main() { 8 | var number = 42; // Объявление и инициализация переменной. 9 | printInteger(number); // ​​​​​​​Вызов функции 10 | } -------------------------------------------------------------------------------- /data-structures/heap/min-heap.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/heap/heap.dart'; 3 | 4 | class MinHeap extends Heap { 5 | MinHeap(List heapContainer) : super(heapContainer); 6 | 7 | @override 8 | bool pairIsInCorrectOrder(num itemOne, num itemTwo) { 9 | return itemOne < itemTwo; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /data-structures/heap/max-heap.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/heap/heap.dart'; 3 | 4 | class MaxHeap extends Heap { 5 | MaxHeap(List heapContainer) : super(heapContainer); 6 | 7 | 8 | @override 9 | bool pairIsInCorrectOrder(num itemOne, num itemTwo) { 10 | return itemOne > itemTwo; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /data-structures/queue/queue.dart: -------------------------------------------------------------------------------- 1 | 2 | extension Queue on List { 3 | void enqueue(T element) { 4 | add(element); 5 | } 6 | 7 | T dequeue() { 8 | if (length > 0) { 9 | return removeAt(0); 10 | } 11 | throw IndexError; 12 | } 13 | 14 | T peek() { 15 | return isEmpty ? null : elementAt(0); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /7. Условные конструкции/7.4_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | 3 | //______________Example 1________________ 4 | for (int i = 0; i < 10; i++) { 5 | if (i == 5) break; 6 | print(i); 7 | } 8 | 9 | //______________Example 2________________ 10 | 11 | for (int i = 0; i < 10; i++) { 12 | if (i == 5) continue; 13 | print(i); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /data-structures/graph/edge-list.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/graph/vertex.dart'; 3 | import 'package:dart_algorithm_club/data-structures/graph/edge.dart'; 4 | 5 | class EdgeList { 6 | Vertex vertex; 7 | var edges; 8 | 9 | EdgeList(vertex) { 10 | this.vertex = vertex; 11 | edges = >[]; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /2. Переменные и константы/2.4_main.dart: -------------------------------------------------------------------------------- 1 | enum Status { 2 | none, 3 | running, 4 | stopped, 5 | paused 6 | } 7 | 8 | void main() { 9 | print(Status.values); 10 | Status.values.forEach((v) => print('value: v, index:v,index:{v.index}')); 11 | print('running: {Status.running},Status.running,{Status.running.index}'); 12 | print('running index: ${Status.values[1]}'); 13 | } -------------------------------------------------------------------------------- /data-structures/graph/vertex.dart: -------------------------------------------------------------------------------- 1 | 2 | class Vertex { 3 | T data; 4 | int index; 5 | 6 | Vertex(this.data, this.index); 7 | 8 | @override 9 | bool operator ==(o) => o is Vertex && o.data == data && o.index == index; 10 | 11 | @override 12 | int get hashCode => data.hashCode * index.hashCode; 13 | 14 | @override 15 | String toString() => '${index}: ${data}'; 16 | } 17 | -------------------------------------------------------------------------------- /4 Generics/4.1_main.dart: -------------------------------------------------------------------------------- 1 | // ------- 4.1 Что такое дженерики? -----Generics - параметризованные типы ---------- 2 | 3 | // Синтаксис: Collection_name identifier= new Collection_name 4 | 5 | //------Example 1---------- 6 | void main (){ 7 | 8 | var names = []; 9 | 10 | names.addAll(['Ryzen', 'Core', 'Pentium', 'Duron']); 11 | 12 | names.add(42); // Ошибка 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /8. Исключения/8.3_main.dart: -------------------------------------------------------------------------------- 1 | void misbehave() { 2 | try { 3 | dynamic foo = true; 4 | print(foo++); // Runtime error 5 | } catch (e) { 6 | print('misbehave() partially handled ${e.runtimeType}.'); 7 | rethrow; // Позволяет вызовам видеть исключение. 8 | } 9 | } 10 | 11 | void main() { 12 | try { 13 | misbehave(); 14 | } catch (e) { 15 | print('main() finished handling ${e.runtimeType}.'); 16 | } 17 | } -------------------------------------------------------------------------------- /5. Функциональное программирование/5.7_main.dart: -------------------------------------------------------------------------------- 1 | /// Возвращает функцию, которая добавляет [addBy] к аргументу функции. 2 | Function makeAdder(int addBy) { 3 | return (int i) => addBy + i; 4 | } 5 | 6 | void main() { 7 | // Создайте функцию, которая добавляет 2. 8 | var add1 = makeAdder(2); 9 | 10 | // Создайте функцию, которая добавляет 4. 11 | var add2 = makeAdder(4); 12 | 13 | assert(add1(3) == 5); 14 | assert(add2(3) == 7); 15 | } -------------------------------------------------------------------------------- /7. Условные конструкции/7.3_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | 3 | //__________________Example 1______________________ 4 | var num = 5; 5 | var factorial = 1; 6 | 7 | while (num >= 1) { 8 | factorial = factorial * num; 9 | num--; 10 | } 11 | print("Факториал числа: ${factorial}"); 12 | 13 | //__________________Example 2______________________ 14 | var num = 10; 15 | do { 16 | print(num); 17 | num --; 18 | } while (num >= 0); 19 | } -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.3.1_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | var str1 = 'Строка в одинарных кавычках'; 3 | String str2 = "Строка в двойных кавычках"; 4 | var mulrStr1 = ''' 5 | Многострочная 6 | строка в 7 | одинарных 8 | кавычках 9 | '''; 10 | var multStr2 = """ 11 | Многострочная 12 | строка в 13 | двойных 14 | кавычках 15 | """; 16 | print(str1); 17 | print(str2); 18 | print(mulrStr1); 19 | print(multStr2); 20 | } 21 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.5_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | 3 | //_____________Example 1_____________ 4 | void hello() { 5 | print("Hello!"); 6 | } 7 | hello(); 8 | hello(); 9 | 10 | //____________Example 2_______________ 11 | void showMessage() { 12 | void hello() { 13 | print("Hello World!"); 14 | } 15 | 16 | hello(); 17 | hello(); 18 | } 19 | 20 | showMessage(); 21 | //____________Example 3_______________ 22 | void welcome() { 23 | var message = "Welcome!"; 24 | print(message); 25 | } 26 | 27 | print(message); 28 | 29 | } 30 | -------------------------------------------------------------------------------- /data-structures/graph/graph.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/graph/edge.dart'; 3 | import 'package:dart_algorithm_club/data-structures/graph/vertex.dart'; 4 | 5 | abstract class Graph { 6 | Vertex createVertex(T data); 7 | void addDirectedEdge(Vertex from, Vertex to, [num weight]); 8 | void addUnDirectedEdge(Vertex from, Vertex to, [num weight]); 9 | num weightFrom(Vertex sourceVertex, Vertex destinationVertex); 10 | List> edgesFrom(Vertex sourceVertex); 11 | 12 | List> get edges; 13 | List> get vertices; 14 | 15 | } 16 | -------------------------------------------------------------------------------- /9 ООП/9.4_main.dart: -------------------------------------------------------------------------------- 1 | class Rectangle { 2 | double left, top, width, height; 3 | 4 | Rectangle(this.left, this.top, this.width, this.height); 5 | 6 | // Определяем два вычисляемых свойства: правое и нижнее 7 | double get right => left + width; 8 | set right(double value) => left = value - width; 9 | double get bottom => top + height; 10 | set bottom(double value) => top = value - height; 11 | } 12 | 13 | void main() { 14 | var rect = Rectangle(3, 4, 20, 15); 15 | assert(rect.left == 3); 16 | print(rect.left); 17 | 18 | rect.right = 12; 19 | assert(rect.left == -8); 20 | print(rect.right); 21 | } -------------------------------------------------------------------------------- /data-structures/tree/tree-node.dart: -------------------------------------------------------------------------------- 1 | class TreeNode { 2 | T value; 3 | TreeNode parent; 4 | var children; 5 | 6 | TreeNode(this.value) { 7 | children = List>(); 8 | } 9 | 10 | void addChild(node) { 11 | children.add(node); 12 | node.parent = this; 13 | } 14 | 15 | TreeNode search(T value) { 16 | if (value == this.value) { 17 | return this; 18 | } 19 | 20 | TreeNode node; 21 | for (var child in children) { 22 | node = child.search(value); 23 | if (node != null) { 24 | break; 25 | } 26 | } 27 | 28 | return node; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.6_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | 3 | //___________Example 1_______________________ 4 | Runes textStr = new Runes('Hello, World!'); 5 | 6 | print( 7 | textStr); // (72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33) 8 | 9 | //____________Example 2_____________________ 10 | Runes input = new Runes( 11 | '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}'); 12 | print(new String.fromCharCodes(input)); 13 | 14 | //____________Example 3______________________ 15 | 16 | Runes input = new Runes('\u{1f60e}'); 17 | 18 | print(new String.fromCharCodes(input)); 19 | } -------------------------------------------------------------------------------- /data-structures/graph/edge.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/graph/vertex.dart'; 3 | 4 | class Edge { 5 | Vertex from; 6 | Vertex to; 7 | 8 | num weight; 9 | 10 | Edge(this.from, this.to, [this.weight]); 11 | 12 | @override 13 | String toString() { 14 | String weightString = weight ?? ''; 15 | return '${from.toString()} -(${weightString})-> ${to.toString()}'; 16 | } 17 | 18 | @override 19 | int get hashCode => from.hashCode * to.hashCode * weight.hashCode; 20 | 21 | @override 22 | bool operator ==(other) => other is Edge && other.from == from && other.to == to && other.weight == weight; 23 | } 24 | -------------------------------------------------------------------------------- /7. Условные конструкции/7.1_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | 3 | //____________Example 1____________________ 4 | var message = StringBuffer('Dart is fun'); 5 | 6 | for (var i = 0; i < 5; i++) { 7 | message.write('!'); 8 | print(message); 9 | } 10 | 11 | //____________Example 2____________________ 12 | var callbacks = []; 13 | 14 | for (var i = 0; i < 2; i++) { 15 | callbacks.add(() => print(i)); 16 | } 17 | 18 | callbacks.forEach((c) => c()); 19 | 20 | print(callbacks); 21 | 22 | //____________Example 3______________________ 23 | var collection = [0, 1, 2]; 24 | 25 | for (var x in collection) { 26 | print(x); // 0 1 2 27 | 28 | } 29 | } -------------------------------------------------------------------------------- /2. Переменные и константы/2.2_main.dart: -------------------------------------------------------------------------------- 1 | 2 | void main() { 3 | 4 | //_____________Example 1_________________________ 5 | var x = 88; //Тип переменной int 6 | 7 | var str = 'hello'; //Тип переменной string 8 | 9 | var list = [1, 2, 3]; // Тип переменной List 10 | 11 | 12 | //_________________Example 2_____________________ 13 | 14 | 15 | 16 | var x = 4; 17 | 18 | print(x);// x = 4 19 | 20 | x = 'Four';// Ошибка! x представляет целые числа, а не строки 21 | 22 | print(x); 23 | 24 | 25 | //_________________Example 3_____________________ 26 | 27 | 28 | dynamic x = 4; 29 | 30 | print(x); // x = 4 31 | 32 | x = 'Four'; // Тип динамически поменяется на String 33 | 34 | print(x); // 'Four' 35 | } -------------------------------------------------------------------------------- /2. Переменные и константы/2.3_main.dart: -------------------------------------------------------------------------------- 1 | //___________Example 1___________________________ 2 | 3 | const x = 1; 4 | const int y = 2; 5 | final int z = 3; 6 | final q = 4; 7 | 8 | //___________Example 2___________________________ 9 | 10 | final name = 'Anna'; // Без указания типа данных 11 | final String nickname = 'Netti'; // С указанием типа данных 12 | 13 | //____________Example 3__________________________ 14 | final name = 'Anna'; // Без указания типа данных 15 | final String nickname = 'Netti'; // С указанием типа данных 16 | name = 'Annet'; // Ошибка при попытке изменить значение нашей переменной name 17 | 18 | //____________Example 4__________________________ 19 | 20 | const bar = 1000000; // Единица давления (дин / см2) 21 | const double atm = 1.01325 * bar; // Стандартная атмосфера -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.2_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | //___________Example 1___________________________ 3 | // String -> int 4 | var one = int.parse('1'); //1 5 | assert(one == 1); 6 | 7 | // String -> double 8 | var onePointOne = double.parse('1.1'); //1.1 9 | assert(onePointOne == 1.1); 10 | 11 | // int -> String 12 | String oneAsString = 1.toString(); //'1' 13 | assert(oneAsString == '1'); 14 | 15 | // double -> String 16 | String piAsString = 3.14159.toStringAsFixed(2); //3.14 17 | assert(piAsString == '3.14'); 18 | 19 | //___________Example 2___________________________ 20 | // объявили целое число 21 | int num1 = 10; 22 | 23 | // объявили дробное число 24 | double num2 = 10.50; 25 | 26 | // вывели значения 27 | print(num1); 28 | print(num2); 29 | } 30 | -------------------------------------------------------------------------------- /sort/bubble-sort.dart: -------------------------------------------------------------------------------- 1 | import 'package:dart_algorithm_club/utils/swap.dart'; 2 | 3 | List sortInAscendingOrder(List elements) { 4 | return bubbleSort(elements, (a, b) => a.compareTo(b) > 0); 5 | } 6 | 7 | List sortInDescendingOrder(List elements) { 8 | return bubbleSort(elements, (a, b) => a.compareTo(b) < 0); 9 | } 10 | 11 | List bubbleSort(List elements, bool Function(T a, T b) comparator) { 12 | var sortedList = List.from(elements); 13 | for (var i = 0; i < sortedList.length; i++) { 14 | for (var j = i; j < sortedList.length; j++) { 15 | if (comparator(sortedList[i], sortedList[j])) { 16 | sortedList.swap(i, j); 17 | } 18 | } 19 | } 20 | return sortedList; 21 | } 22 | -------------------------------------------------------------------------------- /sort/insertion-sort.dart: -------------------------------------------------------------------------------- 1 | import 'package:dart_algorithm_club/utils/swap.dart'; 2 | 3 | List sortInAscendingOrder(List elements) { 4 | return insertionSort(elements, (a, b) => a.compareTo(b) > 0); 5 | } 6 | 7 | List sortInDescendingOrder(List elements) { 8 | return insertionSort(elements, (a, b) => a.compareTo(b) < 0); 9 | } 10 | 11 | List insertionSort(List elements, bool Function(T a, T b) comparator) { 12 | var sortedList = List.from(elements); 13 | for (var i = 1; i < sortedList.length; i++) { 14 | for (var j = i; j > 0; j--) { 15 | if (!comparator(sortedList[j], sortedList[j-1])) { 16 | sortedList.swap(j, j-1); 17 | } 18 | } 19 | } 20 | return sortedList; 21 | } 22 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.8_main.dart: -------------------------------------------------------------------------------- 1 | void foo() {} // Функция верхнего уровня 2 | 3 | class A { 4 | static void bar() {} // Статический метод 5 | void baz() {} // Метод экземпляра 6 | } 7 | 8 | void main() { 9 | var x; 10 | 11 | // Сравнение функций верхнего уровня. 12 | x = foo; 13 | assert(foo == x); 14 | 15 | // Сравнение статических методов. 16 | x = A.bar; 17 | assert(A.bar == x); 18 | 19 | // Сравнение методов экземпляра. 20 | var v = A(); // Instance #1 of A 21 | var w = A(); // Instance #2 of A 22 | var y = w; 23 | x = w.baz; 24 | 25 | // Эти замыкания относятся к одному и тому же экземпляру (#2), поэтому они равны. 26 | assert(y.baz == x); 27 | 28 | // Эти замыкания относятся к разным экземплярам, ​​поэтому они не равны. 29 | assert(v.baz != w.baz); 30 | } -------------------------------------------------------------------------------- /2. Переменные и константы/2.1_main.dart: -------------------------------------------------------------------------------- 1 | // Example 1 2 | void main() { 3 | var name = 4 | 'Den'; //Создали переменную типа String без явного указания типа переменной 5 | 6 | var age = 38; //Тип переменной int хотя мы его явно не указывали 7 | 8 | print('Name: $name, age: $age'); // Выведем переменные name и age 9 | } 10 | 11 | // Example 2 12 | void main() { 13 | String name = 14 | 'Den'; //Создали переменную типа String c указанием на тип переменной 15 | 16 | int age = 38; //Тип переменной int явно указали при создании переменной age 17 | 18 | print('Name: $name, age: $age'); // Выведем переменные name и age 19 | } 20 | 21 | // Example 3 22 | 23 | void main() { 24 | dynamic name; 25 | name = 'Den'; 26 | int age = 38; 27 | print('Name: $name, age: $age'); // Выведем переменные name и age 28 | } 29 | -------------------------------------------------------------------------------- /sort/selection-sort.dart: -------------------------------------------------------------------------------- 1 | import 'package:dart_algorithm_club/utils/swap.dart'; 2 | 3 | List sortInAscendingOrder(List elements) { 4 | return selectionSort(elements, (a, b) => a.compareTo(b) > 0); 5 | } 6 | 7 | List sortInDescendingOrder(List elements) { 8 | return selectionSort(elements, (a, b) => a.compareTo(b) < 0); 9 | } 10 | 11 | List selectionSort(List elements, bool Function(T a, T b) comparator) { 12 | var sortedList = List.from(elements); 13 | for (var i = 0; i < sortedList.length; i++) { 14 | var currentIndex = i; 15 | for (var j = i + 1; j < sortedList.length; j++) { 16 | if (comparator(sortedList[currentIndex], sortedList[j])) { 17 | currentIndex = j; 18 | } 19 | } 20 | sortedList.swap(i, currentIndex); 21 | } 22 | return sortedList; 23 | } 24 | -------------------------------------------------------------------------------- /1. Введение в Dart/1.2_main.dart: -------------------------------------------------------------------------------- 1 | import 'dart:math'; 2 | 3 | void main() { 4 | } 5 | // UpperCamelCase для именования Классов и определения типов 6 | class SliderMenu { 7 | // ... 8 | } 9 | 10 | class HttpRequest { 11 | // ... 12 | } 13 | 14 | typedef num Adder(num x, num y); 15 | 16 | 17 | // UpperCamelCase для именования расширений 18 | extension MyFancyList on List { 19 | // ... 20 | } 21 | 22 | extension SmartIterable on Iterable { 23 | // ... 24 | } 25 | 26 | // lowerCamelCase для членов класса, определения верхнего уровня, переменных, параметров и именованных параметров 27 | 28 | var count = 3; 29 | 30 | HttpRequest httpRequest; 31 | 32 | void align(bool clearItems) { 33 | // ... 34 | } 35 | 36 | // lowerCamelCase для имен констант 37 | 38 | const pi = 3.14; 39 | const defaultTimeout = 1000; 40 | final urlScheme = RegExp('^([a-z]+):'); 41 | 42 | class Dice { 43 | static final numberGenerator = Random(); 44 | } 45 | -------------------------------------------------------------------------------- /1. Введение в Dart/1.3_main.dart: -------------------------------------------------------------------------------- 1 | //__________Example 1________________ 2 | 3 | // определение функции main 4 | void main (){ // начало объявления функции 5 | 6 | 7 | print("Hello Dart!"); // вывод строки на консоль 8 | 9 | } // конец объявления функции 10 | 11 | //_____________Example 2________________ 12 | 13 | /* 14 | 15 | многострочный комментарий 16 | 17 | Первая программа 18 | 19 | на языке Dart 20 | 21 | */ 22 | 23 | //_________________Example 3_______________________ 24 | 25 | /// ( Lama Glama ) является одомашненным южноамериканским верблюдом 26 | /// 27 | /// широко используются в качестве мяса и вьючных животных 28 | /// по андским культурам со временами доколумбовой эпохи . 29 | class Llama { 30 | String name; 31 | 32 | /// Покормить вашу ламу [Food]. 33 | /// 34 | /// Типичная лама съедает один тюк сена в неделю.​​​​​​​ 35 | void feed(Food food) { 36 | // ... 37 | } 38 | 39 | /// Потренируйте свою ламу с [activity] 40 | /// в течении [timeLimit] минут. 41 | void exercise(Activity activity, int timeLimit) { 42 | // ... 43 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Anna Muzykina 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.5.4_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | //__________Example 1_________________ 3 | var map = {5: "Tom"}; 4 | map[1] = "Alice"; 5 | map[44] = "Bob"; 6 | map[6] = "Sam"; 7 | // перебор всех элементов 8 | print("Все элементы:"); 9 | for (var item in map.entries) { 10 | // item представляет MapEntry 11 | print("${item.key} - ${item.value}"); 12 | } 13 | // перебор ключей 14 | print("Ключи элементов:"); 15 | for (var key in map.keys) { 16 | print(key); 17 | } 18 | // перебор значений 19 | print("Values элементов:"); 20 | for (var value in map.values) { 21 | print(value); 22 | } 23 | 24 | //____________Example 2______________ 25 | 26 | var map1 = {"Russia": "Moscow"}; 27 | map1.addAll({"France": "Paris", "Spain": "Madrid"}); // добавляем Map 28 | 29 | print(map1.containsKey("Poland")); // false 30 | print(map1.containsKey("France")); // true 31 | 32 | print(map1.containsValue("Madrid")); // true 33 | 34 | // удаляем элемент с ключом "Spain" 35 | map1.remove("Spain"); 36 | print(map1.containsKey("Spain")); // false 37 | print(map1.containsValue("Madrid")); // false 38 | 39 | } 40 | -------------------------------------------------------------------------------- /5. Функциональное программирование/5.6_main.dart: -------------------------------------------------------------------------------- 1 | //_______________Example 1______________________ 2 | 3 | // Объявление переменной с глобальной областью видимости 4 | 5 | bool topLevel = true; 6 | 7 | void main() { 8 | // Эта переменная находится внутри main и доступна в main 9 | var insideMain = true; 10 | 11 | void myFunction() { 12 | // Эта переменная находится внутри myFunction и доступна в myFunction 13 | 14 | var insideFunction = true; 15 | 16 | void nestedFunction() { 17 | // Эта переменная находится внутри nestedFunction и доступна в nestedFunction 18 | 19 | var insideNestedFunction = true; 20 | 21 | assert(topLevel); 22 | assert(insideMain); 23 | assert(insideFunction); 24 | assert(insideNestedFunction); 25 | } 26 | } 27 | } 28 | 29 | //________________Example 2_______________________________ 30 | Function makeAdder(num n) { 31 | // Lexically scoped or top level static function 32 | return (num i) => n + i; // вернет функцию 33 | } 34 | 35 | void main() { 36 | var addBy = makeAdder(2); // addByTwo closes over adder function 37 | print(addBy(3)); // выведет "5" 38 | print(addBy(4)); // выведет "6" 39 | } -------------------------------------------------------------------------------- /sort/quick-sort.dart: -------------------------------------------------------------------------------- 1 | import 'package:dart_algorithm_club/utils/swap.dart'; 2 | 3 | List sortInAscendingOrder(List elements) { 4 | return quickSort(elements, (a, b) => a.compareTo(b) < 0); 5 | } 6 | 7 | List sortInDescendingOrder(List elements) { 8 | return quickSort(elements, (a, b) => a.compareTo(b) > 0); 9 | } 10 | 11 | List quickSort(List elements, bool Function(T a, T b) comparator) { 12 | var sortedList = List.from(elements); 13 | _quickSort(sortedList, 0, sortedList.length - 1, comparator); 14 | return sortedList; 15 | } 16 | 17 | int _partition(List elements, int start, int end, bool Function(T a, T b) comparator) { 18 | var pivot = elements[end]; 19 | var partitionIndex = start; 20 | 21 | for (var i = start; i < end; i++) { 22 | if (comparator(elements[i], pivot)) { 23 | elements.swap(i, partitionIndex); 24 | partitionIndex += 1; 25 | } 26 | } 27 | elements.swap(partitionIndex, end); 28 | return partitionIndex; 29 | } 30 | 31 | void _quickSort(List elements, int start, int end, bool Function(T a, T b) comparator) { 32 | if (start < end) { 33 | var partitionIndex = _partition(elements, start, end, comparator); 34 | _quickSort(elements, start, partitionIndex - 1, comparator); 35 | _quickSort(elements, partitionIndex + 1, end, comparator); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /data-structures/hash-table/hash-table.dart: -------------------------------------------------------------------------------- 1 | 2 | class Element { 3 | K key; 4 | V value; 5 | 6 | Element(this.key, this.value); 7 | } 8 | 9 | class HashTable { 10 | List> buckets; 11 | num get count => buckets.length; 12 | 13 | HashTable({num capacity = 0}) { 14 | buckets = List.filled(capacity, []); 15 | } 16 | 17 | int indexOf(K key) { 18 | return (key.hashCode % count).abs(); 19 | } 20 | 21 | V valueForKey(K key) { 22 | final index = indexOf(key); 23 | var value; 24 | if (index != null) { 25 | for (var element in buckets[index]) { 26 | if (element.key == key) { 27 | value = element.value; 28 | break; 29 | } 30 | } 31 | } 32 | return value; 33 | } 34 | 35 | void update(K key, V value) { 36 | final index = indexOf(key); 37 | var isPresentInHash = false; 38 | 39 | for (var element in buckets[index]) { 40 | if (element.key == key) { 41 | isPresentInHash = true; 42 | element.value = value; 43 | } 44 | } 45 | 46 | if (!isPresentInHash) { 47 | buckets[index].add(Element(key, value)); 48 | } 49 | } 50 | 51 | void remove(K key) { 52 | final index = indexOf(key); 53 | 54 | var indexToRemove = 0; 55 | for (var element in buckets[index]) { 56 | if (element.key == key) { 57 | break; 58 | } 59 | indexToRemove += 1; 60 | } 61 | 62 | buckets[index].removeAt(indexToRemove); 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /data-structures/binary-tree/binary-tree.dart: -------------------------------------------------------------------------------- 1 | 2 | class BinaryTree { 3 | T data; 4 | BinaryTree leftChild; 5 | BinaryTree rightChild; 6 | 7 | BinaryTree.createNode(this.data, [this.leftChild, this.rightChild]); 8 | 9 | bool get isLeaf => leftChild == null && rightChild == null; 10 | 11 | @override 12 | String toString() { 13 | if (this == null) { 14 | return ''; 15 | } 16 | return 'value: ${data}, left = [${leftChild.toString()}], right = [${rightChild.toString()}]'; 17 | } 18 | } 19 | 20 | extension BinaryTreeCount on BinaryTree { 21 | int count() { 22 | if (isLeaf) { 23 | return 1; 24 | } else { 25 | return (leftChild != null ? leftChild.count() : 0) + 1 + (rightChild != null ? rightChild.count() : 0); 26 | } 27 | } 28 | } 29 | 30 | extension Traversal on BinaryTree { 31 | void traversePreOrder(process) { 32 | if (this == null) { 33 | return; 34 | } 35 | process(data); 36 | leftChild.traversePreOrder(process); 37 | rightChild.traversePreOrder(process); 38 | } 39 | 40 | void traverseInOrder(process) { 41 | if (this == null) { 42 | return; 43 | } 44 | leftChild.traverseInOrder(process); 45 | process(data); 46 | rightChild.traverseInOrder(process); 47 | } 48 | 49 | void traversePostOrder(process) { 50 | if (this == null) { 51 | return; 52 | } 53 | leftChild.traversePostOrder(process); 54 | rightChild.traversePostOrder(process); 55 | process(data); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /10. Асинхронность в Dart/10.3_main.dart: -------------------------------------------------------------------------------- 1 | void doWork() { 2 | print("print 1: Начало функции doWork"); 3 | 4 | Future messageFuture = getMessage(); 5 | 6 | messageFuture.then((message) { 7 | print("print 2: Получено сообщение: $message"); 8 | }); 9 | 10 | print("print 3: Завершение функции doWork"); 11 | } 12 | 13 | Future getMessage() { 14 | // имитация долгой работы с помощью задержки в 3 секунды 15 | 16 | return Future.delayed(Duration(seconds: 3), () => "Hello Dart"); 17 | } 18 | 19 | void main() { 20 | doWork(); 21 | 22 | print("print 4: Выполнение функции main"); 23 | } 24 | 25 | //_________________Example 2_______________ 26 | Future doWork() async { 27 | print("print 1: Начало функции doWork"); 28 | 29 | String message = await getMessage(); 30 | 31 | print("print 2: Получено сообщение: $message"); 32 | 33 | print("print 3: Завершение функции doWork"); 34 | } 35 | 36 | Future getMessage() { 37 | // имитация долгой работы с помощью задержки в 3 секунды 38 | 39 | return Future.delayed(Duration(seconds: 3), () => "Hello Dart"); 40 | } 41 | 42 | void main() { 43 | doWork(); 44 | 45 | print("print 4: Выполнение функции main"); 46 | } 47 | 48 | //__________Example 3________________ 49 | Future doWork() async { 50 | print("print 1: Начало функции doWork"); 51 | 52 | try { 53 | String message = await getMessage(); 54 | 55 | print("print 2: Получено сообщение: $message"); 56 | } catch (e) { 57 | print("print 2 with error: Произошла ошибка: $e"); 58 | } 59 | 60 | print("print 3: Завершение функции doWork"); 61 | } 62 | 63 | Future getMessage() { 64 | // с помощью оператора throw имитируем возникновение ошибки 65 | 66 | return Future.delayed(Duration(seconds: 3), () => throw "Сервер не отвечает"); 67 | } 68 | 69 | void main() { 70 | doWork(); 71 | 72 | print("print 4: Выполнение функции main"); 73 | } 74 | -------------------------------------------------------------------------------- /9 ООП/9.2_main.dart: -------------------------------------------------------------------------------- 1 | //________________Example 1____________________ 2 | 3 | class User{ 4 | 5 | String name = ""; 6 | void display(){ 7 | print("Name: $name"); 8 | 9 | } 10 | } 11 | 12 | class Worker{ 13 | String company = ""; 14 | void work(){ 15 | 16 | print("Work in $company"); 17 | 18 | } 19 | } 20 | class Employee extends User, Worker{ // Ошибка, множественное наследование не допускается 21 | 22 | //_______________Example 2______________________ 23 | void main() { 24 | User anna = Employee(); 25 | anna.name = "Anna"; 26 | anna.display(); // Employee name: Anna 27 | } 28 | 29 | class User { 30 | String name; 31 | 32 | User(this.name); 33 | 34 | void display() { 35 | print("Name: $name"); 36 | } 37 | } 38 | 39 | class Employee implements User { 40 | String name = ""; // реализация поля name 41 | 42 | // реализация метода display 43 | void display() { 44 | print("Employee name: $name"); 45 | } 46 | } 47 | 48 | //________________Example 3____________________ 49 | void main() { 50 | Employee anna = Employee("Anna", "Flutter"); 51 | anna.display(); // Employee name: Anna 52 | anna.work(); // Employee works in Flutter 53 | } 54 | 55 | class User { 56 | String name; 57 | User(this.name); 58 | 59 | void display() { 60 | print("Name: $name"); 61 | } 62 | } 63 | 64 | class Worker { 65 | String company = ""; 66 | 67 | void work() { 68 | print("Work in $company"); 69 | } 70 | } 71 | 72 | class Employee implements User, Worker { 73 | String name; // реализация поля name из User 74 | String company; // реализация поля company из Worker 75 | 76 | void display() { 77 | // реализация метода display User 78 | print("Employee name: $name"); 79 | } 80 | 81 | // реализация метода work из Worker 82 | void work() { 83 | print("Employee works in $company"); 84 | } 85 | 86 | Employee(this.name, this.company); 87 | } -------------------------------------------------------------------------------- /data-structures/heap/heap.dart: -------------------------------------------------------------------------------- 1 | 2 | abstract class Heap { 3 | 4 | var heapContainer = []; 5 | 6 | Heap(this.heapContainer) { 7 | configureHeap(); 8 | } 9 | 10 | Heap addItem(item) { 11 | heapContainer.add(item); 12 | heapifyUp(); 13 | return this; 14 | } 15 | 16 | void configureHeap() { 17 | if (heapContainer.isNotEmpty) { 18 | for (var index = heapContainer.length - 1; index >= ((heapContainer.length - 1)/2).floor(); index -= 1) { 19 | heapifyUp(index); 20 | } 21 | } 22 | } 23 | 24 | num getLeftChildIndex(parentIndex) { 25 | return (parentIndex * 2) + 1; 26 | } 27 | 28 | num getRightChildIndex(parentIndex) { 29 | return (parentIndex * 2) + 2; 30 | } 31 | 32 | num getParentIndex(childIndex) { 33 | return ((childIndex - 1)/2).floor(); 34 | } 35 | 36 | bool hasParent(childIndex) { 37 | return getParentIndex(childIndex) >= 0; 38 | } 39 | 40 | bool hasLeftChild(parentIndex) { 41 | return getLeftChildIndex(parentIndex) < heapContainer.length; 42 | } 43 | 44 | bool hasRightChild(parentIndex) { 45 | return getRightChildIndex(parentIndex) < heapContainer.length; 46 | } 47 | 48 | num leftChild(parentIndex) { 49 | return heapContainer[getLeftChildIndex(parentIndex)]; 50 | } 51 | 52 | num rightChild(parentIndex) { 53 | return heapContainer[getRightChildIndex(parentIndex)]; 54 | } 55 | 56 | num parent(index) { 57 | return heapContainer[getParentIndex(index)]; 58 | } 59 | 60 | void swap(int indexOne, int indexTwo) { 61 | final temp = heapContainer[indexOne]; 62 | heapContainer[indexOne] = heapContainer[indexTwo]; 63 | heapContainer[indexTwo] = temp; 64 | } 65 | 66 | void heapifyUp([index]) { 67 | index = index ?? heapContainer.length - 1; 68 | while (hasParent(index) && !pairIsInCorrectOrder(parent(index), heapContainer[index])) { 69 | swap(index, getParentIndex(index)); 70 | index = getParentIndex(index); 71 | } 72 | } 73 | 74 | bool pairIsInCorrectOrder(num itemOne, num itemTwo); 75 | } 76 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.5.3_main.dart: -------------------------------------------------------------------------------- 1 | void main() { 2 | //___________Example 1___________________________ 3 | Set halogens = {}; 4 | halogens.addAll(['fluorine', 'chlorine', 'bromine', 'iodine']); 5 | halogens.add('astatine'); // Это не вызовет ошибку 6 | halogens.remove('fluorine'); 7 | print(halogens); 8 | print(halogens.contains('astatine')); 9 | print(halogens.containsAll(['astatine', 'chlorine', 'bromine', 'iodine'])); 10 | //___________Example 2___________________________ 11 | var set = {-3, -1, 2, 4, 5, 7}; 12 | // получим первый элемент 13 | print(set.first); // -3 14 | // получим последний элемент 15 | print(set.last); // 7 16 | // получим длинну набора 17 | print(set.length); // 6 18 | // добавим набор 19 | set.addAll({4, 2, 6}); 20 | 21 | //соединим в одну строку используя запятую в качестве разделителя 22 | print(set.join(", ")); 23 | 24 | // удалим число 4 25 | set.remove(4); 26 | 27 | print(set.join(", ")); 28 | 29 | //получим все элементы которые больше числа 2 30 | set = set.where((element) => element > 2).toSet(); 31 | // выведем полученный результат через запятую 32 | print(set.join(", ")); 33 | 34 | //___________Example 3___________________________ 35 | 36 | var set = {-3, -1, 2, 4, 5, 7}; 37 | set.add(12); // добавим число 12 в список 38 | set.addAll({4, 2, 6}); // добавим несколько чисел в список 39 | print(set.join( 40 | ", ")); // -3, -1, 2, 4, 5, 7, 6 выведем получившийся список в качестве разделитея запятая 41 | 42 | set.remove(4); // удалим число 4 43 | print(set.join( 44 | "; ")); // -3, -1, 2, 5, 7, 6 выведем элементы списка, разделитель точка с запятой 45 | 46 | set = set.where((element) => element > 2).toSet(); 47 | print(set.join(", ")); // 5, 6, 7 получим те элементы которые больше 2 48 | 49 | set.clear(); 50 | print('Пустой список: $set'); 51 | 52 | //___________Example 4___________________________ 53 | var intSet = {1, 2, 3, 5}; 54 | for (var n in intSet) { 55 | print(n); 56 | } 57 | var stringSet = {"Den", "Anna", "Egor"}; 58 | for (var s in stringSet) { 59 | print(s); 60 | } 61 | 62 | //___________Example 5___________________________ 63 | var set1 = {1, 2, 3, 5}; 64 | set1.add(3); // добавляем один элемент - 3 65 | set1.addAll({4, 5}); // добавляем другой набор - {4, 5} 66 | for (var n in set1) { 67 | print(n); // 1 2 3 5 4 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /3. Базовые типы данных в Dart/3.5.2_main.dart: -------------------------------------------------------------------------------- 1 | void main (){ 2 | //__________Example 1___________________________ 3 | var fruits = ['apples', 'oranges']; 4 | 5 | // Получаем доступ к элементу списка по индексу. 6 | assert(fruits[0] == 'apples'); 7 | print("1. fruits[0] будет: ${fruits[0]}"); 8 | 9 | // Находим элемент в списке. 10 | assert(fruits.indexOf('apples') == 0); 11 | print("2. fruits.indexOf('apples') будет: ${fruits.indexOf('apples')}"); 12 | 13 | // Если мы попытаемся обратиться по несуществующему индексу, то мы столкнемся с ошибкой: 14 | 15 | assert(fruits[4] == 'apples'); //Ошибка 16 | print("3. fruits[4] будет: ${fruits[4]}"); 17 | 18 | //___________Example 2_______________________ 19 | var list = ['apples', 'bananas', 'oranges']; 20 | for (int i = 0; i < list.length; i++) { 21 | print(list[i]); 22 | } 23 | 24 | //___________Example 3_______________________ 25 | 26 | var lists = ['apples', 'bananas', 'oranges']; 27 | for (var n in lists) { 28 | print(n); 29 | } 30 | 31 | //_____________Example 4_______________________ 32 | 33 | var fruit = ['bananas', 'apples', 'oranges']; 34 | 35 | // Sort a list. 36 | fruit.sort((a, b) => a.compareTo(b)); 37 | 38 | print(fruit); 39 | 40 | //_____________Example 5___________________________ 41 | 42 | var list1 = [3]; 43 | list1.add(1); 44 | list1.add(4); 45 | list1.add(5); 46 | for (var n in list1) { 47 | print(n); 48 | } 49 | 50 | //_____________Example 6___________________________ 51 | 52 | var list2 = List.generate(4, (int index) => index + 1, growable: false); 53 | print(list2); // фиксированный список [1, 2, 3, 4] 54 | list2[0] = 3; 55 | list2[1] = 7; 56 | list2[2] = 11; 57 | list2[3] = 15; 58 | //list2.add(1); //Error нельзя добавить новый элемент 59 | for (var n in list2) { 60 | print(n); 61 | 62 | //_____________Example 7___________________________ 63 | 64 | var list = [-3, -1, 2, 4, 5, 7]; 65 | // получим первый элемент 66 | print(list.first); // -3 67 | // получим последний элемент 68 | print(list.last); // 7 69 | // получим длину списка 70 | print(list.length); // 6 71 | // добавим список 72 | list.addAll([4, 6]); 73 | // соединим элементы списка в строку, разделитель запятая 74 | print(list.join(", ")); // -3, -1, 2, 4, 5, 7, 4, 6 75 | // отсортируем список 76 | list.sort(); 77 | print(list.join(", ")); // -3, -1, 2, 4, 4, 5, 6, 7 78 | // удалим число 4 79 | list.remove(4); 80 | // удалим второй элемент 81 | list.removeAt(1); 82 | print(list.join(", ")); // -3, 2, 4, 5, 6, 7 83 | // получим элементы больше  2 84 | list = list.where((element) => element > 2).toList(); 85 | print(list.join(", ")); // 4, 5, 6, 7 86 | 87 | } 88 | } -------------------------------------------------------------------------------- /9 ООП/9.8_main.dart: -------------------------------------------------------------------------------- 1 | //______________Example 1___________________ 2 | void main() { 3 | User den = User("Den", 38); 4 | den.checkAge(); 5 | 6 | User.retirenmentAge = 65; 7 | den.checkAge(); 8 | } 9 | 10 | class User { 11 | String name; 12 | int age; 13 | 14 | static int retirenmentAge = 60; 15 | 16 | User(this.name, this.age); 17 | 18 | checkAge() { 19 | if (age >= retirenmentAge) { 20 | print("Пора на пенсию"); 21 | } else { 22 | print("$name тебе до пенсии еще ${retirenmentAge - age} лет"); 23 | } 24 | } 25 | } 26 | 27 | //________________Example 2______________________ 28 | 29 | void main() { 30 | User den = User("Den", 38); 31 | den.checkAge(); 32 | 33 | print("Пенсионный возраст ${User.retirenmentAge}"); 34 | } 35 | 36 | class User { 37 | String name; 38 | int age; 39 | static const int retirenmentAge = 65; 40 | 41 | User(this.name, this.age); 42 | 43 | checkAge() { 44 | if (age >= retirenmentAge) { 45 | print("Пора на пенсию"); 46 | } else { 47 | print("$name тебе до пенсии еще ${retirenmentAge - age} лет"); 48 | } 49 | } 50 | } 51 | 52 | //________________Example 3___________________ 53 | void main() { 54 | int a = Operation.sum(3, 5); 55 | int b = Operation.subtract(15, 7); 56 | int c = Operation.multiply(3, 5); 57 | print("a=$a  b=$b  c=$c"); // a=8  b=8  c=15 58 | } 59 | 60 | class Operation { 61 | static int sum(int x, int y) => x + y; 62 | static int subtract(int x, int y) => x - y; 63 | static int multiply(int x, int y) => x * y; 64 | } 65 | 66 | 67 | //________________Example 4___________________ 68 | void main() { 69 | int a = sum(3, 5); 70 | int b = subtract(15, 7); 71 | int c = multiply(3, 5); 72 | print("a=$a  b=$b  c=$c"); // a=8  b=8  c=15 73 | } 74 | 75 | int sum(int x, int y) => x + y; 76 | 77 | int subtract(int x, int y) => x - y; 78 | 79 | int multiply(int x, int y) => x * y; 80 | 81 | //________________Example 5____________________ 82 | void main() { 83 | User den = User("Den", 38); 84 | User.setRetirenmentAge(63); 85 | print(User.retirenmentAge); 86 | } 87 | 88 | class User { 89 | String name; 90 | int age; 91 | static int retirenmentAge = 65; 92 | 93 | User(this.name, this.age); 94 | 95 | checkAge() { 96 | if (age >= retirenmentAge) { 97 | print("Пора на пенсию"); 98 | } else { 99 | print("До пенсии еще ${retirenmentAge - age} лет"); 100 | } 101 | } 102 | 103 | static void setRetirenmentAge(int value) { 104 | if (value > 50 && value < 70) { 105 | retirenmentAge = value; 106 | } else { 107 | print("Некорректное значение"); 108 | } 109 | } 110 | } -------------------------------------------------------------------------------- /data-structures/graph/adjacency-list-graph.dart: -------------------------------------------------------------------------------- 1 | 2 | 3 | import 'package:dart_algorithm_club/data-structures/graph/edge-list.dart'; 4 | import 'package:dart_algorithm_club/data-structures/graph/edge.dart'; 5 | import 'package:dart_algorithm_club/data-structures/graph/graph.dart'; 6 | import 'package:dart_algorithm_club/data-structures/graph/vertex.dart'; 7 | 8 | class AdjacencyListGraph extends Graph { 9 | 10 | var adjacencyList; 11 | 12 | AdjacencyListGraph() { 13 | adjacencyList = >[]; 14 | } 15 | 16 | @override 17 | List get edges { 18 | var edges = >{}; 19 | adjacencyList.forEach((EdgeList edgeList) { 20 | edges.addAll(edgeList.edges); 21 | }); 22 | return edges.toList(); 23 | } 24 | 25 | @override 26 | List get vertices { 27 | var vertices = []; 28 | adjacencyList.forEach((EdgeList edgeList) { 29 | vertices.add(edgeList.vertex); 30 | }); 31 | return vertices; 32 | } 33 | 34 | @override 35 | Vertex createVertex(data) { 36 | var matchingVertex = vertices.lastWhere((vertex) => vertex.data == data, orElse: () => null); 37 | 38 | if (matchingVertex == null) { 39 | matchingVertex = Vertex(data, adjacencyList.length); 40 | adjacencyList.add(EdgeList(matchingVertex)); 41 | } 42 | return matchingVertex; 43 | } 44 | 45 | @override 46 | void addDirectedEdge(Vertex from, Vertex to, [num weight]) { 47 | var edge = Edge(from, to, weight); 48 | var edges = adjacencyList[from.index].edges; 49 | edges.add(edge); 50 | } 51 | 52 | @override 53 | void addUnDirectedEdge(Vertex from, Vertex to, [num weight]) { 54 | addDirectedEdge(from, to, weight); 55 | addDirectedEdge(to, from, weight); 56 | } 57 | 58 | @override 59 | num weightFrom(Vertex sourceVertex, Vertex destinationVertex) { 60 | var edges = adjacencyList[sourceVertex.index].edges; 61 | var matchingEdge; 62 | for(Edge edge in edges) { 63 | if (edge.to == destinationVertex) { 64 | matchingEdge = edge; 65 | break; 66 | } 67 | } 68 | return matchingEdge ? matchingEdge.weight : null; 69 | 70 | } 71 | 72 | @override 73 | List> edgesFrom(Vertex sourceVertex) { 74 | var edgeList = adjacencyList[sourceVertex.index]; 75 | if (edgeList) { 76 | return edgeList.edges; 77 | } 78 | return null; 79 | } 80 | 81 | @override 82 | String toString() { 83 | var rows = []; 84 | for (var edgeList in adjacencyList) { 85 | if (edgeList.edges.length == 0) { 86 | continue; 87 | } 88 | 89 | var row = []; 90 | for(var edge in edgeList.edges) { 91 | row.add('${edge.to.data}: ${edge.weight}'); 92 | } 93 | rows.add('${edgeList.vertex.data} -> [${row.join(', ')}]'); 94 | } 95 | return rows.join('\n'); 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /data-structures/graph/adjacency-matrix-graph.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'package:dart_algorithm_club/data-structures/graph/edge.dart'; 3 | import 'package:dart_algorithm_club/data-structures/graph/graph.dart'; 4 | import 'package:dart_algorithm_club/data-structures/graph/vertex.dart'; 5 | 6 | class AdjacencyMatrixGraph extends Graph { 7 | 8 | List> adjacencyMatrix; 9 | List> _vertices; 10 | 11 | AdjacencyMatrixGraph() { 12 | adjacencyMatrix = []; 13 | _vertices = []; 14 | } 15 | 16 | @override 17 | List get edges { 18 | var _edges = []; 19 | for(var row = 0; row <= adjacencyMatrix.length; row += 1) { 20 | for(var column = 0; column < adjacencyMatrix[row].length; column += 1) { 21 | final weight = adjacencyMatrix[row][column]; 22 | if (weight != null) { 23 | _edges.add(Edge(vertices[row], vertices[column], weight)); 24 | } 25 | } 26 | } 27 | return _edges; 28 | } 29 | 30 | @override 31 | Vertex createVertex(data) { 32 | var matchingVertex = vertices.lastWhere((vertex) => vertex.data == data, orElse: () => null); 33 | if (matchingVertex == null) { 34 | matchingVertex = Vertex(data, adjacencyMatrix.length); 35 | 36 | adjacencyMatrix.add(List.filled(adjacencyMatrix.length, null, growable: true)); 37 | adjacencyMatrix.forEach((row) { 38 | row.add(null); 39 | }); 40 | vertices.add(matchingVertex); 41 | } 42 | return matchingVertex; 43 | } 44 | 45 | @override 46 | List get vertices => _vertices; 47 | 48 | @override 49 | void addDirectedEdge(Vertex from, Vertex to, [num weight]) { 50 | adjacencyMatrix[from.index][to.index] = weight; 51 | } 52 | 53 | @override 54 | void addUnDirectedEdge(Vertex from, Vertex to, [num weight]) { 55 | addDirectedEdge(from, to, weight); 56 | addDirectedEdge(to, from, weight); 57 | } 58 | 59 | @override 60 | num weightFrom(Vertex sourceVertex, Vertex destinationVertex) { 61 | return adjacencyMatrix[sourceVertex.index][destinationVertex.index]; 62 | } 63 | 64 | @override 65 | List edgesFrom(Vertex sourceVertex) { 66 | var row = adjacencyMatrix[sourceVertex.index]; 67 | var index = 0; 68 | var edges = []; 69 | for (var weight in row) { 70 | if (weight != null) { 71 | edges.add(Edge(sourceVertex, vertices[index], weight)); 72 | } 73 | index += 1; 74 | } 75 | return edges; 76 | } 77 | 78 | @override 79 | String toString() { 80 | var rows = []; 81 | for(var rowIndex = 0; rowIndex < adjacencyMatrix.length; rowIndex += 1) { 82 | var row = []; 83 | for(var columnIndex = 0; columnIndex < adjacencyMatrix[rowIndex].length; columnIndex += 1) { 84 | var weight = adjacencyMatrix[rowIndex][columnIndex]; 85 | if (weight != null) { 86 | row.add(' ${weight} '); 87 | } else { 88 | row.add(' ø '); 89 | } 90 | } 91 | rows.add(row.join()); 92 | } 93 | return rows.join('\n'); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /data-structures/linked-list/linked-list.dart: -------------------------------------------------------------------------------- 1 | import 'dart:collection'; 2 | 3 | import 'package:dart_algorithm_club/data-structures/linked-list/linked-list-node.dart'; 4 | 5 | class LinkedListIterator implements Iterator> { 6 | 7 | LinkedListNode node; 8 | 9 | LinkedListIterator(this.node); 10 | 11 | @override 12 | LinkedListNode get current => node; 13 | 14 | @override 15 | bool moveNext() { 16 | if (node != null && node.next != null) { 17 | node = node.next; 18 | return true; 19 | } 20 | return false; 21 | } 22 | } 23 | 24 | class LinkedList with IterableMixin> { 25 | LinkedListNode head; 26 | 27 | @override 28 | LinkedListNode get last { 29 | if (head == null) { 30 | return null; 31 | } 32 | 33 | var element = head; 34 | while(element.next != null) { 35 | element = element.next; 36 | } 37 | return element; 38 | } 39 | 40 | int get count { 41 | var element = head; 42 | var count = 1; 43 | while(element.next != null) { 44 | element = element.next; 45 | count += 1; 46 | } 47 | return count; 48 | } 49 | 50 | LinkedListNode nodeAt(int index) { 51 | if (head == null || index < 0) { 52 | throw IndexError; 53 | } 54 | 55 | var element = head; 56 | for(var iterator = 0; iterator < index; iterator+=1) { 57 | if (iterator == index) { 58 | break; 59 | } 60 | element = element.next; 61 | } 62 | return element; 63 | } 64 | 65 | void append(T value) { 66 | var newNode = LinkedListNode(value); 67 | appendNode(newNode); 68 | } 69 | 70 | void appendNode(LinkedListNode node) { 71 | if (last == null) { 72 | head = node; 73 | } else { 74 | last.next = node; 75 | } 76 | } 77 | 78 | void insert(T value, int index) { 79 | insertNode(LinkedListNode(value), index); 80 | } 81 | 82 | void insertNode(LinkedListNode node, int index) { 83 | if (head == null) { 84 | head = node; 85 | } else if (index < 0 || index > length){ 86 | throw IndexError; 87 | } else if (index == 0) { 88 | node.next = head; 89 | head = node; 90 | } else { 91 | final nodeToReplace = nodeAt(index); 92 | final previousNode = nodeAt(index - 1); 93 | previousNode.next = node; 94 | node.next = nodeToReplace; 95 | } 96 | } 97 | 98 | List toArray() { 99 | var itr = iterator; 100 | var array = [itr.current.value]; 101 | 102 | while(itr.moveNext()) { 103 | array.add(itr.current.value); 104 | } 105 | return array; 106 | } 107 | 108 | void removeAll() { 109 | head = null; 110 | } 111 | 112 | T removeLast() { 113 | return remove(length - 1); 114 | } 115 | 116 | T remove(int index) { 117 | final node = removeNode(nodeAt(index)); 118 | return node != null ? node.value : null; 119 | } 120 | 121 | LinkedListNode removeNode(LinkedListNode node) { 122 | if (length == 0) { 123 | throw ArgumentError; 124 | } 125 | 126 | final itr = iterator; 127 | var element = head; 128 | if (itr.current.value == node.value) { 129 | head = head.next; 130 | } else { 131 | do { 132 | element = itr.current.next; 133 | if (itr.current.next.value == node.value) { 134 | itr.current.next = itr.current.next.next; 135 | break; 136 | } 137 | } while(itr.moveNext()); 138 | } 139 | return element; 140 | } 141 | 142 | LinkedList reverse() { 143 | var currentNode = head; 144 | var previousNode; 145 | var nextNode; 146 | 147 | while(currentNode != null) { 148 | nextNode = currentNode.next; 149 | currentNode.next = previousNode; 150 | previousNode = currentNode; 151 | currentNode = nextNode; 152 | } 153 | 154 | head = previousNode; 155 | return this; 156 | } 157 | 158 | @override 159 | Iterator> get iterator => LinkedListIterator(head); 160 | } 161 | -------------------------------------------------------------------------------- /data-structures/doubly-linked-list/doubly-linked-list.dart: -------------------------------------------------------------------------------- 1 | 2 | import 'dart:collection'; 3 | 4 | import 'package:dart_algorithm_club/data-structures/doubly-linked-list/doubly-linked-list-node.dart'; 5 | 6 | class DoublyLinkedListIterator implements Iterator> { 7 | 8 | DoublyLinkedListNode node; 9 | 10 | DoublyLinkedListIterator(this.node); 11 | 12 | @override 13 | DoublyLinkedListNode get current => node; 14 | 15 | @override 16 | bool moveNext() { 17 | if (node != null && node.next != null) { 18 | node = node.next; 19 | return true; 20 | } 21 | return false; 22 | } 23 | } 24 | 25 | class DoublyLinkedList with IterableMixin> { 26 | 27 | DoublyLinkedListNode head; 28 | 29 | @override 30 | DoublyLinkedListNode last; 31 | 32 | int get count { 33 | final itr = iterator; 34 | var count = 0; 35 | while(itr.moveNext()) { 36 | count += 1; 37 | } 38 | return count + 1; 39 | } 40 | 41 | @override 42 | Iterator> get iterator => DoublyLinkedListIterator(head); 43 | 44 | DoublyLinkedListNode nodeAt(int index) { 45 | if (head == null || index < 0 || index > length) { 46 | throw IndexError; 47 | } 48 | 49 | var element = head; 50 | for(var iterator = 0; iterator < index; iterator+=1) { 51 | if (iterator == index) { 52 | break; 53 | } 54 | element = element.next; 55 | } 56 | return element; 57 | } 58 | 59 | void append(T value) { 60 | var newNode = DoublyLinkedListNode(value); 61 | appendNode(newNode); 62 | } 63 | 64 | void appendNode(DoublyLinkedListNode node) { 65 | if (head == null && last == null) { 66 | head = node; 67 | last = node; 68 | } else { 69 | node.previous = last; 70 | last.next = node; 71 | last = node; 72 | } 73 | } 74 | 75 | void insert(T value, int index) { 76 | insertNode(DoublyLinkedListNode(value), index); 77 | } 78 | 79 | void insertNode(DoublyLinkedListNode node, int index) { 80 | if (head == null) { 81 | head = node; 82 | last = node; 83 | } else if (index < 0 || index > length){ 84 | throw IndexError; 85 | } else if (index == 0) { 86 | node.next = head; 87 | head.previous = node; 88 | head = node; 89 | } else { 90 | final nodeToReplace = nodeAt(index); 91 | final previousNode = nodeToReplace.previous; 92 | previousNode.next = node; 93 | node.previous = previousNode; 94 | node.next = nodeToReplace; 95 | nodeToReplace.previous = node; 96 | } 97 | } 98 | 99 | List toArray() { 100 | var itr = iterator; 101 | var array = [itr.current.value]; 102 | 103 | while(itr.moveNext()) { 104 | array.add(itr.current.value); 105 | } 106 | return array; 107 | } 108 | 109 | void removeAll() { 110 | head = null; 111 | last = null; 112 | } 113 | 114 | T removeLast() { 115 | return remove(length); 116 | } 117 | 118 | T remove(int index) { 119 | final node = removeNode(nodeAt(index)); 120 | return node != null ? node.value : null; 121 | } 122 | 123 | DoublyLinkedListNode removeNode(DoublyLinkedListNode node) { 124 | if (length == 0 || (node.previous == null && node.next == null)) { 125 | throw ArgumentError; 126 | } 127 | 128 | final previousElement = node.previous; 129 | final nextElement = node.next; 130 | 131 | if (previousElement != null) { 132 | previousElement.next = nextElement; 133 | } else { 134 | head = nextElement; 135 | } 136 | 137 | if (nextElement != null) { 138 | nextElement.previous = previousElement; 139 | } else { 140 | last = previousElement; 141 | } 142 | return node; 143 | } 144 | 145 | DoublyLinkedList reverse() { 146 | var currentNode = head; 147 | var previousNode; 148 | var nextNode; 149 | 150 | while (currentNode != null) { 151 | nextNode = currentNode.next; 152 | previousNode = currentNode.previous; 153 | 154 | currentNode.next = previousNode; 155 | currentNode.previous = nextNode; 156 | 157 | previousNode = currentNode; 158 | currentNode = nextNode; 159 | } 160 | 161 | last = head; 162 | head = previousNode; 163 | 164 | return this; 165 | } 166 | } 167 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Project: Примеры к курсу ["Основы Dart"](https://stepik.org/course/92982) 2 | 3 | ## Description 4 | Этот курс обеспечит базовое понимание языка программирования Dart. Данный курс будет полезен начинающим Flutter разработчикам. 5 | 6 | ## A Live version of the project: 7 | - [ ] [Основы Dart](https://stepik.org/course/92982) 8 | 9 | 10 | ## Environment 11 | - [ ] [dartpad](https://dartpad.dev/) 12 | 13 | ## Getting started 14 | - [ ] To get started open dartpad and try code from each lesoons: 15 | ### 1. Введение в Dart: 16 | * [1.1 Введение в Dart](https://github.com/Anna-Myzukina/dart-course/blob/main/1.%20%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B2%20Dart/1.1_main.dart) 17 | * [1.2 Dart style](https://github.com/Anna-Myzukina/dart-course/blob/main/1.%20%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B2%20Dart/1.2_main.dart) 18 | * [1.3 Комментарии](https://github.com/Anna-Myzukina/dart-course/blob/main/1.%20%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B2%20Dart/1.3_main.dart) 19 | * [1.4 Технология компилятора Dart](https://github.com/Anna-Myzukina/dart-course/blob/main/1.%20%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%B2%20Dart/1.4_main.dart) 20 | * 1.5 Важные факты и концепции языка Dart 21 | * 1.6 Dart FFI 22 | * 1.7 Null safety 23 | 24 | ### 2. Переменные и константы: 25 | * [2.1 Введение: переменные](https://github.com/Anna-Myzukina/dart-course/blob/main/5.%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D1%8B/5.1_main.dart) 26 | * [2.2 Объявление переменных: var и dynamic](https://github.com/Anna-Myzukina/dart-course/blob/main/5.%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D1%8B/5.2_main.dart) 27 | * [2.3 Константы : final и const](https://github.com/Anna-Myzukina/dart-course/blob/main/5.%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D1%8B/5.3_main.dart) 28 | * [2.4 Late модификатор] 29 | * [2.5 Перечисляемые типы: enum](https://github.com/Anna-Myzukina/dart-course/blob/main/5.%20%D0%9F%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%B8%20%D0%BA%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D1%8B/5.4_main.dart) 30 | 31 | ### 3. Базовые типы данных в Dart: 32 | * [3.1 Введение в базовые типы](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.1_main.dart) 33 | * [3.2 Числа: int и double](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.2_main.dart) 34 | * [3.3 Строковые переменные: String](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.3.1_main.dart) 35 | * [3.4 Логические переменные (тип bool): true и false](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.4_main.dart) 36 | * [3.5 Коллекции: List, Set, Map](https://github.com/Anna-Myzukina/dart-course/tree/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart) 37 | * [3.6 Руны и кластеры графем](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.6_main.dart) 38 | * [3.7 Символы: объект Symbol](https://github.com/Anna-Myzukina/dart-course/blob/main/6.%20%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D0%B5%20%D1%82%D0%B8%D0%BF%D1%8B%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20%D0%B2%20Dart/6.7_main.dart) 39 | 40 | ### 4. Generics: 41 | * 4.1 Что такое дженерики? 42 | 43 | ### 5. Функциональное программирование: 44 | * [5.1 Функции в Dart[()]() 45 | * [5.2 Функция main ()]() 46 | * [5.3 Параметры функции: обязательные и необязательные]() 47 | * [5.4 Анонимные функции]() 48 | * [5.5 Вложенные функции]() 49 | * [5.6 Лексическая область видимости]() 50 | * [5.7 Замыкание (closure)]() 51 | * [5.8 Проверка функций на равенство]() 52 | 53 | ### 6. Dart операторы: 54 | * [6.1 Введение]() 55 | * [6.2 Операторы присваивания]() 56 | * [6.3 Арифметические операторы]() 57 | * [6.4 Операторы равенства и отношения]() 58 | * [6.5 Тестовые операторы: as, isи is!]() 59 | * [6.6 Логические операторы: !expr, ||, &&]() 60 | * [6.7 Побитовые операторы и операторы сдвига]() 61 | * [6.8 Каскадная запись (..)]() 62 | * [6.9 Условные выражения]() 63 | 64 | ### 7. Условные конструкции: 65 | * [7.1 Введение]() 66 | * [7.2 Условные операторы: if и else]() 67 | * [7.3 Циклы: for, while и do-while]() 68 | * [7.4 Конструкции: break и continue]() 69 | * [7.5 Конструкции switch и case]() 70 | * [7.6 Утверждения assert]() 71 | 72 | ### 8. Исключения: trow, catch, finally: 73 | * [8.1 Введение]() 74 | * [8.2 Throw]() 75 | * [8.3 Блоки try / on / catch]() 76 | * [8.4 Блок finally]() 77 | * [8.5 Пользовательские исключения]() 78 | 79 | ### 9. Объектно-ориентированное программирование: 80 | * [9.1 Базовые принципы ООП]() 81 | * [9.2 Принцип 1. Наследование]() 82 | * [9.3 Принцип 2. Абстракция]() 83 | * [9.4 Принцип 3. Инкапсуляция]() 84 | * [9.5 Принцип 4. Полиморфизм]() 85 | * [9.6 Классы и объекты]() 86 | * [9.7 Конструкторы]() 87 | * [9.8 Статические: поля, методы, константы]() 88 | 89 | ### 10. Асинхронность в Dart: async/await, futures, генераторы, изоляты: 90 | * [10.1 Введение]() 91 | * [10.2 Работа с классом Future]() 92 | * [10.3 Асинхронные функции и операторы async и await]() 93 | * [10.4 Генераторы: Iterable, Stream]() 94 | * [10.5 Изоляты (Isolates)]() 95 | * [10.6 Циклы событий (Event loops)]() 96 | 97 | ### 11. SOLID принципы в Dart: 98 | * [11.1 Введение в SOLID принципы]() 99 | * [11.2 S - Принцип единственной ответственности]() 100 | * [11.3 O - Принцип открытости-закрытости]() 101 | * [11.4 L - Принцип подстановки Лисков]() 102 | * [11.5 I - Принцип разделения интерфейса]() 103 | * [11.6 D - Принцип инверсии зависимостей]() 104 | 105 | 106 | ## Show your support 107 | 108 | - [ ] Give a ⭐️ if you like this project! 109 | 110 | ## 📝 License 111 | 112 | * [ ] See [LICENSE.md](https://github.com/Anna-Myzukina/dart-course/blob/master/LICENSE.md) for details. 113 | 114 | ## Authors 115 | 116 | 👤 **Author1** 117 | * GitHub: [Anna Muzykina](https://github.com/Anna-Myzukina) 118 | * LinkedIn: [Anna Muzykina](https://www.linkedin.com/in/anna-muzykina/) 119 | * email: anna.muzykina83@gmail.com 120 | --------------------------------------------------------------------------------