How Strings Work Differently Across Languages in DSA Javascript - Step-by-Step

Mental Model

Strings are sequences of characters, but how they are stored and handled can change depending on the language.

Analogy: Think of strings like a row of mailboxes. Some languages let you open each mailbox easily and change the mail inside, while others lock the mailboxes so you can only read the mail but not change it directly.

String: 'cat'

Index: 0 -> 1 -> 2 -> null
Chars: c -> a -> t -> null

In some languages, this is a fixed row of mailboxes (immutable).
In others, you can swap mail inside any mailbox (mutable).

Dry Run Walkthrough

Input: String: 'cat', try to change character at index 1 to 'o'

Goal: Show how changing a character in a string works differently in languages that allow it vs those that don't

Step 1: Try to change character at index 1 from 'a' to 'o' directly

'cat' (original string)
Attempt: 'c' + 'o' + 't' ?

Why: We want to see if the language allows direct change of a character inside the string

Step 2: In JavaScript, direct change fails because strings are immutable

'cat' remains unchanged

Why: Strings cannot be changed character by character directly

Step 3: Create a new string by combining parts: 'c' + 'o' + 't'

New string: 'cot'

Why: To change a character, we build a new string with the desired change

Result:

'cat' unchanged after direct change attempt
New string created: 'cot'

Annotated Code

DSA Javascript

class StringExample {
  constructor(str) {
    this.str = str;
  }

  tryChangeChar(index, newChar) {
    // Strings are immutable in JavaScript, so direct change is not possible
    // Attempting direct change will not work
    // Instead, create a new string with the change
    if (index < 0 || index >= this.str.length) {
      return this.str; // index out of bounds, return original
    }
    const newStr = this.str.slice(0, index) + newChar + this.str.slice(index + 1);
    return newStr;
  }
}

// Driver code
const example = new StringExample('cat');
console.log('Original string:', example.str);
const changed = example.tryChangeChar(1, 'o');
console.log('After trying to change index 1 to "o":', changed);
console.log('Original string after attempt:', example.str);

