Форум программистов «Весельчак У»
  *
Добро пожаловать, Гость. Пожалуйста, войдите или зарегистрируйтесь.
Вам не пришло письмо с кодом активации?

  • Рекомендуем проверить настройки временной зоны в вашем профиле (страница "Внешний вид форума", пункт "Часовой пояс:").
  • У нас больше нет рассылок. Если вам приходят письма от наших бывших рассылок mail.ru и subscribe.ru, то знайте, что это не мы рассылаем.
   Начало  
Наши сайты
Помощь Поиск Календарь Почта Войти Регистрация  
 
Страниц: 1 [2]  Все   Вниз
  Печать  
Автор Тема: интерпретируемый язык с поддержкой переменных  (Прочитано 37890 раз)
0 Пользователей и 1 Гость смотрят эту тему.
darkelf
Молодой специалист

fr
Offline Offline

« Ответ #30 : 11-07-2013 09:49 » 

Алексей++, типы тоже есть, но вроде и в js тоже с типами плохо, точнее полностью аналогично - базовые типы есть числа, строки и булевские.
Записан
Алексей++
глобальный и пушистый
Глобальный модератор

ru
Offline Offline
Сообщений: 13


« Ответ #31 : 11-07-2013 09:50 » 

Sla, ок
Записан

Sla
Команда клуба

ua
Offline Offline
Пол: Мужской

WWW
« Ответ #32 : 11-07-2013 10:02 » 

на в тикле тоже нет явных типов
Записан

Мы все учились понемногу... Чему-нибудь и как-нибудь.
Алексей++
глобальный и пушистый
Глобальный модератор

ru
Offline Offline
Сообщений: 13


« Ответ #33 : 11-07-2013 10:34 » 

darkelf, даже можно наборы функций добавлять )

Код:
		chunk="function f1(a,b) return a+b end";
luaL_loadbuffer(L, &chunk[0], chunk.size(), 0);
lua_pcall(L,0,0,0);

chunk="function f2(a,b) return a+b+10 end";
luaL_loadbuffer(L, &chunk[0], chunk.size(), 0);
lua_pcall(L,0,0,0);
      

и работает

Записан

darkelf
Молодой специалист

fr
Offline Offline

« Ответ #34 : 11-07-2013 11:33 » 

darkelf, даже можно наборы функций добавлять )

Код:
		chunk="function f1(a,b) return a+b end";
luaL_loadbuffer(L, &chunk[0], chunk.size(), 0);
lua_pcall(L,0,0,0);

chunk="function f2(a,b) return a+b+10 end";
luaL_loadbuffer(L, &chunk[0], chunk.size(), 0);
lua_pcall(L,0,0,0);
      

и работает
можно и зараз множество функций:
Код: (C)
chunk="function f1(a,b) return a+b end ; function f2(a,b) return a+b+10 end";
luaL_loadbuffer(L, &chunk[0], chunk.size(), 0);
lua_pcall(L,0,0,0);
Записан
Dimka
Деятель
Команда клуба

ru
Offline Offline
Пол: Мужской

« Ответ #35 : 11-07-2013 14:38 » 

ООП можно соорудить на чём угодно. В JavaScript и Lua оно одинаковое - безклассовое на замыканиях и ассоциативных массивах.

Насчёт типизированности не понял. Зачем в интерпретируемом языке типизация? Она имеет смыл лишь при компиляции - когда весь текст заранее проверяешь на косяки. Алексей++, ты хочешь иметь раздельные стадии компиляции и исполнения?
Записан

Программировать - значит понимать (К. Нюгард)
Невывернутое лучше, чем вправленное (М. Аврелий)
Многие готовы скорее умереть, чем подумать (Б. Рассел)
Алексей++
глобальный и пушистый
Глобальный модератор

ru
Offline Offline
Сообщений: 13


« Ответ #36 : 17-07-2013 09:48 » 

darkelf, ага, уже понял ) Можно вообще любой синтаксически верный кусок текста добавить

Dimka, пока что потребовалось в таком виде: загружаю в "машину" все функции, по мере необходимости вызываю нужную, передаю ей числовые параметры, получаю ответ, делаю действие.  Уже увидел, что, в принципе, можно все параметры сделать текстовыми.

 Когда компилируется -  думаю, лучше это пусть делается после определения нужных функций (и этим, видимо, как раз и занимается вызов lua_pcall(L,0,0,0)  после загрузки ещё одного куска кода )

