Merge 803d591466 into 90d544271e

Resolves #5129

fortran.html.markdown

@@ -30,7 +30,8 @@ program example         ! declare a program called example.
 
     ! All declarations must come before statements and expressions.
 
-    implicit none       ! prevents dynamic declaration of variables (recommended!)
+    implicit none       ! prevents dynamic declaration of variables
+    ! Recommended!
     ! Implicit none must be redeclared in every function/program/module...
 
     ! IMPORTANT - Fortran is case insensitive.
@@ -45,10 +46,14 @@ program example         ! declare a program called example.
     complex :: w = (0, 1)                         ! sqrt(-1)
     character(len=3) :: month                     ! string of 3 characters.
 
-    real :: array(6)                              ! declare an array of 6 reals.
-    real, dimension(4) :: arrayb                  ! another way to declare an array.
-    integer :: arrayc(-10:10)                     ! an array with a custom index.
-    real :: array2d(3, 2)                         ! multidimensional array.
+    ! declare an array of 6 reals.
+    real :: array(6)                                    
+    ! another way to declare an array. 
+    real, dimension(4) :: arrayb                 
+    ! an array with a custom index -10 to 10 (inclusive)
+    integer :: arrayc(-10:10)                     
+    ! A multidimensional array.
+    real :: array2d(3, 2)                         
 
     ! The '::' separators are not always necessary but are recommended.
 
@@ -77,7 +82,7 @@ program example         ! declare a program called example.
     ! Assignment & Arithmetic
     ! =======================
     
-    Z = 1                           ! assign to variable z declared above (case insensitive).
+    Z = 1                           ! assign to variable z declared above 
     j = 10 + 2 - 3
     a = 11.54/(2.3*3.1)
     b = 2**3                        ! exponentiation
@@ -86,7 +91,7 @@ program example         ! declare a program called example.
     ! ===================================
 
     ! Single-line if statement
-    if (z == a) b = 4               ! condition always need surrounding parentheses.
+    if (z == a) b = 4               ! conditions always need parentheses.
 
     if (z /= a) then                ! z not equal to a
         ! Other symbolic comparisons are < > <= >= == /=
@@ -98,13 +103,13 @@ program example         ! declare a program called example.
         b = 5                       ! execution block must be on a new line.
     else
         b = 10
-    end if                          ! end statement needs the 'if' (or can use 'endif').
+    end if                          ! end statement needs the 'if'
 
     if (.NOT. (x < c .AND. v >= a .OR. z == z)) then    ! boolean operators.
         inner: if (.TRUE.) then     ! can name if-construct.
             b = 1
         end if inner                ! then must name endif statement.
-    end if
+    endif                           ! 'endif' is equivalent to 'end if'  
 
     i = 20
     select case (i)
@@ -128,16 +133,16 @@ program example         ! declare a program called example.
         j = -1
     end select monthly
 
-    do i = 2, 10, 2             ! loops from 2 to 10 (inclusive) in increments of 2.
+    do i = 2, 10, 2             ! loops from 2 to 10 (inclusive) in steps of 2.
         innerloop: do j = 1, 3  ! loops can be named too.
             exit                ! quits the loop.
         end do innerloop
         cycle                   ! jump to next loop iteration.
     end do
 
-    ! Goto statement exists but it is heavily discouraged though.
+    ! Goto statement exists but it is heavily discouraged.
     goto 10
-    stop 1                      ! stops code immediately (returning specified condition code).
+    stop 1                      ! stops the program, returns condition code 1.
 10  j = 201                     ! this line is labeled as line 10
 
     ! Arrays
@@ -209,8 +214,12 @@ program example         ! declare a program called example.
 
     ! we can have multiple format specifications.
     print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
-    print "(3I5)", 10, 20, 30                       ! 3 repeats of integers (field width = 5).
-    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3     ! repeated grouping of formats.
+    
+    ! 3 repeats of integers (field width = 5).
+    print "(3I5)", 10, 20, 30                       
+
+    ! repeated grouping of formats.
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3     
 
     ! We can also read input from the terminal.
     read (*, *) v
@@ -225,8 +234,9 @@ program example         ! declare a program called example.
 
     ! To read a file.
     open (newunit=m, file="records.txt", status="old")
-    ! The file is referred to by a 'new unit number', an integer that the compiler
-    ! picks for you.
+    ! The file is referred to by a 'new unit number', 
+    ! an integer that the compiler picks for you.
+
     read (unit=m, fmt="(3F10.2)") a, b, c
     close (m)
 
@@ -241,7 +251,7 @@ program example         ! declare a program called example.
     call cpu_time(v)        ! sets 'v' to a time in seconds.
     k = ior(i, j)           ! bitwise OR of 2 integers.
     v = log10(x)            ! log base 10.
-    i = floor(b)            ! returns the closest integer less than or equal to x.
+    i = floor(b)            ! converts b to integer by rounding down.
     v = aimag(w)            ! imaginary part of a complex number.
 
     ! Functions & Subroutines
