What Is Templating and how to use it in JavaScript?
Tags: webdev, javascript, beginners, frontend
Published: 2023-09-04 16:36:05

In the context of programming and web development, `templating `refers to the process of creating a reusable format or layout for presenting data in a consistent manner.

`Templates` typically include placeholders or variables that can be dynamically filled with data, allowing the same template to be used for multiple instances of similar content. For example, in web development, templates are often used to define the structure and layout of web pages, with placeholders for content that will vary depending on the page being displayed.

Templates can be used in a variety of programming languages and frameworks, and they are particularly useful for creating dynamic web pages or generating reports with consistent formatting. They help developers save time and ensure consistency by separating the presentation layer from the business logic and data processing.

## Why to use Templates ?

Templating serves several important purposes, and here are some of the key reasons why we use templating in JavaScript:

**1. Dynamic Content Generation:** Templating allows you to create dynamic web pages or user interfaces by inserting data into predefined templates. This is especially important for web applications where data changes frequently, such as social media feeds, e-commerce product listings, or news articles.

**2. Separation of Concerns:** Templating promotes a separation of concerns between the data and the presentation. By keeping the HTML markup and JavaScript code separate, it's easier to manage and maintain code. Developers can focus on the structure and logic of the template, while data can be manipulated independently.

**3. Code Reusability:** Templates can be reused across different parts of a web application or even in different applications. This reduces code duplication and helps maintain consistency in the user interface.

**4. Improved Performance:** Templating engines often include optimizations to render content efficiently, which can lead to better performance compared to manually manipulating the DOM. Templating engines can update only the parts of the page that change, minimizing unnecessary DOM manipulation.

**5. Security:** Templating can help mitigate security risks such as cross-site scripting (XSS) attacks by automatically escaping or sanitizing user-generated content before rendering it in the template.

**6. Readability and Maintainability:** Templating code tends to be more readable and maintainable compared to generating HTML strings using concatenation. Templates provide a clear structure for representing the intended output.

**7. Accessibility:** Templating can be used to ensure that generated HTML includes proper accessibility attributes and semantic elements, making web applications more accessible to users with disabilities.

There are various JavaScript templating libraries and frameworks available, such as Handlebars, Mustache, Pug, EJS, and more, each with its own syntax and features.

**Example:**

Here's an example of how to use the Handlebars.js templating library to create and render a simple template:

- First, include the Handlebars.js library in your project:

```html
<script    
src="https://cdnjs.cloudflare.com/ajax/libs/handlebars.js/4.7.6/handleb ars.min.js">
</script>

```

- Create a template using Handlebars syntax:

```html
<script id="my-template" type="text/x-handlebars-template">
  <h1>{{title}}</h1>
  <p>{{description}}</p>
</script>

```

- Compile the template using Handlebars:

```javascript
const template = Handlebars.compile(document.querySelector('#my-template').innerHTML);

```

- Define some data to populate the template:

```javascript
const data = {
  title: 'My Template',
  description: 'This is a Handlebars template example.'
};

```

- Render the template with the data:

```javascript
const renderedTemplate = template(data);
document.querySelector('#output').innerHTML = renderedTemplate;

```
In this example, we created a simple Handlebars template that includes two placeholders for data: `{{title}}` and `{{description}}`. We then compiled the template using `Handlebars.compile`, defined some data to populate the template, and finally rendered the template with the data using the compiled template function.

The rendered template is then inserted into an element with the ID "output" in the HTML document.

Here's the demo code:

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/handlebars.js/4.7.6/handlebars.min.js"></script>
  </head>
  <body>
    <div id="output"></div>
    <script id="my-template" type="text/x-handlebars-template">
      <h1>{{title}}</h1>
      <p>{{description}}</p>
    </script>

    <script>
      const data = {
        title: "Endeavour Monk",
        description: "Please like ❤️ this article and follow for more contents",
      };
      const template = Handlebars.compile(
        document.querySelector("#my-template").innerHTML
      );
      const renderedTemplate = template(data);
      document.querySelector("#output").innerHTML = renderedTemplate;
    </script>
  </body>
</html>

```

![Output](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/l5xt767xbu3566lftz3g.png)

Thanks for reading.