Что такое шаблонизатор: Вся правда о шаблонизаторах / Хабр

 app.get('/', (req, res) => {
  res. render('index', { title: 'Привет', message: 'Привет!' })
})
 

Когда вы делаете запрос на домашнюю страницу, файл index.pug будет отображаться как HTML.

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

Чтобы узнать больше о том, как механизмы шаблонов работают в Express, см.: «Разработка шаблонизаторов для Express».

Как работает механизм шаблонов — Письма Шипэн Фэна

написано Шипэн Фэн на 2016-08-01

Я давно пользуюсь шаблонизаторами и наконец нашел время найти как работает шаблонизатор.

Введение

Вкратце, механизм шаблонов — это инструмент, который можно использовать для выполнения задач программирования. с большим количеством текстовых данных. Наиболее распространенное использование — генерация HTML в веб-приложениях. В частности, в Python у нас есть несколько вариантов прямо сейчас.

Прежде чем мы перейдем к деталям реализации, давайте сначала рассмотрим простое использование API:

 из шаблона импорта торнадо
СТРАНИЦА_HTML = """

  Привет, {{ имя пользователя }}!
  <ул>
    {% для работы в job_list %}
      
{{ задание }}
    {% конец %}
  

"""
т = шаблон.Шаблон(PAGE_HTML)
распечатать t.generate (имя пользователя = 'Джон', job_list = ['инженер'])
 

Здесь имя пользователя будет динамическим в html странице, так же как и список вакансий. Ты можно установить

Реализация

Если мы внимательно посмотрим на PAGE_HTML , мы легко обнаружим, что строка шаблона состоит из двух частей: статической текстовой части и динамической части. Мы используем спец. обозначение для выделения динамической части. В целом, шаблонизатор должен возьмите строку шаблона и выведите статическую часть как есть, для этого также необходимо обрабатывать динамические части с заданным контекстом и давать правильный строковый результат. Таким образом, в основном механизм шаблонов — это всего лишь одна функция Python:

 def template_engine(template_string, **контекст):
    # процесс здесь
    вернуть результат_строка
 

Во время процедуры обработки шаблонизатор имеет две фазы:

• парсинг
• визуализация

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

Компиляция

Как было сказано выше, теперь нам нужно проанализировать строку шаблона и инструмент анализа в Модуль шаблонов торнадо компилирует шаблоны в код Python. Наш инструмент для разбора просто одна функция Python, которая выполняет генерацию кода Python:

 def parse_template(template_string):
    # компиляция
    вернуть python_source_code
 

Прежде чем мы перейдем к реализации parse_template , давайте посмотрим код производит, вот пример исходной строки шаблона:

 
  Привет, {{ имя пользователя }}!
  <ул>
    {% для работы в работах %}
      
{{ job.name }}
    {% конец %}
  

 