замыкания - ага, уже почитал, интересная штука. Но пока ещё в голове нет стройности в том, как организовать класс в привычном виде - с методами . Ещё просто не дошёл до этого места, там разберусь )

А в остальном пока всё устраивает в LUA
Записан

Dimka
Деятель
Команда клуба

ru
Offline Offline
Пол: Мужской

« Ответ #37 : 17-07-2013 19:52 » 

Цитата: Алексей++
Но пока ещё в голове нет стройности в том, как организовать класс в привычном виде - с методами .
Элементарно. Метод - это функция, в контексте которой содержатся переменные объекта (видны ей). В данном случае это переменные внутри замыкания и/или значения (которые не ключи) ассоциативного массива. Функция - это тоже объект, назначенный переменной. Т.е. функцию можно добавить в объект как и любое другое значение - и будут тебе методы Улыбаюсь
Записан

Программировать - значит понимать (К. Нюгард)
Невывернутое лучше, чем вправленное (М. Аврелий)
Многие готовы скорее умереть, чем подумать (Б. Рассел)
Алексей++
глобальный и пушистый
Глобальный модератор

ru
Offline Offline
Сообщений: 13


« Ответ #38 : 19-07-2013 06:37 » 

Dimka,  правильно ли я понимаю ? Попытался описать фабрику класса A

(судя по выводу в консоль, это работает)


Код: (Lua)
-- фабрика экземпляров класса A
function create_class_A()
       
        local this={} --таблица будет содержать переменные и методы экземпляра
       
        this.var=0 -- объявил и инит. переменную var
       
        this.get_var= -- метод, возвращающий var
                function()
                        return this.var
                end
       
        return this
end



function test()

        local a1=create_class_A()
        local a2=create_class_A()

        a1.var=1
        a2.var=2
       
        print(a1:get_var())
        print(a2:get_var())
       
end

> test()
1
2
>
Записан

Dimka
Деятель
Команда клуба

ru
Offline Offline
Пол: Мужской

« Ответ #39 : 19-07-2013 08:42 » 

Алексей++, с уточнением, что внутри объекта есть разница между замыканием и ассоциативным массивом как точкой доступа.
Код: (Lua)
-- конструктор объекта
function createC()

  -- локальные переменные функции createC сохранятся внутри замыкания и не будут видны снаружи
  -- так делаются private члены
  -- чтобы их отличать от public, локальных переменных и аргументов методов, будем им ставить префикс "_"

  -- private поля и сразу их инициализация как в конструкторе, код инициализации может быть произвольной сложности
  local _x = 1

  -- protected static поля - общие для всех объектов
  _Const = 3

  -- private методы
  function _printState()
    print(_x)
  end

  -- ассоциативный массив для создаваемого объекта, являющийся точкой доступа к объекту
  -- содержимое ассоциативного массива хранит public члены объекта
  local self = {}

  -- public поля и сразу их инциализация, например, для объявления доступных снаружи констант, которые будем писать с большой буквы
  self.Const = _Const

  -- public методы
  function self.set(x)
    -- можем работать с private членами, поскольку функция находится в общем замыкании с переменными
    _x = x
    _printState()
  end

  function self.get()
    return _x
  end

  -- конструктор обязательно возвращает ассоциативный массив с открытыми членами объекта
  return self

end

-- использование
o = createC()
-- теперь в переменной o находится ассоциативный массив с открытыми членами объекта,
-- со всеми функциями внутри этого массива связано замыкание конструктора, в котором хранятся закрытые члены объекта
o.set(o.Const)
print(o.get())
3
3
Таким образом, функция createC здесь не вполне фабрика. Она не ограничивается только созданием ассоциативного массива со связанными между собой элементами, она ещё генерирует собственное замыкание с закрытыми внутри него private переменными и вспомогательными функциями и увязывает всю эту конструкцию в единый объект.

Стоит заметить, что конструктор может порождать целую серию ассоциативных массивов, являющихся разными интерфейсами одного и того же объекта. Например
Код: (Lua)
function createProcessor

  local readerInterface = {}
  function readerInterface.read()
    print("read")
  end

  local writerInterface = {}
  function writerInterface.write()
    print("write")
  end

  return readerInterface, writerInterface

