JavaScript String strike() Method

What You’ll Learn

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

Introduction

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

Today those wrappers are deprecated. strike() still works in browsers for compatibility, but the <strike> element itself was removed from HTML. Use semantic strikethrough with <s> or <del> instead.

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

Understanding the strike() Method

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

• It is an instance method on strings (auto-boxed if needed).
• It returns a new string — the original is unchanged.
• No parameters — just str.strike().
• Prefer createElement("s") or createElement("del") for real UI.

📝 Syntax

General form of String.prototype.strike:

str.strike()

Parameters

None.

Return value

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

Common patterns

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

// Prefer this in new code:
const elem = document.createElement("s");
elem.textContent = "Hello, world";
document.body.appendChild(elem);

Examples Gallery

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

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

<strike>Hello, world</strike>

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

<strike></strike>
<strike>A < B</strike>
string

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

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

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

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

<strike>Hi</strike>
<big>Hi</big>
<small>Hi</small>
<b>Hi</b>

const contentString = "Hello, world";
const elem = document.createElement("s");
elem.textContent = contentString;

// document.body.appendChild(elem);
console.log(elem.tagName);
console.log(elem.outerHTML);

S
<s>Hello, world</s>

🚀 Common Use Cases

• Reading legacy tutorials — recognize HTML wrapper methods in old samples.
• Migrating old scripts — replace strike() with createElement("s") or "del".
• Price / outdated labels — use a real <s> for “no longer accurate” text.
• Document edits — use <del> (often with <ins>) for tracked changes.
• Not for new apps — do not use strike() to draw strikethrough.
• Safer markup — prefer textContent + DOM over innerHTML strings.

📝 Notes

• strike() is deprecated — standardized only for compatibility.
• The <strike> element was removed from the HTML specification.
• Prefer <s> (inaccurate / irrelevant) or <del> (deleted content).
• It returns a string, not a DOM node.
• It takes no parameters.
• Avoid assigning untrusted strings to innerHTML.

💡 Best Practices