TypeScript – element.innerHTML and element.textContent

Updated: February 14, 2024 By: Guest Contributor Post a comment


When working with TypeScript, a powerful typed superset of JavaScript, developers gain the advantage of strong type-checking alongside the usual flexibility of JavaScript. This tutorial focuses on manipulating HTML elements’ content through innerHTML and textContent properties, and how TypeScript’s type system helps ensure these operations are type-safe by defining types and interfaces.

Manipulating the DOM (Document Object Model) is a common task in web development. Whether you are adding content, extracting information, or simply modifying existing page elements, mastering how to safely and effectively perform these tasks in TypeScript is crucial for creating reliable web applications.

Understanding innerHTML and textContent

The innerHTML property allows getting or setting the HTML or XML content of an element. While highly versatile, using innerHTML carelessly can expose your application to cross-site scripting (XSS) attacks. Conversely, textContent gives you the ability to work with the text inside an element, excluding any HTML tags. It’s safer from an XSS standpoint but doesn’t allow you to parse HTML content.

Defining Types and Interfaces in TypeScript

TypeScript enables developers to declare specific types and interfaces for variables and function parameters, thereby providing compile-time type checking. This feature is incredibly beneficial when manipulating the DOM because it helps prevent runtime errors caused by incorrect element types or properties.

Example: Safely Accessing DOM Elements

interface HTMLElementWithContent extends HTMLElement {
  innerHTML?: string;
  textContent?: string;

function safelyUpdateContent(elementId: string, content: string, isHTML: boolean = false): void {
  const element: HTMLElementWithContent | null = document.getElementById(elementId);
  if (element) {
    if (isHTML) {
      element.innerHTML = content;
    } else {
      element.textContent = content;
  } else {
    console.error('Element not found');

This code snippet demonstrates how to define an interface HTMLElementWithContent that extends the basic HTMLElement inferred by TypeScript. By doing this, we explicitly state our intention to work with elements that have innerHTML or textContent properties, thus making our code more predictable and safer.

Typing Event Listeners

function handleContentClick(event: MouseEvent): void {
  const target = event.target as HTMLElementWithContent;
  if (target && target.innerHTML) {
    console.log('Clicked content:', target.innerHTML);

document.addEventListener('click', handleContentClick);

Here, we type the event’s target as HTMLElementWithContent. This small adjustment makes handling events involving our content elements explicit and type-safe.

Handling Nullable Types

In TypeScript, handling cases where an element might not exist is vital. The nullish coalescing operator (??) and the optional chaining operator (?.) are two powerful tools for dealing with potentially null or undefined values without verbose conditional checking.

Example: A More Robust Content Updating Function

function updateContentSafely(elementId: string, content: string, isHTML: boolean = false): void {
  const element = document.getElementById(elementId) as HTMLElementWithContent | null;
  element?.innerHTML = isHTML ? content : element.textContent;

This improved function adds a layer of safety by using optional chaining, thereby avoiding runtime errors if the element is null.


Through defining types and interfaces, TypeScript provides stronger assurances about the safety and predictability of our code, particularly when manipulating DOM elements. While JavaScript gives the flexibility needed for dynamic web development, TypeScript’s type system helps catch errors early in the development process, leading to more robust applications.

Remember, while innerHTML and textContent are powerful tools for interacting with web page content, understanding and mitigating their potential security implications is essential. Properly typing elements and operations in TypeScript not only adds a layer of security but also improves code readability and maintainability.