Pourquoi les tableaux (tables) Lua commencent-ils à 1 au lieu de 0?

Je ne comprends pas le raisonnement derrière la décision de cette partie de Lua. Pourquoi l'indexation commence-t-elle à 1? J'ai lu (comme beaucoup d'autres) cet excellent article . Cela me semble un coin étrange d'une langue très agréable à apprendre et à programmer. Ne vous méprenez pas, Lua est tout simplement géniale mais il doit y avoir une explication quelque part. La plupart de ce que j'ai trouvé (sur le Web) dit simplement que l'index commence à 1. Point final.

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 en Lua, j'espère ne pas manquer quelque chose d'évident sur les tables.

Lua est un descendant de Sol, un langage conçu pour les ingénieurs pétroliers sans formation formelle en programmation informatique. Les gens qui ne sont pas formés à l'informatique pensent que c'est vraiment bizarre de commencer à compter à zéro. En adoptant l'indexation de tableau et de chaîne basée sur 1, les concepteurs de Lua ont évité de confondre les attentes de leurs premiers clients et sponsors.

Bien que je les trouve aussi bizarres au début, j'ai appris à aimer les tableaux basés sur 0. Mais je me débrouille bien avec les tableaux basés sur 1 de Lua, en particulier en utilisant la forboucle générique de Lua et l' ipairsopérateur - je peux généralement éviter de me soucier de la façon dont les tableaux sont indexés.

Dans la première discussion sur les tables de Programming in Lua , ils mentionnent:

Puisque 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 les tableaux avec 1 (et non avec 0, comme en C) et plusieurs fonctionnalités respectent cette convention.

Plus tard, dans le chapitre sur les structures de données, ils répètent à peu près la même chose: que les fonctionnalités intégrées de Lua supposent une indexation basée sur 1.

Quoi qu'il en soit, il existe quelques avantages à utiliser l'indexation basée sur 1. À savoir, l' #opérateur (longueur): t[#t]accède au dernier index (numérique) de la table, et t[#t+1]accède à 1 après le dernier index. Pour quelqu'un qui n'a pas déjà été exposé à l'indexation basée sur 0, il #t+1serait plus intuitif de passer la fin d'une liste. Il y a aussi la for i = 1,#tconstruction de Lua , qui, je crois, relève de la même catégorie que le point précédent selon lequel "1 à la longueur" peut être plus judicieux que l'indexation "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 initial , mais il a probablement changé depuis.

Je crois comprendre que c'est ainsi simplement parce que les auteurs pensaient que ce serait une bonne façon de le faire, et après avoir diffusé le libellé au public, cette décision s'est considérablement calcifiée. (Je soupçonne qu'il y aurait un enfer à payer s'ils le changeaient aujourd'hui!) Je n'ai jamais vu une justification particulière au-delà de cela.

Peut-être un point moins significatif, mais dont je n'ai pas encore entendu parler: 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 CERTAINS 0 passés comme des 1. Soyez prudent lorsque vous utilisez ipairs.
Alors ça: ("abc"):sub(0,1) == "a" and ("abc"):sub(1,1) == "a"sera 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 vraie raison est que la langue est une mise en œuvre de la définition dans une loi du Portugal et que le principal centre de développement était au Brésil et leur préférence est d'éviter l'utilisation de zéro ou vide ou rien comme index ou indice. Cependant, le langage autorise l'utilisation d'un index de démarrage autre que 1 dans une fonction de création de table dans certaines versions.

table [0] renverra TOUJOURS nil (nul), À MOINS que vous ne lui attribuiez une valeur vous-même table [0] = 'some value' et la table [0] renverra 'une 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]))

Il est logique pour chacun que si un

table = {}

Pour le moment, tableest vide. Donc quand

table == {something}

La table contient quelque chose donc ce qu'elle contient est l'index 1 tablesi vous voyez ce que je veux dire.

Ce que je voulais dire, c'est que la table [0] existe, et sa table = {}, qui est vide, maintenant un programmeur n'appellera pas une table vide, il les définit, puis la remplit, il sera inutile de trouver une table vide table à chaque fois que vous voulez l'appeler, il est donc plus simple de créer simplement une table vide.

Mon anglais ne s'améliorera pas et c'est ma meilleure grammaire. Si vous ne l'aimez pas, vous êtes libre de ne pas continuer à le lire, mais donner -rep pour quelqu'un qui essaie d'aider fait que les gens ne veulent pas du tout aider, surtout pour quelque chose comme la grammaire. Je suis un homme de nombres et de vars, pas de grammaire. Désolé.