Wie deklariert man 2D-Arrays in Haxe?

Question

Nehmen wir an, dass ich in einer anderen Programmiersprache int Array [23] [23] als 2d Array mit 23 Elementen in jeder Dimension deklarieren könnte.

Wie erreiche ich dasselbe mit Haxe?

Zur Zeit muß ich dies tun:

var arr : Array<Array<int>> = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]; 

aber, wenn die Anordnung in größerer Größe wächst, wird es unmöglich für mich so nicht mehr zu erklären.

Könnte mir jemand dabei helfen?

Answer 1

Sie können gefälschte ein 2D-Array durch ein Array 1D mit:

class Array2 extends Array 
{ 
    public var pitch(default, null): Int; 
    public function new(x: Int, y: Int) 
    { 
     pitch = x; 
     super(x * y); 
    } 

    public function get(x: Int, y: Int) 
    { 
     return this[y * pitch + x]; 
    } 
} 

Answer 2

Wie Sie im Kommentar auf John Antwort dachte, gibt es keine eingebaut für 2D-Arrays, die ich wissen, aber es ist nicht schwer, einen zu erstellen.

Hier habe ich 2 Hilfsfunktionen, eine verwendet haxe.ds.Vector, die neu in Haxe 3 ist und für Sammlungen fester Größe optimiert ist. Die andere verwendet normale Arrays, kann also auf manchen Plattformen langsamer sein und hat technisch keine feste Breite, sondern wird nur auf eine bestimmte Größe initialisiert.

import haxe.ds.Vector; 

class Vector2DTest 
{ 
    static function main() 
    { 
     // 2D vector, fixed size, sometimes faster 
     var v2d = Vector2D.create(3,5); 

     v2d[0][0] = "Top Left"; 
     v2d[2][4] = "Bottom Right"; 

     trace (v2d); 
     // [[Top Left,null,null,null,null],[null,null,null,null,null],[null,null,null,null,Bottom Right]] 

     // 2D array, technically variable size, but you'll have to initialise them. Sometimes slower. 
     var a2d = Array2D.create(3,5); 

     a2d[0][0] = "Top Left"; 
     a2d[2][4] = "Bottom Right"; 

     trace (a2d); 
     // [[Top Left,null,null,null,null],[null,null,null,null,null],[null,null,null,null,Bottom Right]] 
    } 
} 

class Vector2D 
{ 
    public static function create(w:Int, h:Int) 
    { 
     var v = new Vector(w); 
     for (i in 0...w) 
     { 
      v[i] = new Vector(h); 
     } 
     return v; 
    } 
} 
class Array2D 
{ 
    public static function create(w:Int, h:Int) 
    { 
     var a = []; 
     for (x in 0...w) 
     { 
      a[x] = []; 
      for (y in 0...h) 
      { 
       a[x][y] = null; 
      } 
     } 
     return a; 
    } 
} 

Die Vector2D wird nur auf Haxe 3 (später in diesem Monat) arbeiten, sollten Array2D auf Haxe gut funktionieren auch 2.

Answer 3

Der beste Weg, dies zu tun, ist, den Vorteil von Array Comprehensions in Haxe Anspruch nehmen will, 3:

var bigArray:Array<Array<Int>> = [for (x in 0...10) [for (y in 0...10) 0]]; 

Array Comprehensions für die Herstellung von Arrays eine wirklich schöne und Kondensmilch Syntax ist. Der obige Code würde ein 10x10-Array machen, gefüllt mit 0s. Sie können mehr über sie lesen here.

Wenn Sie Haxe 2 aus irgendeinem Grund ausführen, wäre es am besten, sie mit For-Loops zu füllen, wie zuvor vorgeschlagen.

Answer 4

Wenn Sie nicht haxe mit 3, und Sie mögen ein Array mit Nullen der kürzesten würde nur das letzte Element init sein, die andere mit null gefüllt werden:

var arr2d = new Array<Array<AType>>(); 
for (i in 0...10) { arr2d[i] = []; arr2d[i][10] = null; } 

oder wie dieser init mit einem Wert:

for (i in 0...10) for (j in 0...10) arr2d[i][j] = a_value; 

Answer 5

dies ein einfacher Weg ist, in Array ax zu erklären (3,0)

class Prova 
{ 
    static function main () 
    { 
    var arr : Array< Array<Int> > = [ [],[],[] ] ; 

    arr[0][0] = 10 ; 
    arr[0][1] = 11 ; 

    trace (arr[0]); 
    trace (arr[1]) ; 
    trace (arr[2]) ; 
    return 0 ; 
    } 
} 

Ausgang:

Prova.hx: 12: [10,11]

Prova.hx: 13: []

Prova.hx: 14: []