if (index < 0 || index >= this.str.length) {

check if index is valid to avoid errors

const newStr = this.str.slice(0, index) + newChar + this.str.slice(index + 1);

build a new string with the character replaced at the given index

return newStr;

return the new string since original cannot be changed

Output

Original string: cat

After trying to change index 1 to "o": cot

Original string after attempt: cat

Complexity Analysis

Time: O(n) because slicing and concatenation create a new string of length n

Space: O(n) because a new string of the same length is created

vs Alternative: In languages with mutable strings, changing a character can be O(1) without creating a new string, saving time and space

Edge Cases

Index out of string bounds

Returns original string unchanged

DSA Javascript

if (index < 0 || index >= this.str.length) {

Empty string

Returns empty string unchanged

DSA Javascript

if (index < 0 || index >= this.str.length) {

When to Use This Pattern

When you see a problem asking to change characters inside a string, remember strings might be immutable and require creating new strings.

Common Mistakes

Mistake: Trying to assign a new character directly to a string index like str[1] = 'o'
Fix: Create a new string by combining slices and the new character instead

Summary

Strings are sequences of characters that may be immutable depending on the language.

Use this when you need to modify strings but the language does not allow direct changes.

The key insight is that strings often cannot be changed in place, so you must build new strings to reflect changes.

Practice

1. In JavaScript, which of the following statements about strings is true?

easy

A. Strings are immutable, meaning you cannot change a character directly.

B. Strings are mutable, so you can change characters by index.

C. Strings are stored as arrays of characters that can be modified.

D. Strings are objects that allow direct character assignment.

Solution

1. Step 1: Understand string mutability in JavaScript

   JavaScript strings cannot be changed after creation; they are immutable.

2. Step 2: Compare with other options

   Options A, B, and C suggest mutability or direct modification, which is incorrect.

3. Final Answer:

   Strings are immutable, meaning you cannot change a character directly. -> Option A

4. Quick Check:

   JavaScript strings are immutable = D [OK]

Hint: Remember: JavaScript strings cannot be changed character by character [OK]

Common Mistakes:

• Thinking strings behave like arrays and can be changed by index
• Confusing string immutability with array mutability
• Assuming strings are objects with mutable properties

2. Which of the following is the correct way to get the length of a string str in JavaScript?

easy

A. str.size

B. str.length()

C. length(str)

D. str.length

Solution

1. Step 1: Recall JavaScript string length syntax

   In JavaScript, string length is accessed as a property without parentheses: str.length

2. Step 2: Check other options for syntax errors

   str.length() uses parentheses which is incorrect; C and D are not valid JavaScript syntax for string length.

3. Final Answer:

   str.length -> Option D

4. Quick Check:

   Use property .length without () = A [OK]

Hint: Use .length property without parentheses for string length [OK]

Common Mistakes:

• Using parentheses like a function call (str.length())
• Confusing with other languages that use length() function
• Trying to use str.size which is invalid in JavaScript

3. What will be the output of the following JavaScript code?

const s = 'hello';
console.log(s[1]);
s[1] = 'a';
console.log(s[1]);

medium

A. e\ne

B. e\na

C. undefined\na

D. undefined\ne

Solution

1. Step 1: Check first console.log(s[1])

   Index 1 of 'hello' is 'e', so first output is 'e'.

2. Step 2: Attempt to change s[1] and check second console.log(s[1])

   Strings are immutable, so s[1] = 'a' does nothing; second output remains 'e'.

3. Final Answer:

   e\ne -> Option A

4. Quick Check:

   Immutable strings keep original chars = B [OK]

Hint: Remember strings can't be changed by index assignment [OK]

Common Mistakes:

• Expecting s[1] to change to 'a'
• Confusing string mutability with arrays
• Assuming assignment to string index works

4. Identify the error in the following JavaScript code snippet:

let str = 'world';
str[0] = 'W';
console.log(str);

medium

A. No error; output is 'World'

B. No error; output is 'world'

C. TypeError because strings are immutable

D. SyntaxError due to invalid assignment

Solution

1. Step 1: Understand string immutability and assignment

   Assigning to str[0] does not change the string; no error is thrown.

2. Step 2: Check console.log output

   Since assignment fails silently, output remains original string 'world'.

3. Final Answer:

   No error; output is 'world' -> Option B

4. Quick Check:

   Immutable strings ignore index assignment = C [OK]

Hint: Index assignment on strings fails silently, no error thrown [OK]

Common Mistakes:

• Expecting a TypeError on index assignment
• Thinking string changes after index assignment
• Confusing with languages that allow mutable strings

5. You want to replace the first character of a string str with an uppercase letter in JavaScript. Which approach correctly achieves this?

hard

A. str.replace(0, str[0].toUpperCase());

B. str[0] = str[0].toUpperCase();

C. str = str[0].toUpperCase() + str.slice(1);

D. str.toUpperCase()[0] + str.slice(1);

Solution

1. Step 1: Understand string immutability and modification

   Direct assignment to str[0] is invalid; strings are immutable.

2. Step 2: Check each option for correct string replacement

   str = str[0].toUpperCase() + str.slice(1); creates a new string by uppercasing first char and adding rest; this works correctly.

3. Step 3: Analyze other options

   B tries direct assignment (invalid), C uses replace incorrectly (replace needs substring, not index), D uppercases whole string then concatenates first char with rest but doesn't reassign to str (str unchanged).

4. Final Answer:

   str = str[0].toUpperCase() + str.slice(1); -> Option C

5. Quick Check:

   Use new string with uppercase first char + rest = A [OK]

Hint: Build new string; can't change characters directly [OK]

Common Mistakes:

• Trying to assign directly to str[0]
• Using replace with index instead of substring
• Uppercasing whole string instead of first char only