@@ -252,7 +262,7 @@ program example         ! declare a program called example.
 
     call routine(a, c, v)   ! subroutine call.
 
-    ! A function takes a list of input parameters and returns a single value.
+    ! A function takes several input parameters and returns a single value.
     ! However the input parameters may still be modified and side effects
     ! executed.
 
@@ -261,21 +271,22 @@ program example         ! declare a program called example.
     ! Function calls can also be evoked within expressions.
     print *, func2(3, 2, k)
 
-    ! A pure function is a function that doesn't modify its input parameters
-    ! or cause any side-effects.
+    ! A pure function is a function that doesn't modify its input 
+    ! parameters or cause any side-effects.
     m = func3(3, 2, k)
 
-contains                    ! Zone for defining sub-programs internal to the program.
+contains                    ! Start defining the program's internal procedures:
 
     ! Fortran has a couple of slightly different ways to define functions.
 
     integer function func(a, b, c)      ! a function returning an integer value.
-        ! implicit none                 ! subvariable fields can no longer declare implicit none
-        integer, intent(in) :: a, b, c  ! type of input parameters defined inside the function.
+        ! implicit none                 ! - no longer used in subvariable fields
+        integer, intent(in) :: a, b, c  ! type of input parameters
+        ! the return variable defaults to the function name.
 
         if (a >= 2) then
-            func = a + b + c            ! the return variable defaults to the function name.
-            return                      ! can return the current value from the function at any time.
+            func = a + b + c            
+            return                      ! returns the current value at 'func'
         end if
         func = a + c
 
@@ -286,17 +297,20 @@ contains                    ! Zone for defining sub-programs internal to the pro
         integer, intent(in) :: a, b     ! can declare and enforce that variables
         !are not modified by the function.
         integer, intent(inout) :: c
-        integer :: f                    ! function return type declared inside the function.
-        integer :: cnt = 0              ! GOTCHA - initialisation implies variable is
-        !saved between function calls.
+        integer :: f                    
+        ! function return type declared inside the function.
+        integer :: cnt = 0               ! GOTCHA -         
+        ! assigning a value at initalization 
+        ! implies that the variable is
+        ! saved between function calls.
 
         f = a + b - c
-        c = 4                           ! altering the value of an input variable.
+        c = 4                           ! changing value of input variable c.
         cnt = cnt + 1                   ! count number of function calls.
 
     end function func2
 
-    pure function func3(a, b, c)        ! a pure function can have no side-effects.
+    pure function func3(a, b, c)        ! a pure function has no side-effects.
         integer, intent(in) :: a, b, c
         integer :: func3
 
@@ -304,6 +318,8 @@ contains                    ! Zone for defining sub-programs internal to the pro
 
     end function func3
     
+    ! a subroutine does not return anything, 
+    ! but can change the value of arguments.
     subroutine routine(d, e, f)
         real, intent(inout) :: f
         real, intent(in) :: d, e
@@ -312,7 +328,8 @@ contains                    ! Zone for defining sub-programs internal to the pro
 
     end subroutine routine
 
