declaration

Ссылка на источник.
Анонимные структуры — используются для объединения данных без явного создания типа. В примере, написанном ниже, создается структура с двумя полями x и name, которые получают значения «12» и «foo» соответственно:

class Main {
  static public function main() {
    var myStructure = { x: 12, name: "foo"};
  }
}

class Main {

static public function main() {

var myStructure = { x: 12, name: "foo"};

}

Общие правила синтаксиса:

Структура заключается в фигурные скобки {};
Пары ключ-значение разделяются запятой;
Между ключом и значением ставится двоеточие;
Значением может быть любое выражение на языке Haxe.

Четвертое правило говорит о том, что структуры могут быть вложенными и сложными, например:

var user = {
  name : "Nicolas",
  age : 32,
  pos : [
    { x : 0, y : 0 },
    { x : 1, y : -1 }
  ],
};

var user = {

name : "Nicolas",

age : 32,

pos : [

{ x : 0, y : 0 },

{ x : 1, y : -1 }

};

Поля структур могут быть получены, как и классы, используя точку (.), как в примере ниже:

// получим значение поля "name", которое имеет значение - "Nicolas"
user.name;
// установим значение поля "age" равным 33
user.age = 33;

// получим значение поля "name", которое имеет значение - "Nicolas"

user.name;

// установим значение поля "age" равным 33

user.age = 33;

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

var target = { "name": "Butterfly", "version": "0.3" }; 
var fields = Reflect.fields(target);
for (field in fields) {
  var value = Reflect.getProperty(target, field);
  trace('${field} => ${value}');
}

var target = { "name": "Butterfly", "version": "0.3" };

var fields = Reflect.fields(target);

for (field in fields) {

var value = Reflect.getProperty(target, field);

trace('${field} => ${value}');

}

Вот что будет выведено:
name => Butterfly version => 0.3

Стоит отметить, что использование анонимных структур не подрывает, существующую в Haxe, систему типизации. Компилятор гарантирует, что доступны только существующие поля. Это означает что следующая программа не будет скомпилирована.

class Test {
  static public function main() {
    var point = { x: 0.0, y: 12.0 };
    // { y : Float, x : Float } не существует поля z
    point.z;
  }
}

class Test {

static public function main() {

var point = { x: 0.0, y: 12.0 };

// { y : Float, x : Float } не существует поля z

point.z;

}

Полученная ошибка свидетельствует о том, что компилятор знает как был объявлен тип point : это структура с полями x и y типа Float. Поскольку поля z не существует, то доступ будет запрещен. Тип point известен благодаря определению типов. Именно ему мы должны сказать спасибо за то, что у нас нет необходимости каждый раз явно определять типы. Однако, если point является полем, то явное определение типов обязательно:

class Path {
    var start : { x : Int, y : Int };
    var target : { x : Int, y : Int };
    var current : { x : Int, y : Int };
}

class Path {

var start : { x : Int, y : Int };

var target : { x : Int, y : Int };

var current : { x : Int, y : Int };

}

Что бы избежать лишнего декларирования типов, особенно для более сложных структур, советуют использовать typedef:

typedef Point = { x : Int, y : Int }

class Path {
    var start : Point;
    var target : Point;
    var current : Point;
}

typedef Point = { x : Int, y : Int }

class Path {

var start : Point;

var target : Point;

var current : Point;

}

Оригинал статьи.
Элементы массива разделяются запятыми , и заключаются в квадратные скобки []. Пустыми квадратными скобками [] объявляется пустой массив, в то время как [1, 2, 3] инициализирует массив с тремя элементами $1$, $2$, $3$.

var arr = new Array(); //Объявление пустого массива
var arr1 = [1, 2, 3]; //Инициализация массива с элементами 1, 2, 3

1 2	var arr = new Array(); //Объявление пустого массива var arr1 = [1, 2, 3]; //Инициализация массива с элементами 1, 2, 3

Так же, как и в других языках программирования, в haxe многомерные массивы создаются на основе одномерных, у которых элементы являются массивами.

class Main 
{
	
	static function main() 
	{
		var arr = [[1, 2], [4, 5, 5, 6], [7, 8, 9]]; //Инициализация многомерного массива
		for (i in 0...arr.length) {
			for (j in 0...arr[i].length) {
				trace("arr["+i+", "+j+"]=" + arr[i][j]); //Вывод каждого j-го элемента каждого i-го массива 
			}
			Sys.print("\n");
		}
        Sys.exit(0);
	}
	
}

class Main

{

static function main()

{

var arr = [[1, 2], [4, 5, 5, 6], [7, 8, 9]]; //Инициализация многомерного массива

for (i in 0...arr.length) {

for (j in 0...arr[i].length) {

trace("arr["+i+", "+j+"]=" + arr[i][j]); //Вывод каждого j-го элемента каждого i-го массива

}

Sys.print("\n");

}

Sys.exit(0);

}

Сгенерированный код может быть менее кратким на платформах, которые не поддерживают инициализацию массива. В итоге такой код инициализации массива из трех элементов var arr = [1, 2, 3]; будет выглядеть следующим образом:

var arr = new Array();
arr.push(1);
arr.push(2);
arr.push(3);

var arr = new Array();

arr.push(1);

arr.push(2);

arr.push(3);

Это следует учитывать, когда функция должна быть встроенной, так как это может содержать больше кода, чем в данном синтаксисе.
Усовершенствованные методы оптимизации можно посмотреть здесь.

Пример использования массива.

class Main 
{
	
	static function main() 
	{
		var arr = new Array(); //объявляем массив
		arr.push(2); //записываем в конец массива число 2 (в данном случае это и первый и последний элемент массива)
		arr.push(4); //записываем в конец массива число 4
		arr.push(8); //записываем в конец массива число 8
		arr.push(16); //записываем в конец массива число 16
		
		arr.insert(2, 32); //вставим число 32 третьим в массиве
		
		Sys.println(arr); //можем наблюдать, что числа 8 и 16 сдвинулись на одну позицию вправо
 
        Sys.exit(0);
	}
	
}

class Main

{

static function main()

{

var arr = new Array(); //объявляем массив

arr.push(2); //записываем в конец массива число 2 (в данном случае это и первый и последний элемент массива)

arr.push(4); //записываем в конец массива число 4

arr.push(8); //записываем в конец массива число 8

arr.push(16); //записываем в конец массива число 16

arr.insert(2, 32); //вставим число 32 третьим в массиве

Sys.println(arr); //можем наблюдать, что числа 8 и 16 сдвинулись на одну позицию вправо

Sys.exit(0);

}

Решение на Try Haxe !

Сергей Завада	Алексей Маслеев	Анастасия Улановская
Владислав Козачков	Николай Яковлев	Даша Тарабаева
Лена Наумова	Денис Швецов	Артур Тарасов
Евгений Кравчук	Дарья Пиндус	Артём Мисесин
Даша Кивганова	Иоанна Васильева	Алёна Ищук
Кирилл Автомонов	Александр Зайченко	Маша Лукьянова
Игорь Варламов	Геннадий Муржи

haxe

Учебные материалы по программированию

Tag Archives: declaration

2.5. Анонимные структуры

5.5 Объявление массивов