Looker: Avoiding Code Repetition in HTML Parameters in Views

Parameterizing Your HTML

So, how do you avoid code repetition in Looker? The answer lies in parameterizing your HTML using Looker’s built-in features. One of the most powerful tools at your disposal is the {{ syntax, which allows you to inject data into your HTML.

  
    {{ my_parameter }}
  

This syntax tells Looker to replace the {{ my_parameter }} placeholder with the actual value of the my_parameter parameter. But how do you define this parameter in the first place?

Defining Parameters in Your Model

In your Looker model, you can define parameters using the parameter keyword. For example:

  
    parameter: my_parameter {
      type: string
    }
  

This code defines a string parameter called my_parameter. You can then use this parameter in your views to inject dynamic data.

Using HTML Parameters in Your Views

Now that you’ve defined your parameter, it’s time to use it in your view. Let’s say you have a view that looks like this:

  
    view: my_view {
      sql_table_name: my_table ;;
      dimension: my_column ;;
      html: {
        h1: {{ my_parameter }}
      }
    }
  

In this example, the {{ my_parameter }} placeholder is used to inject the value of the my_parameter parameter into the h1 HTML element.

Reducing Code Repetition with Macros

Macros are reusable code blocks that can help you avoid repetition in your views. In Looker, you can define a macro using the macro keyword:

  
    macro: my_macro {
      html: {
        h1: {{ my_parameter }}
        p: This is a reusable code block!
      }
    }
  

Once you’ve defined your macro, you can use it in multiple views to avoid repeating the same code:

  
    view: my_view_1 {
      sql_table_name: my_table_1 ;;
      dimension: my_column_1 ;;
      html: {{ my_macro }}
    }

    view: my_view_2 {
      sql_table_name: my_table_2 ;;
      dimension: my_column_2 ;;
      html: {{ my_macro }}
    }
  

By using macros, you can reduce code repetition and make your views more maintainable.

Using Tables to Avoid Repetition

Another way to avoid code repetition is to use tables to store reusable data. In Looker, you can create a table that stores a list of values:

  
    view: my_table {
      column: my_column {
        data_type: string
        values: [
          "Value 1",
          "Value 2",
          "Value 3"
        ]
      }
    }
  

Once you’ve defined your table, you can use it in your views to inject dynamic data:

  
    view: my_view {
      sql_table_name: my_table ;;
      dimension: my_column ;;
      html: {
        ul {
          {{ my_table.values | each }} {
            li: {{ . }}
          }
        }
      }
    }
  

In this example, the {{ my_table.values | each }} syntax is used to iterate over the values in the my_table table and inject them into the HTML.

Best Practices for Avoiding Code Repetition

Now that you’ve learned the techniques for avoiding code repetition in Looker, here are some best practices to keep in mind:

1. Keep it DRY (Don’t Repeat Yourself)**: This is the golden rule of coding. If you find yourself writing the same code over and over, take a step back and think about how you can avoid repetition.
2. Use parameters and macros**: Looker’s built-in features can help you avoid code repetition. Use parameters to inject dynamic data and macros to define reusable code blocks.
3. Keep your code organized**: Break up your code into smaller, reusable components. This will make it easier to maintain and update your views.
4. Test and iterate**: Don’t be afraid to experiment and try new things. Test your code and iterate on your solutions to find the best approach.