JavaScript String fixed() Method

What You’ll Learn

String.prototype.fixed() is a deprecated HTML wrapper method (same API as MDN String.prototype.fixed()). It returns a string that wraps your text in a <tt> (teletype / fixed-width) tag. Learn what it builds, why that element is obsolete, and how to replace it with CSS font-family: monospace — with five examples and try-it labs.

Introduction

Early JavaScript included helpers that wrapped text in HTML presentation tags — fixed(), big(), bold(), italics(), and others. They made it easy to inject markup with innerHTML.

Today those wrappers are deprecated. fixed() still works in browsers for compatibility, but the <tt> element itself was removed from HTML. Fixed-width (monospace) fonts belong in CSS — or in semantic tags like <code> when you mean computer code.

This page is part of JavaScript String Methods. Related topics include bold() and big().

Understanding the fixed() Method

Calling str.fixed() does not create a live DOM node and does not take arguments. It concatenates an HTML string: <tt> + text + </tt>.

• It is an instance method on strings (auto-boxed if needed).
• It returns a new string — the original is unchanged.
• No parameters — just str.fixed().
• Prefer CSS font-family: monospace (or <code>) for real UI.

📝 Syntax

General form of String.prototype.fixed:

str.fixed()

Parameters

None.

Return value

Always an HTML string wrapped in <tt>. Special cases:

Common patterns

"Hello, world".fixed();
// 'Hello, world'

// Prefer this in new code:
const el = document.getElementById("yourElemId");
el.style.fontFamily = "monospace";

// Or semantic markup for code:
const code = document.createElement("code");
code.textContent = "Hello, world";

Examples Gallery

Examples follow MDN String.fixed() patterns. Use View Output or Try It Yourself for each case.

const contentString = "Hello, world";
contentString.fixed();
// 'Hello, world'

<tt>Hello, world</tt>

"".fixed();           // ''
"A < B".fixed();      // 'A < B'
typeof "x".fixed();   // "string"

<tt></tt>
<tt>A < B</tt>
string

const contentString = "Hello, world";
const html = contentString.fixed();
// document.body.innerHTML = html;  // legacy pattern — avoid in new apps

console.log(html);
// Warning:  is not a valid element in modern HTML

<tt>Hello, world</tt>
(invalid modern markup — <tt> was removed from HTML)

"Hi".fixed();   // 'Hi'
"Hi".big();     // 'Hi'
"Hi".bold();    // 'Hi'
"Hi".italics(); // 'Hi'

<tt>Hi</tt>
<big>Hi</big>
<b>Hi</b>
<i>Hi</i>

const el = document.createElement("p");
el.textContent = "Hello, world";
el.style.fontFamily = "monospace";

// document.body.appendChild(el);
console.log(el.style.fontFamily);
console.log(el.outerHTML);

// Semantic alternative for source code:
const code = document.createElement("code");
code.textContent = "const x = 1;";
console.log(code.outerHTML);

monospace
<p style="font-family: monospace;">Hello, world</p>
<code>const x = 1;</code>

🚀 Common Use Cases

• Reading legacy tutorials — recognize HTML wrapper methods in old samples.
• Migrating old scripts — replace fixed() with CSS monospace or <code>.
• Teaching string immutability — show that methods return new strings.
• Not for new apps — do not use fixed() for monospace UI text.
• Code snippets — use <code> / <pre> with a monospace font.
• Safer markup — prefer textContent + CSS over innerHTML strings.

📝 Notes

• fixed() is deprecated — standardized only for compatibility.
• The <tt> element was removed from the HTML specification.
• It returns a string, not a DOM node.
• It takes no parameters.
• Other HTML wrappers (big(), bold(), fontcolor(), …) share the same fate.
• Avoid assigning untrusted strings to innerHTML.

💡 Best Practices