JavaScript String big() Method

What You’ll Learn

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

Introduction

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

Today those wrappers are deprecated. big() still works in browsers for compatibility, but the <big> element itself was removed from HTML. Font size belongs in CSS.

This page is part of JavaScript String Methods. Related topics include anchor() and blink().

Understanding the big() Method

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

• It is an instance method on strings (auto-boxed if needed).
• It returns a new string — the original is unchanged.
• No parameters — just str.big().
• Prefer CSS font-size for real UI.

📝 Syntax

General form of String.prototype.big:

str.big()

Parameters

None.

Return value

A string beginning with a <big> start tag, then the text of str, then a </big> end tag.

Common patterns

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

// Prefer this in new code:
const el = document.getElementById("yourElemId");
el.style.fontSize = "2em";

Examples Gallery

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

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

<big>Hello, world</big>

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

<big></big>
<big>A < B</big>
string

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

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

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

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

<big>Hi</big>
<small>Hi</small>
<b>Hi</b>
<i>Hi</i>

const el = document.createElement("p");
el.textContent = "Hello, world";
el.style.fontSize = "2em";

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

2em
<p style="font-size: 2em;">Hello, world</p>

🚀 Common Use Cases

• Reading legacy tutorials — recognize HTML wrapper methods in old samples.
• Migrating old scripts — replace big() with CSS font-size.
• Teaching string immutability — show that methods return new strings.
• Not for new apps — do not use big() to enlarge UI text.
• Design systems — use type scale tokens / utility classes instead.
• Safer markup — prefer textContent + CSS over innerHTML strings.

📝 Notes

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

💡 Best Practices