Strings 101 with an Object Oriented Approach

A string is text like "Hello". In JavaScript, strings are immutable (you cannot change characters in place) and have many built-in methods. This guide wraps common operations in a tiny class so you can learn strings using an object oriented approach.

JavaScript Implementation


// Object Oriented JavaScript   String utilities for beginners
class StringHelper {
  constructor(text) {
    this.text = String(text); // ensure it's a string
  }

  // --- Basics ---
  length() { return this.text.length; }
  first() { return this.text.at(0) ?? ""; }
  last()  { return this.text.at(-1) ?? ""; }
  charAt(i) { return this.text.charAt(i); }
  codeAt(i) { return this.text.charCodeAt(i); }

  // --- Case & whitespace ---
  upper() { return this.text.toUpperCase(); }
  lower() { return this.text.toLowerCase(); }
  trim()  { return this.text.trim(); }

  // --- Searching ---
  includes(substr) { return this.text.includes(substr); }
  indexOf(substr) { return this.text.indexOf(substr); }
  lastIndexOf(substr) { return this.text.lastIndexOf(substr); }
  startsWith(prefix) { return this.text.startsWith(prefix); }
  endsWith(suffix) { return this.text.endsWith(suffix); }

  // --- Extracting ---
  slice(start, end) { return this.text.slice(start, end); }
  substring(start, end) { return this.text.substring(start, end); }

  // --- Replacing ---
  replace(find, replacement) { return this.text.replace(find, replacement); }
  replaceAll(find, replacement) { return this.text.replaceAll(find, replacement); }

  // --- Split/Join ---
  words() { return this.text.trim().split(/\s+/); } // split by spaces
  splitBy(sep) { return this.text.split(sep); }

  // --- Pad & repeat ---
  padLeft(len, fill = " ") { return this.text.padStart(len, fill); }
  padRight(len, fill = " ") { return this.text.padEnd(len, fill); }
  repeat(n) { return this.text.repeat(n); }

  // --- Compare ---
  equals(other) { return this.text === String(other); }
  compare(other) { return this.text.localeCompare(String(other)); }

  // --- Compose ---
  concat(...parts) { return [this.text, ...parts.map(String)].join(""); }

  // --- Template literal demo (string interpolation) ---
  greet(name) {
    const n = String(name).trim();
    return `Hi ${n}, you said: "${this.text}"`; // uses backticks
  }
}

/*** Demo usage ***/
const s = new StringHelper("  Hello World  ");
console.log("Original:", JSON.stringify(s.text));
console.log("Length:", s.length());
console.log("First/Last:", s.first(), s.last());
console.log("Trimmed:", s.trim());
console.log("Upper:", s.upper());
console.log("Includes 'World'?", s.includes("World"));
console.log("Index of 'o':", s.indexOf("o"), "Last index of 'o':", s.lastIndexOf("o"));
console.log("Slice(2, 7):", s.slice(2, 7));
console.log("Substring(2, 7):", s.substring(2, 7));
console.log("Replace World->JS:", s.replace("World", "JS"));
console.log("ReplaceAll l->*", s.replaceAll(/l/g, "*"));
console.log("Words:", s.words());
console.log("Pad left:", new StringHelper("7").padLeft(3, "0"));
console.log("Repeat:", new StringHelper("ha").repeat(3));
console.log("Compare 'Hello World':", s.compare("Hello World"));
console.log("Concat:", s.concat("!!!"));
console.log("Greeting:", s.greet("Ada"));

Complete Explanation of the Code

Class and constructor class StringHelper defines a blueprint. constructor(text) runs when you create an object and stores text safely using String(text).
Basics length() counts characters. first() and last() use .at() to read first/last characters, defaulting to "" when missing. charAt(i) reads a character; codeAt(i) returns its numeric code.
Case & whitespace upper(), lower(), and trim() return new strings (the original text is unchanged).
Searching includes answers presence; indexOf/lastIndexOf return positions; startsWith/endsWith check edges.
Extracting slice(start,end) and substring(start,end) copy parts. slice supports negative indexes; substring does not.
Replacing replace swaps the first match; replaceAll swaps every match. Works with strings or regular expressions.
Split/Join words() trims then splits on spaces into an array; splitBy(sep) splits by any separator you provide.
Pad & repeat padLeft/padRight add characters to reach a target length; repeat(n) duplicates the text.
Compare equals checks exact equality; compare returns a number indicating alphabetical order (0 equal, negative before, positive after).
Compose concat(...parts) joins the current text with more parts into one string.
Template literals greet(name) trims the name and uses a backtick string to embed values directly.
Demo Shows each method in action using the sample string with spaces around it.

Standard Pseudocode


