mytable = {} --This creates an empty table

mytable = {{}} --This creates an empty 2-dimensional table, i.e. one with another table inside
mytable2 = {{{{{{{{}}}}}}}} --This creates an empty 8-dimensional table, i.e. one with 8 layers of tables inside, you should probably never be in a situation where you have to use something like this

mytable = {} --Make our table
myitem1 = "abc"; --Make an item to add to the table
table.insert(mytable, myitem1) --This adds myitem1, namely the string "abc" to the end of the table. There is an optional argument to specify the position in the table you want to add it to.
myitem2 = "def"; --Make a new item to add to the table
table.insert(mytable, 1, myitem2) --This adds myitem2 to position 1 of the table. Thus it is placed before myitem1 in the table and myitem 1 is shifted to position 2of the table
--The table's values would now be: "def", "abc"

mytable = {"abc", "def", "ghi", {"jkl", "mno"}, "pqr"};
--As shown, your table doesn't have to only contain one type of value, you can have strings, numbers, other tables or even functions inside tables.

mytable = {} --Make our table
mytable[1] = "value 1";
mytable[2] = "value 2";
mytable[20] = "value 20";
--The table's values would be "value 1", "value 2", nil, nil,..., nil, "value 20", where ... is 14 consecutive nil values.
--Note that you could also do all of this in one line, though that's inadvisable for large tables
mytable2 = {"value 1", "value 2", [20] = "value 20"};
--As you can see, when your value is added in order, you can just write it in, but if you want to skip numbers you have to specify which number to use for the value, in this case 20

mytable = {} --Make our table
for i = 1, 20 do --Repeat 20 times, i will be used as the key for entering table values. It starts at one and each time the loop is finished, it goes up by one until it reaches 20.
   mytable[i] = "value "..tostring(i); --Set the table's value for i as "value [value of i]" using string concatenation
end
--The table's values would be "value 1", "value 2", "value 3",..., "value 20"

--Using the values entered in section 2
print(mytable[1]); --PRINT: value 1
print(mytable[20]); --PRINT: value 20
etc.

--Using the values entered in section 2
--Simple for loop
for i = 1, 20 do
   print(mytable[i]..", i is "..i); --PRINT: value 1, i is 1; PRINT: value 2, i is 2; etc.
end
--ipairs loop
for i, v in ipairs(mytable) do
   print(v..", i is "..i); --PRINT: value 1, i is 1; PRINT: value 2, i is 2; etc.
end

--Let's say you want put together a table of fruit and their colours
fruittable = {};
--You can add values in either of the following ways, they're both completely equivalent
fruittable["apple"] = "red";
fruittable.banana = "yellow"; --This version uses lua's 'syntactic sugar' which lets you use .string instead of ["string"] for convenience
--You could also do this all in one line, lua also has an easy way of doing this too
fruittable2 = {["apple"] = "red", banana = "yellow"}; --Again the second value has no square brackets and quotations. Both ways are completely equivalent.

local mostable = {};
for mosrotating in MovableMan.Particles do
   if p.PresetName == "MyDesiredName" then
      mostable[mosrotating] = mosrotating.Pos;
   end
end
--You can then access them easily and move them back with with no difficulty, this'll be covered more in the next section

local mostable = {};
for mosrotating in MovableMan.Particles do
   if p.PresetName == "MyDesiredName" then
      mostable[mosrotating] = {mosrotating.Pos, mystring = "A specific string", [12] = 12345, ["tableval] = {"A sub table", "with all sorts of values", Vector(123, 456)}, function() return 1 + 2 end};
   end
end
--This gives you the ability to store and access a large amount of information very easily

--Using the tables from section 4
print(fruittable["banana"]); --PRINT: yellow
print(fruittable.apple); --PRINT: red
--Given a local variable 'mos' which is one of the mosrotatings in your table
print(mostable[mos]); --PRINT: Vector(x, y)
--In the second case - PRINT: table#aefoc2 (if I remember correctly, the random numbers/letters indicate the memory location of the table, they're irrelevant for our purposes)

--Using the tables from section 4
for k, v in pairs(fruittable) do
   print(k.." - "..v); --PRINT: apple - red; PRINT: banana - yellow
end
for k, v in pairs(mostable) do
   print (k.." - "..v); --PRINT: MOSRotating, MyDesiredName - Vector(x, y); PRINT: ...
end
--In the second case for the mostable, you could use access each subtable's values individually or use another for loop to print all the values
for k, v in pairs(mostable) do
   print(v[12]); --PRINT: 12345
   print(v["mystring"]); --PRINT: A specific string
   print(v.tableval); --PRINT: table#asfw123sd
   print(v.tableval[1]); --PRINT A sub table
   for k2, v2 in pairs(v) do
      print(k2.." - "..v2); --PRINT: 1 - Vector(x, y); PRINT: mystring - A specific string; etc.
   end
end

--Inserting
local mytable = {a = 123, [a] = 456}; --The string "a" has value 123 while the variable a has a value of 456
local mytable2 = {12 = 789, [12] = 012}; --The string "12" has value 789 while the value at index 12 (i.e. the number 12) has a value of 012
--Accessing
print(mytable.a.."  "..mytable["a"].."  "..mytable[a]) --PRINT: 123  123  456 - mytable.a is the same as mytable["a"], but mytable[a] uses the variable a
print(mytable.12.."  "..mytable["12"].."  "..mytable[12]) --PRINT: 789  789  012 - mytable.12 is the same as mytable["12"], but mytable[12] uses the number 12