Cut Boilerplate in Half: Using PhpStorm Live Templates for PHP Developers

Problem: Time‑Consuming Boilerplate

Every PHP developer has a moment when they type the same class skeleton, getters, setters, or Doctrine annotations over and over again. Repetitive typing not only slows you down but also introduces subtle typos that can be hard to spot in large codebases. The goal is to eliminate that friction without sacrificing code readability.

Thesis: Live Templates Turn a Few Keystrokes into Full‑Featured Code

PhpStorm’s Live Templates let you define reusable snippets that expand into context‑aware PHP code. By binding a short keyword to a template and using placeholders, you can generate a fully‑formed block of code in a single Tab press.

1. What Live Templates Are

Live Templates live in Settings/Preferences → Editor → Live Templates. Each template has a keyword, a template text, and a context that controls where it can be used (e.g., PHP files, XML, or HTML). When you type the keyword and hit Tab, the editor replaces the keyword with the template text, automatically moving the cursor to the first placeholder.

The editor’s preview pane shows exactly how the snippet will look once expanded, allowing you to tweak variables and formatting before saving.

2. Crafting a Custom Template

1. Open the Live Templates dialog and click the + button. Choose Live Template.
2. Set a keyword such as entity.
3. In the Template Text field, paste the skeleton you want to generate. Use placeholders like $ENTITY$ and $FIELD$.
4. Click Edit Variables to define each placeholder’s default value or expression. For example, $ENTITY$ can default to MyEntity.
5. Under Applicable in, check PHP and any other relevant contexts.
6. Click Apply and OK.

Below is a minimal template definition for a Doctrine entity skeleton.

<template name="entity" value="

3. Variables and Live Editing

Common placeholders:

Variable	Description
$ENTITY$	Class name (e.g., User)
$NAMESPACE$	Namespace (e.g., App\Entity)
$TABLE$	Database table name (defaults to lowercase class)
$FIELD$	Property block (generated via FIELD variable)
$END$	Cursor position after expansion
$SELECTION$	Selected text to replace

You can also use complete() expressions to generate multiple fields. The Live Template editor’s preview updates in real time, so you can see how changing $ENTITY$ to Product instantly updates the class name, namespace, and table annotation.

4. Worked Example – Doctrine Entity Skeleton

Let’s walk through creating a template that expands into a full Doctrine entity:

1. Open Settings → Editor → Live Templates.
2. Click + → Live Template.
3. Keyword: doctrineEntity.
4. Template Text:

   id$;
       }
   }
   

5. Click Edit Variables and add:
   • $NAMESPACE$ – default: App\\Entity
   • $TABLE$ – expression: toLowerCase($ENTITY$)
   • $FIELDS$ – expression: FIELD (custom logic to generate getters/setters)
   • $END$ – default:
6. Set context to PHP.
7. Apply and close.

Now, in a PHP file, type doctrineEntity and press Tab. The editor will prompt you for $ENTITY$ and $NAMESPACE$, then generate the skeleton. You can quickly add fields by editing the $FIELDS$ placeholder or by creating a second template that expands a single property block.

Trade‑off: Readability vs. Speed

While templates save time, they can obscure intent for newcomers who may not know what a keyword expands to. Keep templates simple, document them in a shared live_templates.xml, and avoid over‑engineering complex logic inside a single snippet.

Actionable Next Steps

• Create a personal template library for common patterns you use (e.g., repository classes, API controllers).
• Export your templates (Settings → Editor → Live Templates → Export) and share the XML file with teammates to keep the team’s IDEs in sync.
• Iterate on the Doctrine entity template by adding field‑generation logic or integrating with Symfony’s Maker Bundle for comparison.
• Test in a real project to ensure the generated code compiles and passes your linter.
• Review when onboarding to make sure new developers understand the shortcuts and can edit the templates if needed.

By investing a few minutes to set up and refine Live Templates, you can reduce repetitive typing, lower the risk of typos, and keep your PHP codebase clean and consistent.