CLASS StringHelper
  PROCEDURE constructor(text)
    SET self.text TO STRING(text)
  END PROCEDURE

  FUNCTION length()
    RETURN LENGTH(self.text)
  END FUNCTION

  FUNCTION first()
    IF LENGTH(self.text) = 0 THEN
      RETURN ""
    ELSE
      RETURN self.text[0]
    END IF
  END FUNCTION

  FUNCTION last()
    IF LENGTH(self.text) = 0 THEN
      RETURN ""
    ELSE
      RETURN self.text[LENGTH(self.text) - 1]
    END IF
  END FUNCTION

  FUNCTION charAt(i)
    IF i < 0 OR i >= LENGTH(self.text) THEN
      RETURN ""
    ELSE
      RETURN self.text[i]
    END IF
  END FUNCTION

  FUNCTION codeAt(i)
    IF i < 0 OR i >= LENGTH(self.text) THEN
      RETURN -1
    ELSE
      RETURN CHAR_CODE(self.text[i])
    END IF
  END FUNCTION

  FUNCTION upper()
    RETURN TO_UPPER(self.text)
  END FUNCTION

  FUNCTION lower()
    RETURN TO_LOWER(self.text)
  END FUNCTION

  FUNCTION trim()
    RETURN TRIM(self.text)
  END FUNCTION

  FUNCTION includes(substr)
    RETURN INCLUDES(self.text, substr)
  END FUNCTION

  FUNCTION indexOf(substr)
    RETURN INDEX_OF(self.text, substr)
  END FUNCTION

  FUNCTION lastIndexOf(substr)
    RETURN LAST_INDEX_OF(self.text, substr)
  END FUNCTION

  FUNCTION startsWith(prefix)
    RETURN STARTS_WITH(self.text, prefix)
  END FUNCTION

  FUNCTION endsWith(suffix)
    RETURN ENDS_WITH(self.text, suffix)
  END FUNCTION

  FUNCTION slice(start, end)
    RETURN SLICE(self.text, start, end)
  END FUNCTION

  FUNCTION substring(start, end)
    RETURN SUBSTRING(self.text, start, end)
  END FUNCTION

  FUNCTION replace(find, repl)
    RETURN REPLACE(self.text, find, repl)
  END FUNCTION

  FUNCTION replaceAll(find, repl)
    RETURN REPLACE_ALL(self.text, find, repl)
  END FUNCTION

  FUNCTION words()
    RETURN SPLIT(TRIM(self.text), REGEX_FOR_SPACES)
  END FUNCTION

  FUNCTION splitBy(sep)
    RETURN SPLIT(self.text, sep)
  END FUNCTION

  FUNCTION padLeft(len, fill)
    IF fill IS UNDEFINED THEN
      SET fill TO " "
    END IF
    RETURN PAD_START(self.text, len, fill)
  END FUNCTION

  FUNCTION padRight(len, fill)
    IF fill IS UNDEFINED THEN
      SET fill TO " "
    END IF
    RETURN PAD_END(self.text, len, fill)
  END FUNCTION

  FUNCTION repeat(n)
    RETURN REPEAT(self.text, n)
  END FUNCTION

  FUNCTION equals(other)
    RETURN self.text EQUALS STRING(other)
  END FUNCTION

  FUNCTION compare(other)
    RETURN LOCALE_COMPARE(self.text, STRING(other))
  END FUNCTION

  FUNCTION concat(PARTS...)
    RETURN JOIN( [self.text] + MAP(STRING, PARTS), "" )
  END FUNCTION

  FUNCTION greet(name)
    SET n TO TRIM(STRING(name))
    RETURN CONCAT("Hi ", n, ", you said: \"", self.text, "\"")
  END FUNCTION
END CLASS

// Demo (mirrors the JavaScript example)
PROCEDURE Demo
  INITIALIZE s AS NEW StringHelper("  Hello World  ")
  PRINT "Original:", JSON_ENCODE(s.text)
  PRINT "Length:", CALL s.length()
  PRINT "First/Last:", CALL s.first(), CALL s.last()
  PRINT "Trimmed:", CALL s.trim()
  PRINT "Upper:", CALL s.upper()
  PRINT "Includes 'World'?", CALL s.includes("World")
  PRINT "Index of 'o':", CALL s.indexOf("o"), "Last index of 'o':", CALL s.lastIndexOf("o")
  PRINT "Slice(2, 7):", CALL s.slice(2, 7)
  PRINT "Substring(2, 7):", CALL s.substring(2, 7)
  PRINT "Replace World->JS:", CALL s.replace("World", "JS")
  PRINT "ReplaceAll l->*:", CALL s.replaceAll(REGEX("l","g"), "*")
  PRINT "Words:", CALL s.words()
  PRINT "Pad left:", CALL (NEW StringHelper("7")).padLeft(3, "0")
  PRINT "Repeat:", CALL (NEW StringHelper("ha")).repeat(3)
  PRINT "Compare 'Hello World':", CALL s.compare("Hello World")
  PRINT "Concat:", CALL s.concat("!!!")
  PRINT "Greeting:", CALL s.greet("Ada")
END PROCEDURE

Explanation of the Pseudocode

CLASS ... END CLASS wraps all related procedures and functions for the string helper.
constructor uses SET to store the input text and ensures it is a string.
length / first / last show simple returns and safe checks using IF ... THEN ... ELSE ... END IF.
charAt / codeAt validate indexes with OR to avoid out-of-range access; return a safe default when invalid.
upper / lower / trim demonstrate transformations that return new strings (original text is unchanged).
includes / indexOf / lastIndexOf / startsWith / endsWith are “question” functions that return boolean or position values.
slice / substring both extract parts; the former supports negative positions, the latter does not.
replace / replaceAll return copies with substitutions; can use plain text or regular expressions.
words / splitBy output arrays; one splits on spaces after trimming, the other splits by a given separator.
padLeft / padRight use a default fill character when not provided and then pad to a target length.
repeat duplicates the text a specified number of times.
equals / compare check equality and alphabetical ordering; compare returns negative/zero/positive.
concat accepts many parts and joins them with the current text into one string.
greet combines conversion, trimming, and concatenation to build a friendly message.
Demo constructs an object and PRINTs results from each function, mirroring the JavaScript example.