Объектные модели на таблицах — бесплатный тест онлайн

Вопрос 1 из 20

Какое правило Lua нужно применить, чтобы верно прочитать этот фрагмент? Ответ должен описывать основной механизм раздела «Прототип».

local Account = {}
Account.__index = Account
function Account:deposit(v) self.balance = self.balance + v end
local a=setmetatable({balance=10},Account)
a:deposit(5)
print(a.balance)

При разборе раздела «Прототип» здесь действует условие: Любой код с ссылкой на таблицу может читать её открытые ключи. При разборе раздела «Прототип» здесь действует условие: Прототипное поведение обычно строят через __index на таблицу методов. При разборе раздела «Прототип» здесь действует условие: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. При разборе раздела «Прототип» здесь действует условие: Композиция часто яснее для независимых возможностей. При разборе раздела «Прототип» здесь действует условие: Двоеточие лишь передаёт self и не создаёт объект автоматически.

Вопрос 2 из 20

Первый пример подтверждает основной путь. Что проверить отдельно? Ищется граничное следствие правила из раздела «Прототип».

local function reproduce_case()
  local Account = {}
  Account.__index = Account
  function Account:deposit(v) self.balance = self.balance + v end
  local a=setmetatable({balance=10},Account)
  a:deposit(5)
  print(a.balance)
end
reproduce_case()

Скрытая граница раздела «Прототип» проявляется так: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Скрытая граница раздела «Прототип» проявляется так: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Скрытая граница раздела «Прототип» проявляется так: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Скрытая граница раздела «Прототип» проявляется так: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Скрытая граница раздела «Прототип» проявляется так: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.

Вопрос 3 из 20

Внутреннюю реализацию меняют. Что обязано остаться верным снаружи? Выберите гарантию, определяющую раздел «Прототип».

do
  local Account = {}
  Account.__index = Account
  function Account:deposit(v) self.balance = self.balance + v end
  local a=setmetatable({balance=10},Account)
  a:deposit(5)
  print(a.balance)
end

Внешнее поведение раздела «Прототип» сохраняется при условии: Прототипное поведение обычно строят через __index на таблицу методов. Внешнее поведение раздела «Прототип» сохраняется при условии: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. Внешнее поведение раздела «Прототип» сохраняется при условии: Композиция часто яснее для независимых возможностей. Внешнее поведение раздела «Прототип» сохраняется при условии: Двоеточие лишь передаёт self и не создаёт объект автоматически. Внешнее поведение раздела «Прототип» сохраняется при условии: Любой код с ссылкой на таблицу может читать её открытые ключи.

Вопрос 4 из 20

После редкого сбоя команда спорит о разделе «Прототип». Какой вывод должен попасть в код и тесты? Выберите практическое следствие раздела «Прототип».

При сопровождении раздела «Прототип» опираются на следующее: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. При сопровождении раздела «Прототип» опираются на следующее: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. При сопровождении раздела «Прототип» опираются на следующее: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. При сопровождении раздела «Прототип» опираются на следующее: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. При сопровождении раздела «Прототип» опираются на следующее: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически.

Вопрос 5 из 20

Что нельзя вывести из одного удачного примера, но нужно знать о разделе «Прототип»? Ответ должен охватывать весь раздел «Прототип».

Весь контракт раздела «Прототип» сводится к следующему: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Весь контракт раздела «Прототип» сводится к следующему: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Весь контракт раздела «Прототип» сводится к следующему: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Весь контракт раздела «Прототип» сводится к следующему: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Весь контракт раздела «Прототип» сводится к следующему: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.

Вопрос 6 из 20

Что из перечисленного относится именно к показанному фрагменту? Ответ должен описывать основной механизм раздела «Конструктор».

local User = {}
User.__index = User
function User.new(name)
  assert(type(name)=="string" and name~="")
  return setmetatable({name=name},User)
end
print(User.new("Ana").name)

В показанном фрагменте раздела «Конструктор» важно следующее: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов. В показанном фрагменте раздела «Конструктор» важно следующее: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. В показанном фрагменте раздела «Конструктор» важно следующее: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. В показанном фрагменте раздела «Конструктор» важно следующее: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. В показанном фрагменте раздела «Конструктор» важно следующее: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.

Вопрос 7 из 20

Первый пример подтверждает основной путь. Что проверить отдельно? Ищется граничное следствие правила из раздела «Конструктор».

local function reproduce_case()
  local User = {}
  User.__index = User
  function User.new(name)
    assert(type(name)=="string" and name~="")
    return setmetatable({name=name},User)
  end
  print(User.new("Ana").name)
end
reproduce_case()

