История изменений

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам. Из них же пересобираются строки.

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = «0302 tree tree house 990 950»

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:

function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

Допустим, зранение чисто блоковое:

tbl = "1006 tree house 950550"

То есть перввый объект 10 символов, второй объект 6 символов. Но тогда читать стринг.сабом… Хмм

Сервер ребутается раз в сутки, не думаю что даже при частой работе хранящиеся объекты станут большой проблемой.\

Или же по переменной на объект вообще, смотри:

objects = "02 house tree" -- два объекта по 5 символов
hp = "02 950550" -- два объекта по 3 символа

Вопросы лишь - чем обрабатывать лучше…

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам. Из них же пересобираются строки.

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = «0302 tree tree house 990 950»

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:

function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

Допустим, зранение чисто блоковое:

tbl = "1006 tree house 950550"

То есть перввый объект 10 символов, второй объект 6 символов. Но тогда читать стринг.сабом… Хмм

Сервер ребутается раз в сутки, не думаю что даже при частой работе хранящиеся объекты станут большой проблемой.\

Или же по переменной на объект вообще, смотри:

objects = "02 house tree" -- два объекта по 5 символов
hp = "02 950550" -- два объекта по 3 символа

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам. Из них же пересобираются строки.

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = «0302 tree tree house 990 950»

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:

function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

Допустим, зранение чисто блоковое:

tbl = "1006 tree house 950550"

То есть перввый объект 10 символов, второй объект 6 символов. Но тогда читать стринг.сабом… Хмм

Сервер ребутается раз в сутки, не думаю что даже при частой работе хранящиеся объекты станут большой проблемой.\

Или же по переменной на объект вообще, смотри:

objects = «02 house tree» – два объекта по 5 символов hp = «02 950550» – два объекта по 3 символа

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам. Из них же пересобираются строки.

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = «0302 tree tree house 990 950»

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:

function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

Допустим, зранение чисто блоковое:

tbl = "1006 tree house 950550"

То есть перввый объект 10 символов, второй объект 6 символов. Но тогда читать стринг.сабом… Хмм

Сервер ребутается раз в сутки, не думаю что даже при частой работе хранящиеся объекты станут большой проблемой.

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам. Из них же пересобираются строки.

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = «0302 tree tree house 990 950»

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:

function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

?

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:

tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам.  Из них же пересобираются строки. 

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = "0302 tree tree house 990 950"

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:
```lua
function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

?

Сейчас у меня так:

tbl = {
    ["объекты] = {
        ['1'] = "tree",
        ['2'] = 'house'
    {,
    ['целостность'] = {
        ['1'] = 990,
        ['2'[ = 550
    }
{

То есть у каждого пользователя несколько таблиц по 100 объектов. Получается от 6 подтаблиц, в теории больше гораздо. В каждой подтаблице стринговый ключ - сто штук. В каждом ключе по сто интов или стрингов.

Я же хочу так:
```lua
tbl = "0202 tree house 990 550"

Что мы видим? Мы читаем первый блок строки: 1006. По байту на адрес. То есть первый адрес 02. Два слова в первом объекте. Добавляем эти слова в кэш таблицу. Смотрим второй адрес - там тоже два слова. Добавляем два слова в следущую таблицу. Это временные таблицы. Они используются для каждого обращения к строкам.  Из них же пересобираются строки. 

Берем кэш таблицу и формируем из нее строку: в первой таблице три слова стало? Мы ее работали? Ок, тогда tbl = "03

Во второй два осталось? Ок, tbl - "0302

дальше записываем обратно: tbl = "0302 tree tree house 990 950"

А теперь скажи мне, что менее ресурсозатратно - хранить все сплошняком без разделителей и получать данные через string.sub или хранить с разделителем через пробел и получать через функцию:
```lua
function mysplit (inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t={}
	for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
		table.insert(t, str)
	end
	return t
end

?