Fonctions dans la table de Table
table.concat (table [, sep [, i [, j]]])
table.foreach (table, f)
table.foreachi (table, f)
table.getn (table)
table.sort (table [, comp])
table.insert (table, [pos,] value)
table.remove (table [, pos])
table.setn (table, n)
table.concat (table [, sep [, i [, j]]])Concaténez / raccordent les valeurs d'une table avec ..
Paramètre :
- La table que les valeurs doivent être concaténées
- Une ficelle(chaîne) ou une valeur qui doit être placée entre. (optionnel : le défaut est une ficelle(chaîne) vide)
- D'où les valeurs devraient être raccordées (optionnel : le défaut est 1)
- Jusqu'à où les valeurs doivent être concaténées. (optionnel : la grandeur de la table est le défaut)
Nous le rappelons les ficelles(chaînes) et les nombres peuvent être concaténés avec deux points. ("a" .. 5-> "a5")
Cette fonction fait le même avec les valeurs d'une table numérique
Exemple:
myTable = {
19,
"eisen",
10,
"guss",
}
resultat = table.concat(myTable)
print(resultat) --> 19eisen10guss
resultat = table.concat(myTable, " leer ")
print(resultat) --> 19 leer eisen leer 10 leer guss
resultat = table.concat(myTable, " leer ", 2)
print(resultat) --> eisen leer 10 leer guss
resultat = table.concat(myTable, " leer ", 2, 3)
print(resultat) --> eisen leer 10
Cette fonction passe par chaque index de la table et l'alloue à la fonction (le deuxième paramètre à l'intérieur de la parenthèse).
La considération suite aux paramètres pour le retour:
- La table, dans laquelle chaque index doit être passé
- La fonction qui recevra la valeur du selon l'index.
table.foreach (meinTable , MeineFunktion)
Exemple:
meinTable = {}
meinTable.wert1 = true
meinTable.wert3 = 8
meinTable[1] = "Name1"
meinTable[7] = "Name7"
function DruckWas(_index)
print( _index, meinTable[_index] )
end
table.foreach( meinTable, DruckWas )
Cette fonction ressemble à la précédence, mais elle passe par les index seulement numériques. Mais seulement aussi longtemps qu'un ordre sera interrompu.
La considération suite aux paramètres pour le retour:
- La table, dans laquelle chaque index numérique doit être passé
- La fonction qui recevra la valeur du selon l'index.
table.foreachi (meinTable , MeineFunktion)
Exemple:
meinTable = {}
meinTable.wert1 = true
meinTable.wert3 = 8
meinTable[1] = "Name1"
meinTable[7] = "Name7"
function DruckWas(_index)
print( _index, meinTable[_index] )
end
table.foreachi( meinTable, DruckWas )
Comme vous pouvez voir, l'index 7 ne sera pas imprimé comme les index numériques 2 jusqu'à 6 manquent.
Cette fonction met une valeur à la fin d'une table. Si une position exacte(précise) sera définie, la valeur
sera placé sur cette position et tous suite à indices seront faits défiler en conséquence.
La seule tâche de cette fonction est, changer la table directement.
La considération suite aux paramètres pour le retour :
- Ils présentent dans lequel la variable doit être conservée
- Optionnel la position où la variable devrait être placée exactement
table.insert (meinTable , [position,] wert)
Exemple:
meinTable = {}
table.insert (meinTable , 5)
resultat --> = meinTable[1] == 5
-- de nouveau:
table.insert (meinTable , "Luna")
resultat --> = meinTable[1] == 5
meinTable[2] == "Luna"
-- de nouveau:
table.insert (meinTable , 2, true)
resultat --> = meinTable[1] == 5
meinTable[2] == true
meinTable[3] == "Luna"
Cette fonction rend la grandeur d'une table numérique.
La considération suite aux paramètres pour le retour:
- La table, que la grandeur nous voulons savoir
tableGroesse = table.getn(meinTable)
Beispiel:
myTable={ 1, 3, 6, "toll", false, { 8,9} )
tableGroesse = table.getn ( myTable ) --> tableGroesse == 6
tableGroesse = table.getn ( myTable[6] ) --> tableGroesse == 2
Cette fonction supprime un élément d'une table numérique et donne de l'avancement aux index restants si nécessaire.
Considering following parameters for return:
- La table dans laquelle nous voulons effacer un élément
- La position de cet élément (optionnel)
geloeschtesElement = table.remove(meinTable[, pos])
Exemple:
myTable = { 1, 3, 6, "grand", false, { 8,9} )
myTable[3] == 6
geloeschtesElement = table.remove(myTable, 3)
De cela il suit -->
myTable[3] == "grand"
geloeschtesElement == 6
Cette fonction change une grandeur d'une table numérique.
La considération suite aux paramètres pour le retour:
- La table quelle taille devrait être changée
- La grandeur de la table ensuite
table.setn (meinTable , 7)
Exemple:
Comme montré au-dessus à table.foreachi rien ne sera imprimé en plus de l'index 1
meinTable = {}
meinTable.wert1 = true
meinTable.wert3 = 8
table.setn(meinTable,7)
meinTable[1] = "Name1"
meinTable[7] = "Name7"
function DruckWas(_index)
print( _index, meinTable[_index] )
end
table.foreachi( meinTable, DruckWas )
Comme nous pouvons voir, tous les éléments jusqu'à 7 seront imprimés.
À coup sûr, il est aussi possible de réduire la grandeur d'une table avec cette fonction. Pourtant, cela signifie aussi que tous les éléments au-dessus du plus haut index seront effacés.
Arrange une table numérique ( myTable[1] ... myTable[n] )
Paramètre:
- La table qui doit être arrangée.
- une fonction qui définit l'ordre de sorte.
Exemple:
myTable = {}
myTable[1] = 77
myTable[2] = 8
myTable[3] = 717
myTable[4] = 55
table.sort(myTable)
De cela il suit
myTable[1] --> 8
myTable[2] --> 55
myTable[3] --> 77
myTable[4] --> 717
____________________________________________________________________
ou
myTable = {}
myTable[1] = "z"
myTable[2] = "o"
myTable[3] = "f"
myTable[4] = "n"
table.sort(myTable)
De cela il suit
myTable[1] --> "f"
myTable[2] --> "n"
myTable[3] --> "o"
myTable[4] --> "z"
____________________________________________________________________
Toutes les valeurs doivent être même type. Autrement une erreur se produit: attempt to compare string with number
Une table avec non des index numériques ne peut pas être triée directement. Cependant, pour faire ainsi tous les index doivent être écrit dans une table numérique d'abord.
Cette table peut être triée ensuite.
Exemple:
meinTable = {}
meinTable.Z = 89
meinTable.X = 8
meinTable.Y = 55
sortierTable = {}
for index in pairs(meinTable) do
table.insert(sortierTable, index)
end
sortierTable[1] --> Y
sortierTable[2] --> X
sortierTable[3] --> Z
maintenant le sortierTable peut être arrangé en conséquence
table.sort(sortierTable)
sortierTable[1] --> X
sortierTable[2] --> Y
sortierTable[3] --> Z
Une fonction pour faire un arrangement:
Comme le deuxième paramètre dans table.sort une fonction peut être allouée qui définit l'ordre de sorte.
Elle reçoit deux valeurs de la table comme le paramètre. Alors cette fonction doit déterminer lequel de ces paramètres vient au début.
Si la première valeur devrait venir avant le deuxième, la fonction doit revenir vrai. Autrement le zéro ou false.
Exemple:
myTable = {
10,
124,
10,
48,
}
function comp(w1,w2)
if w1 > w2 then
return true
end
end
table.sort(myTable,comp)
avec cela l'ordre de sorte sera changé
myTable[1] --> 124
myTable[2] --> 48
myTable[3] --> 10
myTable[4] --> 10