Граничный тест раздела «Конструктор» должен показать: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Граничный тест раздела «Конструктор» должен показать: Двоеточие лишь передаёт self и не создаёт объект автоматически. Граничный тест раздела «Конструктор» должен показать: Прототипное поведение обычно строят через __index на таблицу методов. Граничный тест раздела «Конструктор» должен показать: Композиция часто яснее для независимых возможностей. Граничный тест раздела «Конструктор» должен показать: Любой код с ссылкой на таблицу может читать её открытые ключи.

Вопрос 8 из 20

Какая гарантия важнее сохранения точной формы кода? Речь идёт о центральном правиле раздела «Конструктор».

do
  local User = {}
  User.__index = User
  function User.new(name)
    assert(type(name)=="string" and name~="")
    return setmetatable({name=name},User)
  end
  print(User.new("Ana").name)
end

Регрессионный контракт раздела «Конструктор» требует: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов. Регрессионный контракт раздела «Конструктор» требует: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Регрессионный контракт раздела «Конструктор» требует: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Регрессионный контракт раздела «Конструктор» требует: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Регрессионный контракт раздела «Конструктор» требует: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием.

Вопрос 9 из 20

Новый интерфейс скрывает детали раздела «Конструктор». Что всё равно должно быть явно проверяемо? Выберите практическое следствие раздела «Конструктор».

Граница эксплуатации раздела «Конструктор» формулируется так: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Граница эксплуатации раздела «Конструктор» формулируется так: Композиция часто яснее для независимых возможностей. Граница эксплуатации раздела «Конструктор» формулируется так: Любой код с ссылкой на таблицу может читать её открытые ключи. Граница эксплуатации раздела «Конструктор» формулируется так: Двоеточие лишь передаёт self и не создаёт объект автоматически. Граница эксплуатации раздела «Конструктор» формулируется так: Прототипное поведение обычно строят через __index на таблицу методов.

Вопрос 10 из 20

Какое правило раздела «Конструктор» стоит закрепить в тестах? Ответ должен охватывать весь раздел «Конструктор».

Рабочее правило всего раздела «Конструктор»: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Рабочее правило всего раздела «Конструктор»: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Рабочее правило всего раздела «Конструктор»: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. Рабочее правило всего раздела «Конструктор»: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Рабочее правило всего раздела «Конструктор»: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе.

Вопрос 11 из 20

Какое правило точнее всего описывает происходящее в строке «local Player=setmetatable({}, {__index=Entity}); Player.__index=Player»? Выберите основное правило раздела «Наследование».

local Entity={}; Entity.__index=Entity
function Entity:kind() return "entity" end
local Player=setmetatable({}, {__index=Entity}); Player.__index=Player
function Player:kind() return "player" end
local p=setmetatable({},Player)
print(p:kind())

Для этого кода в разделе «Наследование» нужно учитывать: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Для этого кода в разделе «Наследование» нужно учитывать: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Для этого кода в разделе «Наследование» нужно учитывать: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Для этого кода в разделе «Наследование» нужно учитывать: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Для этого кода в разделе «Наследование» нужно учитывать: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей.

Вопрос 12 из 20

Какой крайний случай важнее всего добавить к проверке? Ищется граничное следствие правила из раздела «Наследование».

local function reproduce_case()
  local Entity={}; Entity.__index=Entity
  function Entity:kind() return "entity" end
  local Player=setmetatable({}, {__index=Entity}); Player.__index=Player
  function Player:kind() return "player" end
  local p=setmetatable({},Player)
  print(p:kind())
end
reproduce_case()

Регрессионная проверка раздела «Наследование» наблюдает следующее: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Регрессионная проверка раздела «Наследование» наблюдает следующее: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Регрессионная проверка раздела «Наследование» наблюдает следующее: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Регрессионная проверка раздела «Наследование» наблюдает следующее: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Регрессионная проверка раздела «Наследование» наблюдает следующее: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически.

Вопрос 13 из 20

Какой контракт отличит эквивалентный рефакторинг от тихой поломки? Выберите гарантию, определяющую раздел «Наследование».

Регрессионный контракт раздела «Наследование» требует: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Регрессионный контракт раздела «Наследование» требует: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Регрессионный контракт раздела «Наследование» требует: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Регрессионный контракт раздела «Наследование» требует: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Регрессионный контракт раздела «Наследование» требует: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.

Вопрос 14 из 20

Нужно сделать поведение «Наследование» предсказуемым для следующего разработчика. Что выбрать? Нужна эксплуатационная граница раздела «Наследование».

Для диагностируемого решения раздела «Наследование» требуется: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Для диагностируемого решения раздела «Наследование» требуется: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Для диагностируемого решения раздела «Наследование» требуется: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Для диагностируемого решения раздела «Наследование» требуется: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Для диагностируемого решения раздела «Наследование» требуется: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи.

Вопрос 15 из 20

Какое правило лучше всего описывает границы раздела «Наследование»? Нужна полная формулировка раздела «Наследование».