Наша функция parse_template скомпилирует этот шаблон в код Python, который только одна функция, упрощенная версия:

 def _execute():
    _буфер = []
    _buffer. append('\n\n Привет, ')
    _tmp = имя пользователя
    _buffer.append (ул (_tmp))
    _buffer.append('!\n 
\n ')
    на работу в вакансии:
        _buffer.append('\n 
')
        _tmp = задание.имя
        # упрощено, здесь нужно сделать несколько проверок _tmp
        _buffer.append (ул (_tmp))
        _buffer.append('
\n')
    _buffer.append('\n 
\n\n')
    вернуть ''.join(_buffer)
 

Теперь наш шаблон анализируется в функцию с именем _execute , доступ к этой функции все переменные контекста из глобального пространства имен. Эта функция создает список строк и соедините их вместе как результирующую строку. Имя пользователя помещается в локальное имя _tmp , поиск локального имени выполняется намного быстрее, чем поиск глобального. Есть другие оптимизации, которые можно выполнить здесь, например:

 _buffer.append('hello')
_append_buffer = _buffer.append
# быстрее для многократного использования
_append_buffer('привет')
 

Выражения в {{ . .. }} оцениваются и добавляются к списку строкового буфера. В модуле шаблона торнадо нет ограничений на выражения, которые вы можете включите в свои заявления, если и для блоков будут переведены точно в Python.

Код

Теперь посмотрим на реальную реализацию. Основным интерфейсом, который мы используем, является Класс Template , когда мы создаем один объект Template , мы компилируем строку шаблона и позже мы можем использовать его для визуализации данного контекста. Нам нужно скомпилировать только один раз и вы можете кэшировать объект шаблона где угодно, упрощенная версия конструктора:

 Шаблон класса (объект):
    def __init__(я, template_string):
        self.code = parse_template (template_string)
        self.compiled = compile(self.code, '', 'exec')
 

Компиляция скомпилирует исходный код в объект кода. Мы можем выполнить это позже с оператором exec . Теперь давайте создадим функцию parse_template , во-первых, нам нужно разобрать нашу строку шаблона в список узлов, которые знают как сгенерировать код Python, нам нужна функция с именем _parse , мы увидим функция позже, сейчас нам нужны помощники, чтобы помочь с чтением шаблона файл, у нас есть класс _TemplateReader , который обрабатывает чтение для нас, когда мы использовать файл шаблона. Нам нужно начать с самого начала и идти вперед чтобы найти некоторые специальные обозначения, _TemplateReader сохранит текущую позицию и дайте нам способы сделать это:

 class _TemplateReader(object):
    def __init__(я, текст):
        селф.текст = текст
        селф.поз = 0
    def найти (я, игла, начало = 0, конец = нет):
        позиция = self.pos
        старт += поз.
        если конец равен None:
            index = self.text.find (игла, начало)
        еще:
            конец += поз.
            index = self.text.find (игла, начало, конец)
        если индекс != -1:
            индекс -= позиция
        возвращаемый индекс
    защита потребления (я, количество = нет):
        если количество равно None:
            count = len(self.text) - self.pos
        newpos = self.pos + количество
        s = self.text[self.pos:newpos]
        self.pos = новая позиция
        вернуть с
    оставшаяся защита (я):
        вернуть len(self.text) - self.pos
    защита __len__(я):
        вернуть self. remaining()
    def __getitem__(я, ключ):
        если ключ <0:
            вернуть self.text[ключ]
        еще:
            вернуть self.text[self.pos + ключ]
    защита __str__(я):
        вернуть self.text[self.pos:]
 

Чтобы помочь с созданием кода Python, нам нужен класс _CodeWriter , этот класс пишет строки кода и управляет отступами, также это один контекстный менеджер Python:

 class _CodeWriter(object):
    защита __init__(сам):
        self.buffer = cStringIO.StringIO()
        self._indent = 0
    деф отступ(сам):
        вернуть себя
    определение indent_size (я):
        вернуть self._indent
    защита __enter__(сам):
        self._indent += 1
        вернуть себя
    def __exit__(я, *аргументы):
        self._indent -= 1
    def write_line (я, строка, отступ = нет):
        если отступ == Нет:
            отступ = self._indent
        для я в xrange (отступ):
            self.buffer.write(" ")
        print >> self.buffer, строка
    защита __str__(я):
        вернуть self. buffer.getvalue()
 

В начале parse_template мы сначала создаем одну программу чтения шаблонов:

 def parse_template(template_string):
    читатель = _TemplateReader (template_string)
    file_node = _File (_parse (читатель))
    писатель = _CodeWriter()
    file_node.generate(писатель)
    вернуть ул (писатель)
 

Затем мы передаем считыватель функции _parse и получаем список узлов. Все эти узлы являются дочерними узлами узла файла шаблона. Мы создаем один объект CodeWriter, файловый узел записывает код Python в CodeWriter, и мы возвращаем сгенерированный код Python. _Node класс будет обрабатывать Python генерация кода для конкретного случая, мы увидим это позже. Теперь вернемся к нашему _parse функция:

 def _parse(reader, in_block=None):
    тело = _ChunkList([])
    пока верно:
        # Найти следующую директиву шаблона
        кудрявый = 0
        пока верно:
            кудрявый = reader. find("{", кудрявый)
            если curly == -1 или curly + 1 == reader.remaining():
                # конец файла
                если в_блоке:
                    поднять ParseError("Отсутствует блок {%% end %%} для %s" %
                                     in_block)
                body.chunks.append(_Text(reader.consume()))
                вернуть тело
            # Если первая фигурная скобка не является началом специального токена,
            # начать поиск с символа после него
            если читатель [кудрявый + 1] не в ("{", "%"):
                кудрявый += 1
                продолжать
            # Если подряд более 2 завитушек, используйте
            # самые внутренние. Это полезно при создании языков
            # как латекс, где завитки также имеют смысл
            если (curly + 2 < reader.remaining() и
                читатель [кудрявый + 1] == '{' и читатель [кудрявый + 2] == '{'):
                кудрявый += 1
                продолжать
            перерыв
 

Мы зацикливаемся, чтобы найти директиву шаблона в оставшемся файле, если мы достигнем конец файла, мы добавляем текстовый узел и выходим, иначе мы нашли одна директива шаблона.

 # Добавить любой текст перед специальным токеном
        если фигурные > 0:
            body.chunks.append(_Text(reader.consume(curly)))
 

Перед обработкой специального токена мы добавляем текстовый узел, если есть статическая часть.

 start_brace = reader.consume(2)
 

Получить нашу стартовую фигурную скобку, если она должна быть '{{' или '{%' .

 # Выражение
        если start_brace == "{{":
            конец = читатель.найти("}}")
            если end == -1 или reader.find("\n", 0, end) != -1:
                поднять ParseError("Отсутствует конечное выражение }}")
            содержимое = читатель.consume(конец).strip()
            читатель.consume(2)
            если не содержание:
                поднять ParseError("Пустое выражение")
            body.chunks.append(_Expression(содержимое))
            продолжать
 

Начальная фигурная скобка '{{' , и здесь у нас есть выражение, просто получите содержимое выражения и добавить один узел _Expression .

 # Блок
        утверждать start_brace == "{%", start_brace
        конец = читатель.найти("%}")
        если end == -1 или reader.find("\n", 0, end) != -1:
            поднять ParseError("Отсутствует конечный блок %}")
        содержимое = читатель.consume(конец).strip()
        читатель.consume(2)
        если не содержание:
            поднять ParseError("Пустой тег блока ({% %})")
        оператор, пробел, суффикс = содержимое.раздел(" ")
        # Конечный тег
        если оператор == "конец":
            если не в_блоке:
                поднять ParseError("Дополнительный блок {% end %}")
            вернуть тело
        оператор elif в ("попробуй", "если", "для", "пока"):
            # рекурсивно анализируем внутреннее тело
            block_body = _parse (читатель, оператор)
            блок = _ControlBlock (содержимое, блок_тело)
            body.chunks.append(блок)
            продолжать
        еще:
            поднять ParseError("неизвестный оператор: %r" % оператор)
 

Здесь у нас есть блок, обычно мы получаем тело блока рекурсивно и добавляем узел _ControlBlock , тело блока должно быть списком узлов. Если мы столкнемся an {% end %} , блок заканчивается, и мы выходим из функции.

Пришло время узнать секреты класса _Node , это довольно просто:

 class _Node(object):
    def сгенерировать (я, писатель):
        поднять NotImplementedError()
 

 класс _ChunkList(_Node):
    def __init__(я, куски):
        self.chunks = куски
    def сгенерировать (я, писатель):
        для чанка в self.chunks:
            chunk.generate(писатель)
 

A _ChunkList — это просто список узлов.

 класс _File(_Node):
    def __init__(я, тело):
        самотело = тело
    def сгенерировать (я, писатель):
        Writer.write_line("def _execute():")
        с автором.indent():
            писатель.write_line("_buffer = []")
            self.body.generate (писатель)
            Writer.write_line("возврат ''.join(_buffer)")
 

Узел _File записывает функцию _execute в CodeWriter.

 класс _Expression(_Node):
    def __init__(я, выражение):
        self. expression = выражение
    def сгенерировать (я, писатель):
        Writer.write_line("_tmp = %s" % self.expression)
        писатель.write_line("_buffer.append(str(_tmp))")
класс _Text(_Node):
    def __init__(я, значение):
        самостоятельная ценность = ценность
    def сгенерировать (я, писатель):
        значение = собственное значение
        если значение:
            Writer.write_line('_buffer.append(%r)'% значение)
 

_Текст 9Узел 0016 и _Expression также очень прост, просто добавьте то, что вы получить из источника шаблона.

 класс _ControlBlock(_Node):
    def __init__(я, оператор, тело = нет):
        self.statement = заявление
        самотело = тело
    def сгенерировать (я, писатель):
        Writer.write_line("%s:" % self.statement)
        с автором.indent():
            self.body.generate (писатель)
 

Для узла _ControlBlock нам нужно сделать отступ и написать список дочерних узлов с помощью отступ.

Теперь вернемся к части рендеринга, мы рендерим контекст, используя generate метод объекта Template , генерирует функцию , просто вызывая скомпилированный Python код:

 def generate(self, **kwargs):
 пространство имен = {}
 namespace.
No related posts.