Pourquoi les tableaux (tables) Lua commencent-ils à 1 au lieu de 0?
Je ne comprends pas la justification de la décision de cette partie de Lua. Pourquoi l'indexation commence-t-elle à 1? J'ai lu (comme beaucoup d'autres l'ont fait) ce grand article . Cela me semble un coin étrange d'une langue très agréable à apprendre et à programmer. Ne vous méprenez pas, Lua est juste génial mais il doit y avoir une explication quelque part. La plupart de ce que j'ai trouvé (sur le Web) dit simplement que l'indice commence à 1. Arrêt complet.
Il serait très intéressant de lire ce que ses concepteurs ont dit sur le sujet.
Notez que je suis "très" débutant à Lua, j'espère que je ne manque pas quelque chose d'évident sur les tables.
Lua est issu de Sol, un langage conçu pour les ingénieurs pétroliers sans formation formelle en programmation informatique. Les personnes non formées à l'informatique pensent qu'il est sacrément bizarre de commencer à compter à zéro. En adoptant l'indexation de tableaux et de chaînes basée sur 1, les concepteurs de Lua ont évité de confondre les attentes de leurs premiers clients et sponsors.
Bien que moi aussi, je les ai trouvés étranges au début, j'ai appris à aimer les tableaux à base de 0. Mais je me débrouille bien avec les tableaux basés sur 1 de Lua, en particulier en utilisant la boucle générique for de Lua et l'opérateur ipairs - je peux généralement éviter de me soucier de la façon dont les tableaux sont indexés.
Dans Programmation en Lua première discussion des tables, ils mentionnent:
Comme vous pouvez indexer une table avec n'importe quelle valeur, vous pouvez démarrer les index d'un tableau avec n'importe quel nombre qui vous plaît. Cependant, il est habituel dans Lua de démarrer des tableaux avec 1 (et non avec 0, comme en C) et plusieurs installations respectent cette convention.
Plus tard, dans le chapitre sur les structures de données, ils disent à peu près la même chose: que les installations intégrées de Lua supposent une indexation basée sur 1.
Quoi qu'il en soit, il existe un couple avantages à utiliser l'indexation basée sur 1. A savoir, l'opérateur # (Longueur): t[#t] Accède au dernier index (numérique) de la table, et t[#t+1] Accède à 1 passé le dernier indice. Pour quelqu'un qui n'a pas déjà été exposé à l'indexation basée sur 0, #t+1 Serait plus intuitif pour dépasser la fin d'une liste. Il y a aussi la construction for i = 1,#t De Lua, qui, je crois, tombe dans la même catégorie que le point précédent que "1 à la longueur" peut être plus sensé que l'indexation de "0 à la longueur moins 1".
Mais, si vous ne pouvez pas briser l'état d'esprit de l'indexation basée sur 0, alors l'indexation basée sur 1 de Lua peut certainement être plus un obstacle. En fin de compte, les auteurs voulaient quelque chose qui fonctionnait pour eux; et j'avoue que je ne sais pas quel était leur objectif original, mais il a probablement changé depuis.
Il y a une raison très importante de NE PAS compter les tableaux à partir de 1: si les tableaux partent de zéro, vous pouvez les utiliser comme anneaux algébriques de manière naturelle. Par exemple. nous avons les jours d'une semaine (day={'mo', 'tu', 'we'...) et nous voulons les parcourir. Il serait alors beaucoup moins compliqué d'écrire:
nextday = day[(i+1)%7] as it is in almost every other language
Que:
nextday = day[i%7+1] as it is in lua
ne semble pas être si mauvais au début, mais essayez de faire défiler la semaine dans l'autre sens.
Ou plus généralement: si l'ensemble d'index manque de zéro, il lui manque l'élément neutre d'addition. Chaque fois que cela est nécessaire dans les calculs d'indices, les indices doivent être déplacés.
Je suis mathématicien, mais j'ai accepté le fait qu'en matière de programmation, compter à partir de zéro soit la meilleure option.
D'après ce que je comprends, c'est de cette façon simplement parce que les auteurs ont pensé que ce serait une bonne façon de le faire, et après avoir diffusé le langage au public, cette décision s'est considérablement calcifiée. (Je soupçonne qu'il y aurait un enfer à payer s'ils devaient le changer aujourd'hui!) Je n'ai jamais vu de justification particulière au-delà de cela.
Peut-être un point moins significatif, mais que je n'ai pas encore entendu mentionné: il y a une meilleure symétrie dans le fait que le premier et le dernier caractère d'une chaîne sont respectivement à 1 et -1, au lieu de 0 et -1.
Les bibliothèques Lua préfèrent utiliser des index qui commencent à 1. Cependant, vous pouvez utiliser n'importe quel index de votre choix. Vous pouvez utiliser 0, vous pouvez utiliser 1, vous pouvez utiliser -5. C'est même dans leur manuel, qui peut être trouvé à ( https://www.lua.org/pil/11.1.html ).
En fait, quelque chose de cool ici est que les bibliothèques lua internes traiteront QUELQUES 0 passés comme des 1. Soyez prudent lorsque vous utilisez ipairs.
Pour que: ("abc"): sub (0,1) == "a" et ("abc"): sub (1,1) == "a" soit vrai.
You can start an array at index 0, 1, or any other value:
-- creates an array with indices from -5 to 5
a = {}
for i=-5, 5 do
a[i] = 0
end
la table [0] retournera TOUJOURS nil (null), À MOINS QUE vous ne lui attribuiez vous-même une valeur table [0] = 'une certaine valeur' et ensuite la table [0] renverra 'une certaine valeur' que VOUS avez assignée.
Voici un exemple:
tbl={'some'}
print('tbl[0]='..tostring(tbl[0]))
print('tbl[1]='..tostring(tbl[1]))
nothing={}
print('nothing[0]='..tostring(nothing[0]))
print('nothing[1]='..tostring(nothing[1]))
nothing[0]='hey'
print('(after assign)\nnothing[0]='..tostring(nothing[0]))