dollar

Lua актуален в 2020 и будет актуален ещё долго.
Учить стоит.

Только там нечего учить. :) Язык настолько простой, что программисту хватит максимум 30 минут для освоения. Для более простых людей, но владеющих хотя бы логикой и простой математикой, ну день должно хватить, думаю. А для всех остальных есть книжка Роберта Иерузалимски (автора языка), в которой всё разжевано до мелочей.

В общем, начните с такого запроса в гугле: lua in 15 minutes
А дальше - как пойдет.

1) Считать все строки файла в массив (таблицу).
2) Изменить элемент (строку) №22 в массиве.
3) Перезаписать файл, записав в него из массива все строки заново.

_G['SomeText'..i]:GetName('12','34')

sampSendChat(string.format('/get guns %d', tonumber(msg)))

А еще можно проще:
sampSendChat('/get guns ' .. msg))

local function round_or_nil(num)
	local res = math.floor(num + 0.5)
	local diff = math.abs(res - num)
	return (diff <= 0.1 or diff >= 0.9) and res or nil
end

1) А что вам важнее, изящество или скорость?
1.а) Во-первых, изящнее использовать встроенную функцию ipairs, которая как раз интерирует индексный массив:

lines = {"sdss", "vfbf"}
for i, line in ipairs(lines) do
  print(line)
end

Это изящнее, чем просто обращение по индексу, потому что исчезает строка создания переменной line, она задаётся в самом цикле. Однако с точки зрения производительности такой способ медленнее, потому что конструкции языка быстрее, чем обращение к функциям, даже встроенным. Так что если у вас миллиарды строк, то лучше ваш вариант, хоть он и менее изящен.

1.б) Во-вторых, в вашем примере создаётся переменная line глобально. Это не ошибка, но может привести к ошибке в будущем, если код будет сложный. Поэтому делать так совсем не изящно. Лучше писать так:
local line = lines[i]
Это создаст локальную переменную внутри цикла. Она не будет доступна вне цикла. А если есть одноименная глобальная переменная, то с ней ничего не произойдет. Везде, где только можно, лучше использовать слово local, оно ограничивает область видимости переменной текущим блоком (и вложенными блоками).

Кстати, массив lines тоже желательно задавать через local, если ваш скрипт не рассчитан на несколько файлов и общее глобальное пространство имен между ними. Дело в том, что такие локально-глобальные переменные в пределах файла чуть быстрее, чем классические глобальные.

2) nil выводит потому, что строки в lua не являются итерируемыми объектами, в отличие от строк в javascript, например. То есть строка является объектом, поэтому обращение к свойству [j] не является синтаксической ошибкой, но свойства такого у строки нет, поэтому line[j] возвращает nil.

Обращение к символу в Lua происходит через функцию подстроки:
line:sub[j,j]
То есть мы буквально вырезаем подстроку с позиции j до позиции j, это и есть один символ.

Опять же, красиво создавать локальные переменные, чтобы читателю вашего кода было понятно, что происходит, а потом их использовать. Желательно с комментариями. Например, так:

local c = line:sub[j,j] --Получаем символ с номером j
print(c) --Выводим символ

3) Ну и, наконец, если вам не важна скорость и производительность совсем, а под изяществом вы понимаете как можно более короткую (и/или сложную для понимания) запись кода, то вам подойдёт что-то вроде этого:

Ведь в Lua использовать в качестве итератора любую функцию, кроме pairs и ipairs, очень необычно, не всем понятно, зато "изящно" (если это можно так назвать). Передавать функции в качестве аргументов другой функции - приём также чуть сложнее, чем просто цикл. Ну и регулярные выражения, само собой разумеется, отдельная сложная тема. Тем более, что в Lua регулярки немного иначе устроены, то есть ещё +10% к сложности.

local x, y, z = streetIsMyHome()
if x == 1 and y == 2 and z == 3 then
  print("Working")
end

Если не хотите "мусорить" переменными в пространстве текущего файла или текущей области видимости, то:

Еще один вариант - написать свою собственную функцию сравнения:

Но самое правильное и красивое - делать отдельную функцию для каждой конкретной задачи:

Очевидно, число 4 находится в первом столбце (x==1) и второй строке (y==2).
Это видно невооруженным глазом.
Программно это можно выяснить так:

array = {
    1,2,3,
    4,5,6,
    7,8,9
}

function getXY(num)
    local x,y,i=1,1,1
    while array[i] ~= num do
        i = i + 1
        x = x + 1
        if x > 3 then
            x = 1
            y = y + 1
        end
        if not array[i] then return end
    end
    return x,y
end

print(getXY(4)) --1,2
print(getXY(8)) --2,3
print(getXY(3)) --3,1

А если вам нужна обратная задача (по координатам искать число), то вот:

array = {
    1,2,3,
    4,5,6,
    7,8,9
}

function find(x,y)
    return array[(y-1)*3 + x]
end

print(find(1,2)) --4
print(find(2,3)) --8
print(find(3,1)) --3

Но всё же лучше пересмотреть способ хранения данных. Например, так:

array = {
    { 1,2,3 },
    { 4,5,6 },
    { 7,8,9 },
}

Для начала, лучше не использовать слово string для имени переменной, т.к. это целая библиотека для работы со строками. Вы перекрываете к ней доступ.

В Lua нет полноценных регулярных выражений, потому что Lua задумывался как максимально лёгкий язык. Вместо этого используется т.н. "соответствие шаблону". Так что {2} не работает. Просто в большинстве случаев хватает модификаторов + - * ?

В вашем случае подойдёт:

local str = "qw.erty"
return str:match("([a-z][a-z])%.")

Или даже:

local str = "qw.erty"
return str:match("(%l%l)%.")