namespace.md

Writerside/topics/array-method.md

@@ -16,22 +16,9 @@ uint length()
 
 ```C#
 uint A = {0,1,2}.length(); // 3
+uint B = {,}.length(); // 2
 ```
 
-<warning>
-
-Осторожно! В связи с [багом](https://github.com/UnryzeC/UjAPI/issues/12) при инициализации запятая в конце влияет на
-длину массива.
-```C#
-array<int> a = {1,}; // с запятой в конце
-print(a.length() + "\n"); // 2
-
-array<int> b = {1}; // без запятой в конце
-print(b.length() + "\n"); // 1
-```
-
-</warning>
-
 ## resize
 
 Изменяет размер массива.
@@ -42,15 +29,19 @@ void resize(uint size)
 
 `size`
 : Новый размер массива.
-: - Если значение меньше текущего размера, то массив будет обрезан.
-: - Если значение больше текущего размера, то массив будет увеличен до указанного размера.
-Добавленные элементы будут инициализированы [значениями по умолчанию](var.md#initial-value).
+: - если значение меньше текущего размера, то массив будет обрезан.
+: - если значение больше текущего размера, то массив будет увеличен до указанного размера.
+: Добавленные элементы будут инициализированы [значениями по умолчанию](var.md#initial-value).
 
 ```C#
+
 array<int> A = {0,1,2,3,4,5,6,7,8,9}.resize(4); // [0, 1, 2, 3]
 array<int> B = {0,1,2,3}.resize(10); // [0,1,2,3,0,0,0,0,0,0]
 ```
 
+> [](data-types.md#primitive) при [инициализации](var.md#init) принимают [случайное значение](var.md#primitive-default).
+> Не полагайтесь на то, что числа инициализируются нулём.
+
 ## reverse
 
 Изменяет порядок элементов в массиве.

Writerside/topics/array.md

@@ -4,7 +4,7 @@
 
 <a href="https://www.angelcode.com/angelscript/sdk/docs/manual/doc_datatypes_arrays.html"/>
 
-[Массив](https://w.wiki/9$bs) - это структуры данных, которые позволяют хранить набор элементов одного типа под одним
+Массив — структура данных, которая позволяет хранить набор элементов одного типа под одним
 именем и обращаться к ним по индексу. Индексация массивов начинается с нуля.
 
 ```C#
@@ -14,15 +14,25 @@ array<int> С(3, 1); // Массив размером три, каждый эл
 array<int> D = {5,6,7}; // Массив размером три с заданными значениями
 ```
 
-## Многомерные массивы
+## Запятая {id="comma"}
+
+При [инициализации](var.md#init) массива значениями, отделённое запятой пустое место считается значением. Это может
+привести к непредвиденным последствиям, так что будьте внимательны и всегда явно указывайте значение.
+
+```C#
+array<int> A = {,};
+uint B = A.[[[length()|array-method.md#length]]]; // 2 
+```
+
+## Многомерные массивы {id="multi"}
 
 ```C#
 array<array<int>> A;
 array<array<int>> B = {{1,2},{3,4}};
 array<array<int>> C(10, array<int>(10));
 ```
 
-## Перегрузка
+## Перегрузка {id="override"}
 
 Если функция имеет несколько перегрузок с массивами разных типов, то можно явно указать тип для выбора необходимой
 функции.

Writerside/topics/class-property.md

@@ -5,7 +5,7 @@
 [](var.md), которые относятся к членам класса, называются свойствами.
 
 > Переменные-члены класса также называют другими
-> терминами, например, полями, но в этой документации, такие переменные будут называться — свойствами.
+> терминами, например, полями, но в этой документации, такие переменные будут называться свойствами.
 
 ```C#
 class A {

Writerside/topics/namespace.md

@@ -5,21 +5,112 @@
 Механизм, который позволяет организовать код в логические группы. Позволяет избежать конфликтов имён при разрастании
 кодовой базы, особенно при использовании внешних зависимостей.
 
+Для доступа к объектам внутри пространства имён используется оператор `::`:
+
+```C#
+string A = "A";
+
+namespace N {
+    string A = "NA";   
+}
+
+void [[[main|main.md]]](){
+    print(A + N::A); //ANA
+}
+```
+
+Оператор `::` можно опустить, если объекты находятся в одном пространстве имён:
+
+```C#
+namespace N {
+    string A = "A";
+    string B = A + "B";
+}
+
+void [[[main|main.md]]](){
+    print(N::A); //AB
+}
+```
+
+## Глобальное пространство имён {id="global"}
+
+Доступ к любому объекту в глобальной области видимости можно получить с помощью оператора `::` без указания имени
+пространства имён:
+
 ```C#
-int A = 1;
-void B(){ A++; }
+string A = "A";
+
+namespace N {
+    string A = "NA";
+    string B = ::A + A;
+}
 
+void [[[main|main.md]]](){
+    print(::A); // A
+    print(::N::A); // NA
+    print(N::B); //ANA
+}
+```
+
+## Вложенные пространства имён {id="nested"}
+
+Пространства имён можно вкладывать друг в друга.
+
+```C#
 namespace NA {
-    int A = 2;
-    void B(){ A++; } // Сущности внутри пространства имён разрешаются без дополнительного синтаксиса
-    
     namespace NB {
-        int A1 = ::A; // Доступ к глобальному пространству имён
-        int A2 = NA::A; // Доступ к пространству имён NA 
+        namespace NC {
+            string A = "NC";
+        }
     }
 }
 
 void [[[main|main.md]]](){
-    int A = NA::NB::A1; // Доступ к вложенному пространству имён
+    print(NA::NB::NC::A); // NC 
 }
 ```
+
+Доступ из вложенного пространства имён к родительскому осуществляется через [глобальное пространство имён](#global):
+
+```C#
+namespace NA {
+    namespace NB {
+        string A = "NB";
+        namespace NC {
+            string A = ::NA::NB::A + "NC";
+        }
+    }
+}
+
+void [[[main|main.md]]](){
+    print(NA::NB::NC::A); // NBNC 
+}
+```
+
+## Множественное объявление {id="multi"}
+
+Пространства имён с одним именем допустимо объявлять неограниченное количество раз. Единственное условие — вложенные
+объекты не должны конфликтовать друг с другом.
+
+```C#
+namespace N {
+    string A = "A";
+}
+
+namespace N {
+    string B = "B";
+}
+
+namespace N {
+    string C = A + B + "C";
+    // string A = "A"; // Ошибка! Переменная A уже объявлена.
+}
+
+void [[[main|main.md]]](){
+    print(N::C); // ABC 
+}
+```
+
+> Этот функционал удобно использовать совместно с [](include.md) для разбиения кода в разные файлы. 
+
+