[vor_]

I find Lua's use of tables as a universal container to be clumsy. For example:

  local array = { one, two, threee, four }

A gap is silently created in the array because Lua returns nil for undefined variables. This causes the (#) operator to an return incorrect result and can lead to subtle, difficult-to-find bugs in the program.

Lua makes no distinction between nil and a non-existent element, so assigning nil to an array element will also create a gap, rather than shifting the keys of the subsequent elements downward:

  local array = { 1, 2, 3, 4 }
  array[2] = nil
  -- array is now { [1] = 1, [3] = 3, [4] = 4 }

[groovy2shoes]

If you want the array elements to shift into the gap, you want to use table.remove:

    local array = {1, 2, 3, 4}
    table.remove(array, 2)
    -- array is now { [1] = 1, [2] = 3, [3] = 4 }

[gruseom]

Your second example is not "clumsy", but a consequence of how Lua's tables are simple and cleanly designed. It would be weird magic for the elements to suddenly shift downward. One can do that oneself if need be.

Your first example has a point – perhaps undefined variables should error when accessed – but that's got nothing to do with tables.

[vor_]

Array keys shifting downward wouldn't be weird magic; it would be the expected behavior when removing an element from an array. Dismissing it as simply how Lua's tables are designed doesn't make it intuitive or expected.

> Your first example has a point – perhaps undefined variables should error when accessed – but that's got nothing to do with tables.

Well, of course it does. The point is that you can silently end up with array "holes" due to a typo, which you are supposed to avoid in Lua for a number of reasons, such as an the length operator returning an incorrect result. I don't understand why my previous comment is getting voted down for pointing this out.