You know that it plays a key role in displaying (custom) content in Drupal. You know that it shouldn't miss from your toolkit as a Drupal module developer. And yet, it's still unclear to you: what is the Drupal 8 render API more precisely?
How does it work?
When and how do you use it? And how is it any different from Drupal 7's rendering logic?
Let's dig deep for some clear answers, shall we?
1. What Is the Drupal 8 Render API?
A short, yet thorough answer would be:
It's the key part of the process where Drupal displays... something on the user's screen.
And that “something” includes:
- any type of custom content
Now, if we were to elaborate it a bit, we'd end up with this “enlightening”, more detailed answer:
You want to make sure that your theme has the ability to customize the markup of a page. And you well know that writing strings of HTML markup for blocks, pages and other types of output in your modules is... out of question. So, you rely on Drupal 8's rendering logic, which renders structured content under the form of render arrays.
A bit clearer now?
The structured data delivered by the Render API will already incorporate important “clues” on the nature of the contained information and on the way that it should be converted to HTML.
And, most importantly:
In the end, it's your theme layer that will do the HTML rendering. It's your theme that will customize the markup of that page...
Now, to further detail the answer to your “What is Drupal 8 Render API?” question, I'll add that it's mainly a two-part system:
- the structured render arrays, that provide key information on how the data should be rendered
- the render pipeline, that renders the arrays in any output format of your choice (JSON, HTML, etc.)
And I wrote “mainly”, cause there are more elements that make up Drupal 8's rendering logic:
- render elements
- the overall use case of the data rendering system
2. What's Its Role? When Should You Use the Render API?
It improves usability.
“How?” Well, just think about it:
- even if a specific functionality is present on different areas of your website, its markup stays the same... sitewide
- users will then be challenged to recognize fewer UIs
See my point?
And as for the “When should I use it?” part, it depends greatly on whether you're a themer or a module developer:
- you'll use it whenever you need to apply changes to the render arrays and thus to custom-tune the resulting output
- you'll use it whenever you need to display your content in render arrays and to set up new element types (and to customize the rendering pipeline)
In short: every time you write custom code that should output content for the end-users you should be using Render API...
3. Render Arrays: The Fundamental Structure of the Drupal 8 Render API
Take them as:
Representations of the HTML pages on your Drupal 8 website.
And if you find this response too vague, here's a more detailed definition:
A render array is the core building block of Drupal 8's rendering sytem. It contains data to be rendered and key properties indicating how that data should be rendered.
A hierarchical ecosystem of render arrays makes the fundamental structure of the rendering logic itself.
And now, here are just some of their key features:
- the ones determining what content will be displayed to the user, therefore the ones “measuring” responses' level of catchability
- more flexible, easier to modify than stripes
- act as a bridge between the back-end and the front end
- support both altering and nesting (which translates into boosted flexibility)
- can be rendered either as modal dialogues or in JSON (or in other alternate formats)
- incorporate complex components
Note: long gone are the days when the theme() function would rule. We used to call it any time we had to render data on our Drupal 7 websites. Now, thanks to the Drupal 8 Render API, we use render arrays whenever we need to display... anything on users' screens.
4. The Render Pipeline
It's the process that Drupal 8 uses to... render pages. To service an HTTP request and to deliver the appropriate response.
And by “servicing a request” I mean:
- determining the right output format (do keep in mind that the render pipeline is format-agnostic)
- gathering the required data
- converting the data arrays to the required format
- finally, returning a valid response to the initial HTTP request
As a Drupal module developer, you'll see that the whole process happens “backstage”. And still, knowing how the render pipeline operates will help you to use render arrays in your code much more efficiently.
Be honest now: have I managed to shed some light on the Drupal 8 Render API topic?