Template reference for direct access in Angular - Performance & Optimization

Performance: Template reference for direct access

MEDIUM IMPACT

This affects interaction speed and rendering efficiency by reducing the need for extra DOM queries or component lookups.

Accessing a DOM element or component instance directly in the template

Angular

<input #inputRef />
<button (click)="inputRef.focus()">Focus Input</button>

Directly accessing the element via template reference avoids Angular lifecycle overhead and extra DOM queries.

📈 Performance GainImproves INP by reducing event handling delay and avoids extra change detection cycles.

Accessing a DOM element or component instance directly in the template

Angular

import { ElementRef, ViewChild, Component } from '@angular/core';

@Component({ selector: 'app-example', template: `<input #inputRef />` })
export class ExampleComponent {
  @ViewChild('inputRef') inputElement!: ElementRef;

  focusInput() {
    this.inputElement.nativeElement.focus();
  }
}

Using @ViewChild triggers Angular's component lifecycle and change detection to find the element, adding overhead and delaying interaction.

📉 Performance CostTriggers extra change detection cycles and delays input responsiveness (INP) by several milliseconds.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
@ViewChild querying	Extra DOM query during lifecycle	0-1 reflows depending on usage	Minimal paint cost	[!] OK but slower
Template reference direct access	No extra DOM query, direct reference	0 reflows	Minimal paint cost	[OK] Good

Rendering Pipeline

Template references allow direct access to DOM elements or component instances without Angular's ViewChild querying, reducing the work in the rendering pipeline.

→DOM Access

→Event Handling

→Change Detection

⚠️ BottleneckChange Detection triggered by @ViewChild queries

Core Web Vital Affected

INP

This affects interaction speed and rendering efficiency by reducing the need for extra DOM queries or component lookups.

Optimization Tips

1Use template references for direct DOM or component access to reduce Angular lifecycle overhead.

2Avoid @ViewChild for simple element access to improve input responsiveness (INP).

3Check performance in DevTools to confirm reduced change detection and event handling delays.

Performance Quiz - 3 Questions

What is the main performance benefit of using a template reference variable over @ViewChild in Angular?

A It reduces the bundle size significantly.

B It avoids Angular's extra DOM querying and change detection overhead.

C It improves CSS selector matching speed.

D It prevents layout shifts during rendering.

DevTools: Performance

How to check: Record a performance profile while interacting with the element accessed via @ViewChild vs template reference. Look for change detection and event handling duration.

What to look for: Lower event handling and change detection time indicates better performance with template references.

Practice

1. What is the main purpose of a #templateReference in Angular templates?

easy

A. To bind data between components

B. To define a new Angular component

C. To create a service for dependency injection

D. To directly access a DOM element or component instance in the template

Solution

1. Step 1: Understand what template references do

   Template references let you name elements or components in the template for direct access.

2. Step 2: Identify their use

   They are used to access DOM elements or component instances directly without extra code.

3. Final Answer:

   To directly access a DOM element or component instance in the template -> Option D

4. Quick Check:

   Template reference = direct element/component access [OK]

Hint: Template references name elements for direct access [OK]

Common Mistakes:

• Confusing template references with component declarations
• Thinking they create services
• Assuming they handle data binding

2. Which of the following is the correct syntax to create a template reference named inputBox on an <input> element?

easy

A.

B.

C.

D.

Solution

1. Step 1: Recall Angular template reference syntax

   Angular uses the hash symbol (#) to declare template references.

2. Step 2: Check each option

   Only #inputBox is valid syntax for template references on elements.

3. Final Answer:

   <input #inputBox> -> Option B

4. Quick Check:

   Use # for template references [OK]

Hint: Use # before name to create template reference [OK]

Common Mistakes:

• Using ref= instead of #
• Using * which is for structural directives
• Using $ which is invalid here

3. Given this template snippet:

<input #myInput type="text">
<button (click)="myInput.focus()">Focus</button>

What happens when the button is clicked?

medium

A. Nothing happens because focus() is not a valid method

B. An error occurs because myInput is undefined

C. The input box receives keyboard focus

D. The button text changes to 'Focus'

Solution

1. Step 1: Understand the template reference usage

   The #myInput references the input element, allowing direct access to its DOM methods.

2. Step 2: Analyze the click event

   Click calls myInput.focus(), which sets keyboard focus on the input element.

3. Final Answer:

   The input box receives keyboard focus -> Option C

4. Quick Check:

   Template ref calls focus() = input focused [OK]

Hint: Template refs access DOM methods like focus() [OK]

Common Mistakes:

• Assuming template refs are undefined in event handlers
• Thinking focus() is invalid on input elements
• Expecting button text to change

4. Consider this Angular template:

<input #userInput type="text">
<button (click)="logValue()">Log</button>

And this component code:

logValue() {
  console.log(userInput.value);
}

What is the problem here?

medium

A. The userInput template reference is not accessible in the component class

B. The logValue method is missing a parameter

C. The console.log statement is incorrect syntax

D. The button click event should be (click)="logValue(userInput)"

Solution

1. Step 1: Understand template reference scope

   Template references exist only in the template, not in the component class directly.

2. Step 2: Identify why userInput is undefined in the class

   Trying to access userInput in the class without passing it causes an error.

3. Final Answer:

   The userInput template reference is not accessible in the component class -> Option A

4. Quick Check:

   Template refs not in class scope [OK]

Hint: Template refs only exist in template, not class [OK]

Common Mistakes:

• Assuming template refs are class properties
• Forgetting to pass template ref as method argument
• Confusing template refs with ViewChild

5. You want to create a form with an input and a button that clears the input when clicked. Using a template reference #inputRef, which template code correctly implements this behavior?

hard

A.
Clear

B.
Clear

C.
Clear

D.
Clear

Solution

1. Step 1: Understand how to clear input value via template reference

   Directly setting inputRef.value = '' clears the input content.

2. Step 2: Check other options for correctness

   Options B, C, and D call undefined or non-existent methods: clear() is undefined in the component, and clear() and reset() are not methods on input elements.

3. Final Answer:

   <input #inputRef type="text"> <button (click)="inputRef.value = ''">Clear</button> -> Option A

4. Quick Check:

   Set inputRef.value to empty string to clear [OK]

Hint: Set inputRef.value = '' to clear input [OK]

Common Mistakes:

• Calling non-existent methods like clear() or reset() on input
• Trying to call component methods without passing template ref
• Confusing template ref usage with reactive forms