Template reference for direct access in Angular - Mini Project: Build & Apply

Template Reference for Direct Access in Angular

📖 Scenario: You are building a simple Angular component that includes an input box and a button. You want to access the input box's value directly in the template when the button is clicked, without using two-way binding or component properties.

🎯 Goal: Create an Angular standalone component that uses a template reference variable to access the input element's value directly in the template and display it below the button when clicked.

📋 What You'll Learn

Create an input element with a template reference variable named userInput

Create a button that, when clicked, displays the current value of the input element

Use Angular's template reference variable syntax to access the input value directly in the template

Display the input value in a <p> tag below the button

Use standalone component syntax with Angular 17+ features

💡 Why This Matters

🌍 Real World

Template reference variables let you quickly access DOM elements in Angular templates without extra code in the component class. This is useful for simple forms, quick value reads, or focusing elements.

💼 Career

Understanding template references is important for Angular developers to write clean, efficient templates and handle user input directly. It is a common skill needed in frontend development roles using Angular.

1

Create the input element with a template reference variable

Create an input element of type text with a template reference variable named userInput inside the component's template.

Angular

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  standalone: true,
  template: `
    
    
  `
})
export class AppComponent {
}

Hint

Use #userInput to create a template reference variable on the input element.

2

Add a button to trigger displaying the input value

Add a button element with the text Show Value below the input. The button should have a click event that sets a component property displayValue to the current value of the input accessed via the template reference variable userInput.

Angular

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  standalone: true,
  template: `
    
    Show Value
    
  `
})
export class AppComponent {
  displayValue = '';
}

Hint

Use (click)="displayValue = userInput.value" on the button and declare displayValue as a string property in the component class.

3

Display the input value below the button

Add a <p> tag below the button that displays the value of the component property displayValue using Angular interpolation.

Angular

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  standalone: true,
  template: `
    
    Show Value
    {{ displayValue }}
    
  `
})
export class AppComponent {
  displayValue = '';
}

Hint

Use {{ displayValue }} inside a <p> tag to show the value.

4

Add accessibility and finalize the component

Add an aria-label attribute with the value Enter text to the input element for accessibility. Ensure the component is standalone and properly structured.

Angular

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  standalone: true,
  template: `
    
    Show Value
    {{ displayValue }}
    
  `
})
export class AppComponent {
  displayValue = '';
}

Hint

Add aria-label="Enter text" to the input element for screen readers.

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