assoziative Arrays bei LUA

[Jürgen W. (lovos)]

Hallo,
bei
http://www.lua.org/pil/2.5.html
steht was über die Definition von Arrays:

    a = {}     -- create a table and store its reference in `a'
    k = "x"
    a[k] = 10        -- new entry, with key="x" and value=10
    a[20] = "great"  -- new entry, with key=20 and value="great"
    print(a["x"])    --> 10
    k = 20
    print(a[k])      --> "great"
    a["x"] = a["x"] + 1     -- increments entry "x"
    print(a["x"])    --> 11

Darüberhinaus kann man ein normales Array auch direkt angeben, z.B.

print( summe( {1,2,3,4,5} ) )

wie geht das bei assoziativen Arrays?
Dinge wie

{key1 = value1, key2 = value2}

funktioniert nicht.

[Stefan Salewski (Gast)]

Jürgen W. schrieb:
> funktioniert nicht.

Wo kein Wille ist, da ist auch kein Weg...

http://www.lua.org/manual/5.1/manual.html

Siehe 2.5.7 - Table Constructors

> table = {e = "a", [3] = "drei"}
> print(table[3])
drei
> print(table["e"])
a
>

Na ja, nun weiß ich, dass auf meinem Rechner sogar Lua installiert ist.

[Jürgen W. (lovos)]

Das muss daran liegen, dass der Key nicht in Anführungszeichen 
geschrieben darf (im Gegensatz zu der []-Schreibweise)

bei

htPar={"index1"="value1"}

ergibt das

file.lua:2: '}' expected near '='

Ohne Anführungszeichen funktioniert das aber. Seltsam!

[Udo N. (weinbauer73)]

Ich kenne zwar Lua nicht, aber nach 
http://lua-users.org/wiki/TablesTutorial kann der Key verschiedenes 
sein, daher darf der nicht in Anführungszeichen stehen.

[Jürgen W. (lovos)]

> sein, daher darf der nicht in Anführungszeichen stehen.

Im LUA-Tutorial stehen aber die nicht-numerischen Keys ALLE in 
Anführungszeichen. Jeder logisch denkende Mensch würde denken, dass das 
bei einer Direkt-Definition eines Arrays auch so sein muss.

Aber wie so vieles kann man auch das nicht verstehen, sondern sollte es 
einfach zur Kenntnis nehmen

http://www.lua.org/pil/2.5.html

    a = {}     -- create a table and store its reference in `a'
    k = "x"
    a[k] = 10        -- new entry, with key="x" and value=10
    a[20] = "great"  -- new entry, with key=20 and value="great"
    print(a["x"])    --> 10
    k = 20
    print(a[k])      --> "great"
    a["x"] = a["x"] + 1     -- increments entry "x"
    print(a["x"])    --> 11

[Stefan Salewski (Gast)]

>Jeder logisch denkende Mensch würde denken

Nachlesen oder nachdenken.

Ich würde meinen, man möchte Tipparbeit sparen -- oder tippst Du so 
gerne Anführungszeichen?

Bei Ruby gibt es ähnliche Tipparbeit sparende Konstrukte für 
Initialisierungen, etwa mit dem %w vor einem Array

stefan@AMD64X2 ~/gts $ irb
irb(main):001:0> a = %w[a b c]
=> ["a", "b", "c"]
irb(main):002:0> b = ["a", "b", "c"]
=> ["a", "b", "c"]
irb(main):003:0>

Das macht für mich schon Sinn, aber ich habe auch ein Buch, und lese das 
auch. Lua kenne ich nur dem Namen nach.

[Jürgen W. (lovos)]

> Das macht für mich schon Sinn

Für mich auch. Ich war lediglich irritiert, dass in den 
Einzelzuweisungen (arr["key"]="value") die Anführungszeichen vorhanden 
sind.

Die Lua-Arrays erinnerten mich an die JSON-Konstrukte.
http://en.wikipedia.org/wiki/JSON

Und da werden auch die Anführungszeichen für Keys verwendet (ob sie 
zwingend notwendig sind weiß ich nicht)
Ohne Anführungszeichen lässt sich der Code viel flüssiger schreiben, 
klar.

[Yalu X. (yalu) (Moderator)]

Da es in Lua nur einen einzigen zusammengesetzten Datentyp (nämlich die
Table) gibt, mit dem sowohl Arrays als auch Records (Strukturen) darge-
stellt werden, gibt es für die Initialisierung und den Elementzugriff
die Array- und die Record-Syntax. Die Array-Syntax ist die allgemeinere
Form, die Record-Syntax ist syntaktischen Zucker, um Tables wie Struktu-
ren oder Objekte aus anderen Programmiersprachen behandeln zu können.

Array-Syntax:

a = { [3]=333, [3.14]="pi", ["pi"]=3.14 }
print(a[3])            --> 333
print(a[3.14])         --> pi
print(a["pi"])         --> 3.14

Der Index kann bspw. ein Integer, FLoat oder String sein. Strings stehen
immer in Anführungszeichen.