Рабочее правило всего раздела «Наследование»: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Рабочее правило всего раздела «Наследование»: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Рабочее правило всего раздела «Наследование»: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Рабочее правило всего раздела «Наследование»: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Рабочее правило всего раздела «Наследование»: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи.

Вопрос 16 из 20

Что нельзя заменить привычкой из другого языка при чтении этого кода? Ответ должен описывать основной механизм раздела «Инкапсуляция».

local function new_wallet(start)
  local balance = start
  return {get=function() return balance end,
          debit=function(v) assert(v>=0 and v<=balance); balance=balance-v end}
end
local w=new_wallet(20); w.debit(7); print(w.get())

Строку из раздела «Инкапсуляция» нужно читать так: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. Строку из раздела «Инкапсуляция» нужно читать так: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты. Строку из раздела «Инкапсуляция» нужно читать так: Прототипное поведение обычно строят через __index на таблицу методов. Строку из раздела «Инкапсуляция» нужно читать так: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Строку из раздела «Инкапсуляция» нужно читать так: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов.

Вопрос 17 из 20

Какая проверка отделит устойчивый контракт от удачного совпадения? Ищется граничное следствие правила из раздела «Инкапсуляция».

local function reproduce_case()
  local function new_wallet(start)
    local balance = start
    return {get=function() return balance end,
            debit=function(v) assert(v>=0 and v<=balance); balance=balance-v end}
  end
  local w=new_wallet(20); w.debit(7); print(w.get())
end
reproduce_case()

Повторный запуск в разделе «Инкапсуляция» должен выявить: Любой код с ссылкой на таблицу может читать её открытые ключи. Повторный запуск в разделе «Инкапсуляция» должен выявить: Композиция часто яснее для независимых возможностей. Повторный запуск в разделе «Инкапсуляция» должен выявить: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Повторный запуск в разделе «Инкапсуляция» должен выявить: Прототипное поведение обычно строят через __index на таблицу методов. Повторный запуск в разделе «Инкапсуляция» должен выявить: Двоеточие лишь передаёт self и не создаёт объект автоматически.

Вопрос 18 из 20

Какой результат обязан подтверждать регрессионный тест после правки? Речь идёт о центральном правиле раздела «Инкапсуляция».

При замене внутренних шагов раздела «Инкапсуляция» остаётся гарантия: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. При замене внутренних шагов раздела «Инкапсуляция» остаётся гарантия: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов. При замене внутренних шагов раздела «Инкапсуляция» остаётся гарантия: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием. При замене внутренних шагов раздела «Инкапсуляция» остаётся гарантия: Прототипное поведение обычно строят через __index на таблицу методов. При замене внутренних шагов раздела «Инкапсуляция» остаётся гарантия: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.

Вопрос 19 из 20

В проекте пересматривают «Инкапсуляция». Какое правило лучше выразить в интерфейсе, а не оставлять устной договорённостью? Выберите практическое следствие раздела «Инкапсуляция».

Рабочий контракт раздела «Инкапсуляция» делает наблюдаемым: Композиция часто яснее для независимых возможностей. Рабочий контракт раздела «Инкапсуляция» делает наблюдаемым: Двоеточие лишь передаёт self и не создаёт объект автоматически. Рабочий контракт раздела «Инкапсуляция» делает наблюдаемым: Экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Рабочий контракт раздела «Инкапсуляция» делает наблюдаемым: Любой код с ссылкой на таблицу может читать её открытые ключи. Рабочий контракт раздела «Инкапсуляция» делает наблюдаемым: Прототипное поведение обычно строят через __index на таблицу методов.

Вопрос 20 из 20

Что следует считать рабочим контрактом раздела «Инкапсуляция»? Выберите описание, объединяющее механизм и границу раздела «Инкапсуляция».

Раздел «Инкапсуляция» корректно описывает утверждение: Инкапсуляцию обеспечивают модули, замыкания и ограниченный интерфейс, а не имя поля с подчёркиванием; любой код с ссылкой на таблицу может читать её открытые ключи. Раздел «Инкапсуляция» корректно описывает утверждение: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты; двоеточие лишь передаёт self и не создаёт объект автоматически. Раздел «Инкапсуляция» корректно описывает утверждение: Наследование через цепочку __index возможно, но длинные и изменяемые цепочки усложняют поиск методов; композиция часто яснее для независимых возможностей. Раздел «Инкапсуляция» корректно описывает утверждение: Прототипное поведение обычно строят через __index на таблицу методов; экземпляр хранит собственные данные, а отсутствующие методы ищутся в прототипе. Раздел «Инкапсуляция» корректно описывает утверждение: Конструктор на Lua — обычная функция, которая создаёт таблицу, устанавливает метатаблицу и проверяет инварианты.