[wahern]

The key phrase to keep in mind in Lua is "sequence". The # operator on a table, and the ipairs function, are meant to be used with sequences. Per the Lua manual

  We use the term sequence to denote a table where the set of
  all positive numeric keys is equal to {1..n} for some non
  negative integer n, which is called the length of the
  sequence (see §3.4.7).

If a table contains numeric keys with any gaps (i.e. nil values between sequential numeric indices), then it's not a sequence. Because Lua uses a binary search to find the end of the sequence, it might select any nil as the one ending the sequence.

Also, another thing to remember is that a Lua table can have both a sequence and non-numerical (e.g. string) keys. So

  local t = { 1, 2, 3, n = 3 }

is a valid sequence. Using n to store the length of the "array" part is a common Lua idiom when you want array behavior but cannot guarantee a valid sequence. For example, table.pack creates a table out of a variable argument list; but because any of the arguments might be nil, it sets n as the length of the argument list. Of course, you have to explicitly make use of n in those cases.

Lots of people complain about this aspect of Lua. But Lua is very minimalist and there aren't any obvious alternatives. Lua could try to keep track of the maximum numeric index, but that can have poor asymptotic behavior unless Lua used a binary tree for tables instead of arrays and hashes. Lua could implement a type-safe array object, but that violates a core design guideline of Lua, which is that it provides the table as the only primitive for compound data structures. And in any event, it's trivial to implement your own array implementation using metamethods to maintain the invariants of a table while providing transparent support for # and ipairs.