end

reader, writer = createProcessor()
reader.read()
writer.write()
read
write

Наследование с полиморфизмом поведения реализуется элементарно. Достаточно получить ассоциативный массив предка и дополнить/переписать его под потомка. При этом private-члены будут свои для каждого конструктора. С одним ассоциативным массивом связывается несколько замыканий: по одному замыканию от каждого конструктора с local-переменными (private) и общее замыкание для всех конструкторов и всех объектов с не local переменными (static protected).

Код: (Lua)
function createParent
  local _x = 1
  _y = 3
  local self = {}
  function self.test()
    print("test")
  end
  function self.foo()
    print("parent")
    print(_x)
    print(_y)
  end
  return self
end

function createChild
  local _x = 2
  local self = createParent()
  function self.foo()
    print("child")
    print(_x)
    print(_y)
  end
  return self
end

p = createParent()
p.test()
p.foo()
c = createChild()
c.test() -- унаследовано от parent
c.foo() -- переопределено, но переменная _y видна из parent и является общей для всех объектов
test
parent
1
3
test
child
2
3

В общем, вот и весь краткий курс безклассового ООП.
« Последнее редактирование: 19-07-2013 09:12 от Dimka » Записан

Программировать - значит понимать (К. Нюгард)
Невывернутое лучше, чем вправленное (М. Аврелий)
Многие готовы скорее умереть, чем подумать (Б. Рассел)
Алексей++
глобальный и пушистый
Глобальный модератор

ru
Offline Offline
Сообщений: 13


« Ответ #40 : 19-07-2013 09:03 » 

по первому блоку кода: я всё так и понял, вроде бы. Только в моём случае все переменные размещались в таблице this, которая будет жить в объекте благодаря замыканию и которая есть эквивалент _x, по сути. С той лишь разницей, что я вернул ссылку на эту приватную таблицу, тем самым разрешив доступ ко всем полям извне. Тут вроде всё понятно

С наследованием тоже понятно, спасибо.  По сути, всё то, что в C++ скрывается синтаксисом, тут как на ладони расписывается ))

Добавлено через 22 минуты и 24 секунды:
а как организовать аналог сишной локальной static переменной в функции ? Глобальная таблица ?

« Последнее редактирование: 19-07-2013 09:25 от Алексей1153 » Записан

Dimka
Деятель
Команда клуба

ru
Offline Offline
Пол: Мужской

« Ответ #41 : 19-07-2013 11:02 » 

Алексей++, нет, в C++ нету замыканий функций. Наоборот, из объектов можно делать аналог функций с замыканиями - функторы: объекты с оператором (). В Lua всё с точностью наоборот: из функций с замыканиями делаются объекты.

Аналога static переменных внутри функций нет. Но через замыкание можно - см. выше переменные внутри конструктора без local. Т.е. в чистом виде это будет просто замыкание без ассоциативных массивов.
Код: (Lua)
f = (function()
  staticVar = 0
  return function()
    staticVar = staticVar + 1
    print(staticVar)
  end
end)()

f()
f()
1
2
Записан

Программировать - значит понимать (К. Нюгард)
Невывернутое лучше, чем вправленное (М. Аврелий)
Многие готовы скорее умереть, чем подумать (Б. Рассел)
Dimka
Деятель
Команда клуба

ru
Offline Offline
Пол: Мужской

« Ответ #42 : 19-07-2013 11:14 » new

Нет, выше я всюду неправ насчёт не local переменных и функция - это просто глобальные переменные и функции, видимые отовсюду. Они не закрыты. Т.е. за пределами объектов такие переменные могут изменить значение, а функции конфликтовать за счёт совпадения имён. Значит нет static protected, бывают только private - это local переменные и функции внутри функций.
« Последнее редактирование: 19-07-2013 21:32 от Dimka » Записан

Программировать - значит понимать (К. Нюгард)
Невывернутое лучше, чем вправленное (М. Аврелий)
Многие готовы скорее умереть, чем подумать (Б. Рассел)
Страниц: 1 [2]  Все   Вверх
  Печать  
 

Powered by SMF 1.1.21 | SMF © 2015, Simple Machines