-end program example                     ! End of Program Definition -----------------------
+end program example                     
+! End of Program Definition -----------------------
 
 ! Functions and Subroutines declared externally to the program listing need
 ! to be declared to the program using an Interface declaration (even if they
@@ -350,7 +367,8 @@ module fruity
     use fruit, only: apple, pear    ! use apple and pear from fruit module.
     implicit none                   ! comes after module imports.
 
-    private                         ! make things private to the module (default is public).
+    ! By default all module data and functions will be public
+    private                         ! Instead set default to private 
     ! Declare some variables/functions explicitly public.
     public :: apple, mycar, create_mycar
     ! Declare some variables/functions private to the module (redundant here).

java.html.markdown

@@ -44,6 +44,9 @@ Multi-line comments look like this.
 import java.util.ArrayList;
 // Import all classes inside of java.security package
 import java.security.*;
+// Java to illustrate calling of static members and methods without calling classname
+import static java.lang.Math.*;
+import static java.lang.System.*;
 
 public class LearnJava {
 
@@ -211,9 +214,21 @@ public class LearnJava {
         // Prefer the String constructor when you need an exact value.
         BigDecimal tenCents = new BigDecimal("0.1");
 
+        // Type inference with 'var'
+        var x = 100; // int
+        var y = 1.90; // double
+        var z = 'a'; // char
+        var p = "tanu"; // String
+        var q = false; // boolean
+
         // Strings
         String fooString = "My String Is Here!";
 
+        // Text blocks
+        vat textBlock = """
+                        This is a <Text Block> in Java 
+                        """;
+
         // \n is an escaped character that starts a new line
         String barString = "Printing on a new line?\nNo Problem!";
         // \t is an escaped character that adds a tab character
@@ -459,6 +474,8 @@ public class LearnJava {
             System.out.println(br.readLine());
             // In Java 7, the resource will always be closed, even if it throws
             // an Exception.
+        } catch (IOException | SQLException ex) {
+            // Java 7+ Multi catch block handle both exceptions
         } catch (Exception ex) {
             //The resource will be closed before the catch statement executes.
             System.out.println("readLine() failed.");
@@ -852,6 +869,12 @@ public abstract class Mammal()
     }
 }
 
+// Java Records are a concise way to define immutable data carrier classes, automatically
+// generating boilerplate code like constructors, equals(), hashCode()and toString().
+// This automatically creates an immutable class Person with fields name and age.
+public record Person(String name, int age) {}
+Person p = new Person("Alice", 30);
+
 // Enum Type
 //
 // An enum type is a special data type that enables for a variable to be a set

jinja.html.markdown

@@ -11,6 +11,7 @@ Jinja is a fast, expressive, and extensible templating engine for Python
 applications.
 
 Jinja includes a lot of functionalities, such as:
+
 - Template inheritance and inclusion;
 - Defining and importing macros within templates;
 - Security mechanisms to prevent XSS attacks;

lean4.html.markdown

@@ -256,7 +256,7 @@ We now state Collatz conjecture. The proof is left as an exercise to the reader.
 def collatz_next (n : Nat) : Nat :=
   if n % 2 = 0 then n / 2 else 3 * n + 1
 
-def iter (k : Nat) (f: Nat → Nat) :=
+def iter (k : Nat) (f : Nat → Nat) :=
   match k with
   | Nat.zero => fun x => x
   | Nat.succ k' => fun x => f (iter k' f x)

opengl.html.markdown

@@ -161,7 +161,7 @@ sf::Event event{ };
 // ...
 ```
 
-Ofcourse we have to create the vertex and fragment shader before we can load them,
+Of course we have to create the vertex and fragment shader before we can load them,
 so lets create two basic shaders.
 
 **Vertex Shader**
@@ -342,7 +342,7 @@ void main() {
 We define a new input variable ```color``` which represents our color data, this data
 is passed on to ```fColor```, which is an output variable of our vertex shader and
 becomes an input variable for our fragment shader.
-It is imporatant that variables passed between shaders have the exact same name
+It is important that variables passed between shaders have the exact same name
 and type.
 
 ## Handling VBO's
@@ -501,7 +501,7 @@ glBindTexture(GL_TEXTURE_2D, 0);
 glDeleteTextures(1, &texture);
 ```
 
-Ofcourse there are more texture formats than only 2D textures,
+Of course there are more texture formats than only 2D textures,
 You can find further information on parameters here:
 [glBindTexture - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBindTexture.xhtml)<br>
 [glTexImage2D - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexImage2D.xhtml)<br>
@@ -574,7 +574,7 @@ in vec2 fTexCoords;
 out vec4 outColor;
 
 void main() {
-    // texture() loads the current texure data at the specified texture coords,
+    // texture() loads the current texture data at the specified texture coords,
     // then we can simply multiply them by our color.
     outColor = texture(tex, fTexCoords) * vec4(fColor, 1.0);
 }
@@ -685,7 +685,7 @@ Geometry shaders are inbetween the vertex and the fragment shader.
 
 layout(location = 0) in vec3 position;
 layout(location = 1) in vec3 color;
-// Create an output interface block passed to the next shadaer stage.
+// Create an output interface block passed to the next shader stage.
 // Interface blocks can be used to structure data passed between shaders.
 out VS_OUT {
     vec3 color;

ru-ru/dart-ru.html.markdown

@@ -0,0 +1,721 @@
+---
+language: dart
+filename: learndart-ru.dart
+contributors:
+  - ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+  - ["Vince Ramces Oliveros", "https://github.com/ram231"]
+translators:
+    - ["nikaose", "https://github.com/nikaose"]
+lang: ru-ru
+---
+
+**Dart** это однопоточный язык программирования общего назначения.
+Он многое заимствует из других основных языков.
+Он поддерживает потоки, фьючерсы (известные как промисы в JavaScript), дженерики, первоклассные функции (замыкания) и проверку статического типа.
+Dart может работать на любой платформе, включая веб-интерфейс, интерфейс командной строки, десктопные, мобильные устройства и устройства IoT.
+
+```dart
+import "dart:collection";
+import "dart:math" as math;
+
+/// Добро пожаловать в «Изучите Dart за 15 минут». http://dart.dev/
+/// Это исполняемый учебник. Вы можете запустить его с помощью Dart или
+/// Попробуйте Dart! если вы скопируете/вставите его сюда: http://dartpad.dev/
+/// Вы также можете запустить Flutter в DartPad, щелкнув `< > New Pad ` и выбрав Flutter.
+
+
+/// В Dart все является объектом.
+/// Каждое объявление объекта является экземпляром Null и
+/// Null также является объектом.
+
+
+/// 3 типа комментариев в Dart
+// Однострочный комментарий
+/**
+* Многострочный комментарий
+* Можно прокомментировать несколько строк
+*/
+/// Комментарий к документации кода
+/// Он использует синтаксис markdown для создания документации кода при создании API.
+/// Комментарий к документации кода — рекомендуемый выбор при документировании API, классов и методов.
+
+/// 4 типа объявления переменных.
+/// Константы — это переменные, которые являются неизменяемыми и не могут быть изменены.
+/// `const` в Dart должен использовать объявление имени SCREAMING_SNAKE_CASE.
+const CONSTANT_VALUE = "Я НЕ МОГУ ПОМЕНЯТЬ";
+CONSTANT_VALUE = "Я сделал?"; // Ошибка
+/// Final — это еще одно объявление переменной, которое нельзя изменить после создания экземпляра. Обычно используется в классах и функциях.
+/// `final` может быть объявлен в pascalCase.
+final finalValue = "значение не может быть изменено после создания экземпляра";
+finalValue = "Кажется, нет"; // Ошибка
+
+/// `var` — это еще одно объявление переменной, которая является изменяемой и может изменять свое значение. Dart выведет типы и не изменит тип данных.
+var mutableValue = "Переменная строка";
+mutableValue = "Так работает";
+mutableValue = false; // Ошибка.
+
+/// `dynamic` — это еще одно объявление переменной, в котором тип не оценивается при проверке статического типа Dart.
+/// Он может изменить свое значение и тип данных.
+/// Некоторые дартисты используют динамический подход с осторожностью, поскольку он не может отслеживать тип данных. так что используйте его на свой страх и риск
+dynamic dynamicValue = "Я строка";
+dynamicValue = false; // false
+
+
+/// Функции могут быть объявлены в глобальном пространстве.
+/// Объявление функции и объявление метода выглядят одинаково.
+/// Объявления функции могут быть вложенными.
+/// Декларация имеет форму name() {} или name() => singleLineExpression;
+/// Объявление функции большой стрелкой может быть неявным или явным возвратом результата выражения.
+/// Dart выполнит функцию `main()` в любом месте проекта dart.
+///
+example1() {
+  nested1() {
+    nested2() => print("Example1 nested 1 nested 2");
+    nested2();
+  }
+
+  nested1();
+}
+
+/// Анонимные функции не включают имя
+example2() {
+  //// Явный тип возвращаемого значения.
+  nested1(void Function() fn) {
+    fn();
+  }
+  nested1(() => print("Example2 nested 1"));
+}
+
+/// Когда объявлен параметр функции, объявление может включать количество параметров,
+/// которые принимает функция, путем явного указания имен принимаемых ею параметров.
+example3() {
+  planA(fn(String informSomething)) {
+    fn("Example3 plan A");
+  }
+  planB(fn) {
+    // Или не объявляйте количество параметров.
+    fn("Example3 plan B");
+  }
+
+  planA((s) => print(s));
+  planB((s) => print(s));
+}
+
+/// Функции имеют замыкающий доступ к внешним переменным.
+/// Dart выводит типы, когда переменная имеет какое-либо значение.
+/// В этом примере Dart знает, что эта переменная является строкой.
+var example4Something = "Example4 nested 1";
+example4() {
+  nested1(fn(informSomething)) {
+    fn(example4Something);
+  }
+
+  nested1((s) => print(s));
+}
+
+/// Объявление класса с методом sayIt, который также имеет закрывающий доступ
+/// к внешней переменной, как если бы это была функция, как было показано ранее.
+var example5method = "Example5 sayIt";
+
+class Example5Class {
+  sayIt() {
+    print(example5method);
+  }
+}
+
+example5() {
+  /// Создайте анонимный экземпляр класса Example5Class и вызовите для него метод sayIt
+  /// Ключевое слово `new` в Dart не является обязательным..
+  new Example5Class().sayIt();
+}
+
+/// Объявление класса принимает форму имени класса. { [classBody] }.
+/// Где classBody может включать методы и переменные экземпляра, 
+/// а также методы и переменные класса.
+class Example6Class {
+  var instanceVariable = "Example6 переменная экземпляра";
+  sayIt() {
+    print(instanceVariable);
+  }
+}
+
+example6() {
+   Example6Class().sayIt();
+}
+
+/// Методы и переменные класса объявляются с помощью «статических» терминов.
+class Example7Class {
+  static var classVariable = "Example7 переменная класса";
+  static sayItFromClass() {
+    print(classVariable);
+  }
+
+  sayItFromInstance() {
+    print(classVariable);
+  }
+}
+
+example7() {
+  Example7Class.sayItFromClass();
+  new Example7Class().sayItFromInstance();
+}
+
+/// Dart поддерживает дженерики.
+/// Дженерики относятся к технике написания кода для класса.
+/// без указания типов данных, с которыми работает класс.
+/// Источник: https://stackoverflow.com/questions/4560890/what-are-generics-in-c
+
+/// Тип `T` относится к любому типу, экземпляр которого был создан.
+/// вы можете вызывать все, что захотите.
+/// Программисты используют это соглашение в следующих случаях:
+/// T - Тип (используется для типов классов и примитивов)
+/// E - Элемент (используется для списка, набора или итерации)
+/// K,V - Ключевое значение (используется для Map)
+class GenericExample<T>{
+  void printType(){
+    print("$T")
+  }
+  // методы также могут иметь дженерики
+  genericMethod<M>(){
+    print("class:$T, method: $M");
+  }
+}
+
+
+/// Список похож на массивы, но список является дочерним элементом Iterable<E>.
+/// Поэтому Maps, List, LinkedList являются дочерними элементами Iterable<E>, 
+/// чтобы иметь возможность зацикливаться с использованием ключевого слова `for`
+/// Важные вещи, которые следует помнить:
+/// () - Iterable<E>
+/// [] - List<E>
+/// {} - Map<K,V>
+
+
+/// Список — это здорово, но есть ограничение на то, каким может быть список.
+/// outside of function/method bodies. List on the outer scope of class
+/// вне тела функции/метода. Список во внешней области класса или
+/// вне класса должен быть постоянным. Строки и числа используются по умолчанию.
+/// А вот массивы и карты — нет. Их можно сделать постоянными,
+/// объявив их "const". Что-то похожее на Object.freeze() в Javascript.
+const example8List = ["Example8 const array"];
+const  example8Map = {"someKey": "Example8 const map"};
+/// Объявите List или Map как объекты.
+ List<String> explicitList = new List<String>();
+ Map<String,dynamic> explicitMaps = new Map<String,dynamic>();
+
+ explicitList.add("НекоторыйМассив");
+example8() {
+  print(example8Map["какой-тоКлюч"]);
+  print(explicitList[0]);
+}
+
+/// Присвоение списка одной переменной другой не будет тем же результатом.
+/// Потому что dart передает ссылку по значению.
+/// Поэтому, когда вы назначаете существующий список новой переменной.
+/// Вместо списка он становится итерируемым
+var iterableExplicitList = explicitList;
+print(iterableExplicitList) // ("НекоторыйМассив"); "[]" становится "()"
+var newExplicitLists = explicitList.toList() // Преобразует Iterable<E> в List<E>
+
+/// Циклы в Dart имеют форму стандартных циклов for () {} или while () {},
+/// немного более современный for (.. in ..) {} или функциональные обратные вызовы 
+/// со многими поддерживаемыми функциями, начиная с forEach,map иwhere.
+var example9Array = const ["a", "b"];
+example9() {
+  for (int i = 0; i < example9Array.length; i++) {
+    print("Example9 цикл цикл '${example9Array[i]}'");
+  }
+  var i = 0;
+  while (i < example9Array.length) {
+    print("Example9 цикл while '${example9Array[i]}'");
+    i++;
+  }
+  for (final e in example9Array) {
+    print("Example9 цикл for-in '${e}'");
+  }
+
+  example9Array.forEach((e) => print("Example9 цикл forEach '${e}'"));
+
+}
+
+/// Чтобы перебрать символы строки или извлечь подстроку.
+var example10String = "ab";
+example10() {
+  for (var i = 0; i < example10String.length; i++) {
+    print("Example10 цикл строковых символов '${example10String[i]}'");
+  }
+  for (var i = 0; i < example10String.length; i++) {
+    print("Example10 цикл извлечения '${example10String.substring(i, i + 1)}'");
+  }
+}
+
+/// `int`, `double` и `num` — три поддерживаемых числовых формата.
+/// `num` может быть либо `int`, либо `double`.
+/// `int` и `double` являются дочерними элементами типа `num`
+example11() {
+  var i = 1 + 320, d = 3.2 + 0.01;
+  final num myFinalNumDouble = 2.2;
+  final num myFinalNumInt = 2;
+  final int myFinalInt = 1;
+  final double myFinalDouble = 0.1;
+  num myNumDouble = 2.2;
+  num myNumInt = 2;
+  int myInt = 1;
+  double myDouble = 0; // Dart добавит десятичный префикс и станет 0.0;
+  myNumDouble = myFinalInt; // действительный
+  myNumDouble = myFinalDouble; // действительный
+  myNumDouble = myFinalNumInt; // действительный
+
+  myNumInt = myFinalInt; // действительный
+  myNumInt = myFinalDouble; // действительный
+  myNumInt = myFinalNumDouble; // действительный
+
+  myInt = myNumDouble; // ошибка
+  myInt = myFinalDouble; // ошибка
+  myInt = myFinalNumInt; // действительный
+
+  myDouble = myFinalInt; // ошибка
+  myDouble = myFinalNumInt; // ошибка
+  myDouble = myFinalNumDouble; // действительный
+
+  print("Example11 int ${i}");
+  print("Example11 double ${d}");
+
+}
+
+/// DateTime обеспечивает арифметику даты и времени.
+example12() {
+  var now = new DateTime.now();
+  print("Example12 сейчас '${now}'");
+  now = now.add(new Duration(days: 1));
+  print("Example12 завтра '${now}'");
+}
+
+/// Поддерживаются регулярные выражения.
+example13() {
+  var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$");
+  match(s) {
+    if (re.hasMatch(s)) {
+      print("Example13 совпадения с регулярными выражениями '${s}'");
+    } else {
+      print("Example13 регулярное выражение не соответствует '${s}'");
+    }
+  }
+
+  match(s1);
+  match(s2);
+}
+
+/// Логические выражения поддерживают неявные преобразования и динамический тип.
+example14() {
+  var a = true;
+  if (a) {
+    print("true, a равно $a");
+  }
+  a = false;
+  if (a) {
+    print("true, a равно $a"); 
+  } else {
+    print("false, a равно $a"); /// сработает здесь
+  }
+
+  /// динамический типизированный null не может быть преобразован в bool
+  var b; /// b — динамический тип
+  b = "abc";
+  try {
+    if (b) {
+      print("true, b равно $b");
+    } else {
+      print("false, b равно $b");
+    }
+  } catch (e) {
+    print("error, b равно $b"); /// это можно было запустить, но возникает ошибка
+  }
+  b = null; 
+  if (b) { /// Неудачное утверждение: логическое выражение не должно быть нулевым)
+    print("true, b равно $b");
+  } else {
+    print("false, b равно $b"); 
+  }
+
+  /// статически типизированный null не может быть преобразован в bool
+  var c = "abc";
+  c = null;
+  /// компиляция не удалась
+  /// if (c) {
+  ///   print("true, c равно $c");
+  /// } else {
+  ///   print("false, c равно $c");
+  /// }
+}
+
+/// try/catch/finally и throw используются для обработки исключений.
+/// throw принимает любой объект в качестве параметра;
+example15() {
+  try {
+    try {
+      throw "Какая-то неожиданная ошибка.";
+    } catch (e) {
+      print("Example15 исключение: '${e}'");
+      throw e; /// Re-throw
+    }
+  } catch (e) {
+    print("Example15 catch exception being re-thrown: '${e}'");
+  } finally {
+    print("Example15 Still run finally");
+  }
+}
+
+/// Чтобы быть эффективным при динамическом создании длинной строки, 
+/// используйте StringBuffer. Или вы можете присоединиться к массиву строк.
+example16() {
+  var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e;
+  for (e in a) {
+    sb.write(e);
+  }
+  print("Example16 динамическая строка, созданная с помощью "
+      "StringBuffer '${sb.toString()}'");
+  print("Example16 объединить массив строк '${a.join()}'");
+}
+
+/// Строки можно объединить, просто разместив список строк рядом друг с другом
+/// без необходимости использования дополнительных операторов.
+
+example17() {
+  print("Example17 "
+      "concatenate "
+      "strings "
+      "just like that");
+}
+
+/// Строки имеют одинарные или двойные кавычки для разделителей, 
+/// между которыми нет фактической разницы. Данная гибкость может быть полезной,
+/// чтобы избежать необходимости экранировать содержимое, соответствующее используемому разделителю.
+/// Например, двойные кавычки атрибутов HTML, если строка содержит содержимое HTML.
+example18() {
+  print('Example18 <a href="etc">'
+      "Don't can't I'm Etc"
+      '</a>');
+}
+
+/// Строки с тройными одинарными или тройными двойными кавычками занимают несколько строк
+/// и включают разделители строк.
+example19() {
+  print('''Example19 <a href="etc">
+Example19 Don't can't I'm Etc
+Example19 </a>''');
+}
+
+/// Строки имеют удобную функцию интерполяции с помощью символа $.
+/// При использовании $ {[expression] } возврат выражения интерполируется.
+/// $ за которым следует имя переменной, интерполирует содержимое этой переменной.
+/// $ можно экранировать следующим образом: \$, чтобы вместо этого просто добавить его в строку.
+example20() {
+  var s1 = "'\${s}'", s2 = "'\$s'";
+  print("Example20 \$ интерполяция ${s1} или $s2 работает.");
+}
+
+/// Необязательные типы позволяют аннотировать API и приходят на помощь IDE,
+/// чтобы IDE могли лучше выполнять рефакторинг, автозаполнение и проверку на наличие ошибок.
+/// До сих пор мы не объявляли никаких типов, и программы работали нормально.
+/// Фактически, типы игнорируются во время выполнения. Типы могут даже быть неправильными,
+/// но программа все равно будет иметь преимущество сомнения и будет работать так,
+/// как будто типы не имеют значения.
+/// Существует параметр времени выполнения, который проверяет наличие ошибок типа.
+/// Это проверенный режим, который считается полезным во время разработки,
+/// но который также медленнее из-за дополнительной проверки и, 
+/// следовательно, его избегают во время выполнения развертывания.
+class Example21 {
+  List<String> _names;
+  Example21() {
+    _names = ["a", "b"];
+  }
+  List<String> get names => _names;
+  set names(List<String> list) {
+    _names = list;
+  }
+
+  int get length => _names.length;
+  void add(String name) {
+    _names.add(name);
+  }
+}
+
+void example21() {
+  Example21 o = new Example21();
+  o.add("c");
+  print("Example21 имена '${o.names}' и длина '${o.length}'");
+  o.names = ["d", "e"];
+  print("Example21 имена '${o.names}' и длина '${o.length}'");
+}
+
+/// Наследование классов принимает форму имени класса расширяет AnotherClassName {}.
+class Example22A {
+  var _name = "Some Name!";
+  get name => _name;
+}
+
+class Example22B extends Example22A {}
+
+example22() {
+  var o = new Example22B();
+  print("Example22 наследование класса '${o.name}'");
+}
+
+/// Миксин классов также доступен и принимает форму имени класса,
+/// расширяющего SomeClass с AnotherClassName {}. 
+/// Необходимо расширить какой-то класс, чтобы можно было добавить другой.
+/// Класс шаблона миксина на данный момент не может иметь конструктор.
+/// Миксин в основном используется для совместного использования методов с удаленными классами,
+/// поэтому единое наследование не мешает повторному использованию кода.
+/// Миксины следуют за оператором «with» во время объявления класса.
+class Example23A {}
+
+class Example23Utils {
+  addTwo(n1, n2) {
+    return n1 + n2;
+  }
+}
+
+class Example23B extends Example23A with Example23Utils {
+  addThree(n1, n2, n3) {
+    return addTwo(n1, n2) + n3;
+  }
+}
+
+example23() {
+  var o = new Example23B(), r1 = o.addThree(1, 2, 3), r2 = o.addTwo(1, 2);
+  print("Example23 addThree(1, 2, 3) приводит к результату '${r1}'");
+  print("Example23 addTwo(1, 2) приводит к результату '${r2}'");
+}
+
+/// Метод конструктора класса использует то же имя класса и
+/// принимает форму SomeClass() : super() {}, где часть ": super()" является необязательной и
+/// используется для делегирования константных параметров суперуправлению-родительский конструктор.
+class Example24A {
+  var _value;
+  Example24A({value: "некотороеЗначение"}) {
+    _value = value;
+  }
+  get value => _value;
+}
+
+class Example24B extends Example24A {
+  Example24B({value: "некотороеДругоеЗначение"}) : super(value: value);
+}
+
+example24() {
+  var o1 = new Example24B(), o2 = new Example24B(value: "evenMore");
+  print("Example24 вызов super во время конструктора '${o1.value}'");
+  print("Example24 вызов super во время конструктора '${o2.value}'");
+}
+
+/// Существует ярлык для установки параметров конструктора в случае более простых классов.
+/// Просто используйте префикс this.parameterName, и он установит параметр в переменную экземпляра с тем же именем.
+class Example25 {
+  var value, anotherValue;
+  Example25({this.value, this.anotherValue});
+}
+
+example25() {
+  var o = new Example25(value: "a", anotherValue: "b");
+  print("Example25 ярлык для конструктора '${o.value}' и "
+      "'${o.anotherValue}'");
+}
+
+/// Именованные параметры доступны, если они объявлены между {}.
+/// Порядок параметров может быть необязательным, если они объявлены между {}.
+/// Параметры можно сделать необязательными, если они объявлены между [].
+example26() {
+  var _name, _surname, _email;
+  setConfig1({name, surname}) {
+    _name = name;
+    _surname = surname;
+  }
+
+  setConfig2(name, [surname, email]) {
+    _name = name;
+    _surname = surname;
+    _email = email;
+  }
+
+  setConfig1(surname: "Doe", name: "John");
+  print("Example26 имя '${_name}', фамилия '${_surname}', "
+      "email '${_email}'");
+  setConfig2("Mary", "Jane");
+  print("Example26 имя '${_name}', фамилия '${_surname}', "
+      "email '${_email}'");
+}
+
+/// Переменные, объявленные с помощью Final, можно установить только один раз.
+/// В случае классов конечные переменные экземпляра могут быть установлены через постоянный параметр конструктора.
+class Example27 {
+  final color1, color2;
+  /// Немного гибкости для установки конечных переменных экземпляра с синтаксисом,
+  /// следующим за:
+  Example27({this.color1, color2}) : color2 = color2;
+}
+
+example27() {
+  final color = "оранжевый", o = new Example27(color1: "сиреневый", color2: "белый");
+  print("Example27 цвет '${color}'");
+  print("Example27 цвет '${o.color1}' и '${o.color2}'");
+}
+
+/// Чтобы импортировать библиотеку, используйте import "libraryPath" или,
+/// если это основная библиотека, импортируйте "dart:libraryName".
+/// Существует также управление пакетами «pub» со своим собственным соглашением
+/// об импорте «package:packageName». См. импорт «dart:collection»; в начале.
+/// Импорт должен предшествовать другим объявлениям кода. IterableBase происходит из dart:collection.
+class Example28 extends IterableBase {
+  var names;
+  Example28() {
+    names = ["a", "b"];
+  }
+  get iterator => names.iterator;
+}
+
+example28() {
+  var o = new Example28();
+  o.forEach((name) => print("Example28 '${name}'"));
+}
+
+/// Для потока управления у нас есть:
+/// * стандартный переключатель с операторами must Break
+/// * if-else if-else и тернарный оператор ..?..:..
+/// * замыкания и анонимные функции
+/// * операторы break, continue и return
+example29() {
+  var v = true ? 30 : 60;
+  switch (v) {
+    case 30:
+      print("Example29 оператор switch");
+      break;
+  }
+  if (v < 30) {
+  } else if (v > 30) {
+  } else {
+    print("Example29 оператор if-else");
+  }
+  callItForMe(fn()) {
+    return fn();
+  }
+
+  rand() {
+    v = new DM.Random().nextInt(50);
+    return v;
+  }
+
+  while (true) {
+    print("Example29 callItForMe(rand) '${callItForMe(rand)}'");
+    if (v != 30) {
+      break;
+    } else {
+      continue;
+    }
+    /// Никогда сюда не попадет.
+  }
+}
+
+/// Парсим int, преобразуем double в int или просто сохраняем целое число при
+/// делении чисел с помощью операции ~/. Давайте тоже поиграем в угадайку.
+example30() {
+  var gn,
+      tooHigh = false,
+      n,
+      n2 = (2.0).toInt(),
+      top = int.parse("123") ~/ n2,
+      bottom = 0;
+  top = top ~/ 6;
+  gn = new DM.Random().nextInt(top + 1); /// +1, потому что nextInt top является эксклюзивным
+  print("Example30 Угадайте число от 0 до ${top}");
+  guessNumber(i) {
+    if (n == gn) {
+      print("Example30 Угадал! Число ${gn}");
+    } else {
+      tooHigh = n > gn;
+      print("Example30 Число ${n} слишком "
+          "${tooHigh ? 'большое' : 'маленькое'}. Попробуйте еще раз");
+    }
+    return n == gn;
+  }
+
+  n = (top - bottom) ~/ 2;
+  while (!guessNumber(n)) {
+    if (tooHigh) {
+      top = n - 1;
+    } else {
+      bottom = n + 1;
+    }
+    n = bottom + ((top - bottom) ~/ 2);
+  }
+}
+
+/// Необязательный позиционный параметр:
+/// параметр будет указан в квадратных скобках [ ] & параметр в квадратных скобках является необязательным.
+example31() {
+    findVolume31(int length, int breath, [int height]) {
+      print('length = $length, breath = $breath, height = $height');
+    }
+
+    findVolume31(10,20,30); //действительный
+    findVolume31(10,20); //также действителен
+}
+
+/// Необязательный именованный параметр: 
+/// параметр будет указан в фигурных скобках { } 
+/// Параметр в фигурных скобках не является обязательным. 
+/// необходимо использовать имя параметра, чтобы присвоить значение, 
+/// которое разделено двоеточием: в фигурных скобках порядок параметров не имеет значения,
+/// эти параметры типа помогают нам избежать путаницы при передаче значения для функции,
+/// которая имеет много параметров.
+example32() {
+    findVolume32(int length, int breath, {int height}) {
+    print('length = $length, breath = $breath, height = $height');
+    }
+
+    findVolume32(10,20,height:30);//действительно, и мы видим, что здесь упоминается имя параметра.
+    findVolume32(10,20);//также действителен
+}
+
+/// Необязательный параметр по умолчанию: 
+/// то же, что и необязательный именованный параметр, кроме того,
+/// мы можем назначить этому параметру значение по умолчанию. 
+/// это означает, что значение не передается, будет принято значение по умолчанию.
+example33() {
+    findVolume33(int length, int breath, {int height=10}) {
+     print('length = $length, breath = $breath, height = $height');
+    }
+
+    findVolume33(10,20,height:30);//действительный
+    findVolume33(10,20);//действительный
+}
+
+/// В Dart также добавлена ​​такая функция, как операторы, поддерживающие Null.
+var isBool = true;
+var hasString = isBool ?? "default String";
+
+/// Программы имеют только одну точку входа в главную функцию.
+/// Ожидается, что во внешней области ничего не будет выполнено до того,
+/// как программа начнет работать с тем, что находится в ее основной функции.
+/// Это помогает ускорить загрузку и даже ленивую загрузку именно того, с чем программа должна запускаться.
+main() {
+  print("Изучите Dart за 15 минут!");
+  [
+    example1, example2, example3, example4, example5,
+    example6, example7, example8, example9, example10,
+    example11, example12, example13, example14, example15,
+    example16, example17, example18, example19, example20,
+    example21, example22, example23, example24, example25,
+    example26, example27, example28, example29,
+    example30 // Добавление этого комментария не позволяет средству форматирования dart помещать все элементы на новую строку.
+  ].forEach((ef) => ef());
+}
+```
+
+## Дальнейшее чтение
+
+У Dart есть обширный веб-сайт. Он охватывает справочник по API, учебные пособия, статьи и многое другое, включая
+полезный DartPad (облачная площадка для программирования Dart).
+[https://dart.dev/](https://dart.dev)
+[https://dartpad.dev/](https://dartpad.dev)