Record-Syntax:

b = { pi=3.14 }        -- entspricht b = { ["pi"]=3.14 }
print(b.pi)            -- entspricht print(b["pi"])

Der Selektor ist ein Identifier und wird (wie auch Variablennamen) ohne
Anführungszeichen geschrieben. Für ihn gelten dieselben Regeln wie für
Variablennamen: Das erste Zeichen muss ein Buchstabe oder Unterstrich
sein, alle nachfolgenden Zeichen Buchstaben, Unterstriche oder Ziffern.

[Johann L. (gjlayde)]

Das bedeutet also, daß folgendes identisch ist?

a[20] = 1;
a["20"] = 1;

Oder wie unterscheidet man das sonst bei der Direktzuweisung?

[Yalu X. (yalu) (Moderator)]

Johann L. schrieb:
> Das bedeutet also, daß folgendes identisch ist?
> a[20] = 1;
> a["20"] = 1;

Nein, denn 20 (Integer) und "20" (String) sind zwei unterschiedliche
Indizes.

> Oder wie unterscheidet man das sonst bei der Direktzuweisung?

Die Frage habe ich nicht verstanden.

[Johann L. (gjlayde)]

Yalu X. schrieb:
> Johann L. schrieb:
>> Das bedeutet also, daß folgendes identisch ist?
>> a[20] = 1;
>> a["20"] = 1;
>
> Nein, denn 20 (Integer) und "20" (String) sind zwei unterschiedliche
> Indizes.
>
>> Oder wie unterscheidet man das sonst bei der Direktzuweisung?
>
> Die Frage habe ich nicht verstanden.

Ah, ich glaub jetzt hab ich's:

table = { 1 = "ein", [2] = "zwei", ["3"] = "drei" }

Der 1. und 3. Schlüssel sind Strings und der 2. ein Integer.

[Jürgen W. (lovos)]

Ich habe ein kleines Testprogramm geschrieben, um zu sehen, was "intern" 
ankommt: String oder Number/Float.

Im Lua Programm propiere ich alle Kombinationen durch in verschiedenen 
Schreibweise. Dabei verursacht die letzte Schreibweise "{11="str1"}" 
einen Fehler.

outputTable({[1]="1"})
outputTable({["1"]=1})
outputTable({["num"]=1})
outputTable({num=1})

a={}; a[1]="1"
outputTable(a)
b={}; b["1"]=1
outputTable(b)

--outputTable({11="str1"}) --error

Im C-Programm, was durch die Lua-Funktion "outputTable" aufgerufen wird, 
iteriere ich durch die Tabelle und hänge bei Key und Value ein /S oder 
/N an, je nachdem ob es sich um einen String oder Zahl handelt

static int l_outputTable(lua_State *L) {
short narg;
narg=1;
luaL_checktype(L, narg, LUA_TTABLE);
{
  lua_pushnil(L);
  while (lua_next(L, narg) != 0) {
    char s2[2][0x20];
    unsigned char ii;
    for (ii=0;ii<2;ii++) {
      if (lua_type(L,-2+ii)==LUA_TSTRING) {
        sprintf(s2[ii],"%s/S", lua_tostring(L, -2+ii));
      }
      else if (lua_type(L,-2+ii)==LUA_TNUMBER)
        sprintf(s2[ii],"%.2f/N",lua_tonumber(L, -2+ii));
      else sprintf(s2[ii],"TYPE %d",lua_type(L, -2+ii));
    }
      printf("%s=\t%s\n", s2[0],s2[1]);
    lua_pop(L, 1);
  }
}
return 0;
}

Die Ausgabe ist wie erwartet, dabei ist zwischen {["num"]=1} und {num=1} 
kein Unterschied.

1.00/N=  1/S
1/S=  1.00/N
num/S=  1.00/N
num/S=  1.00/N
1.00/N=  1/S
1/S=  1.00/N

Nachtrag:
bei der Reihenfolge der indizes spielt die Schreibweise doch ein Rolle:

outputTable({[1]="1", ["1"]=1, num=3.14})

erzeugt

1.00/N=  1/S
num/S=  3.14/N
1/S=  1.00/N

[Yalu X. (yalu) (Moderator)]

Johann L. schrieb:
> Ah, ich glaub jetzt hab ich's:
> table = { 1 = "ein", [2] = "zwei", ["3"] = "drei" }
> Der 1. und 3. Schlüssel sind Strings und der 2. ein Integer.

Theoretisch wäre das so. Allerdings ist der erste Initialisierer in
Record-Syntax gegeben, somit muss der Key hier ein Identifier sein, also
mit einem Buchstaben oder Underscore beginnen, sonst gibt's Gemecker.

Jürgen W. schrieb:
> bei der Reihenfolge der indizes spielt die Schreibweise doch ein Rolle:

Über die Reihenfolge, in der die Elemente intern gespeichert sind, kann
man kaum eine Aussage machen (und sollte es auch nicht), da sie
implementierungsabhängig ist und sich prinzipiell mit jeder neuen
Lua-Version ändern kann.