String Basics and Memory Representation in DSA Javascript

Mental Model

A string is a sequence of characters stored one after another in memory, like beads on a string.

Analogy: Imagine a necklace where each bead is a letter. The beads are lined up in order, and you can look at each bead one by one to read the message.

Index:  0   1   2   3   4
String: H -> e -> l -> l -> o -> null
Memory: [H][e][l][l][o]

Dry Run Walkthrough

Input: string: "Hello"

Goal: Understand how each character is stored in memory and accessed by index

Step 1: Store 'H' at index 0

[H] -> null

Why: First character must be stored at the start of the string

Step 2: Store 'e' at index 1

[H] -> [e] -> null

Why: Next character stored right after the first

Step 3: Store 'l' at index 2

[H] -> [e] -> [l] -> null

Why: Continue storing characters sequentially

Step 4: Store 'l' at index 3

[H] -> [e] -> [l] -> [l] -> null

Why: Each character occupies its own position

Step 5: Store 'o' at index 4

[H] -> [e] -> [l] -> [l] -> [o] -> null

Why: Last character stored, string ends here

Result:

[H] -> [e] -> [l] -> [l] -> [o] -> null

Annotated Code

DSA Javascript

class StringMemory {
  constructor(str) {
    this.chars = [];
    for (let i = 0; i < str.length; i++) {
      this.chars[i] = str[i]; // store character at index i
    }
  }

  print() {
    let result = '';
    for (let i = 0; i < this.chars.length; i++) {
      result += '[' + this.chars[i] + ']';
      if (i < this.chars.length - 1) result += ' -> ';
    }
    result += ' -> null';
    console.log(result);
  }
}

// Driver code
const myString = new StringMemory("Hello");
myString.print();

this.chars[i] = str[i]; // store character at index i

store each character sequentially in array to simulate memory layout

result += '[' + this.chars[i] + ']';

build string representation showing each character in memory

Output

[H] -> [e] -> [l] -> [l] -> [o] -> null

Complexity Analysis

Time: O(n) because we copy each character once where n is string length

Space: O(n) because we store each character separately in an array

vs Alternative: Compared to storing string as a single object, this shows explicit memory layout but uses more space for demonstration

Edge Cases

empty string ""

No characters stored, print shows only ' -> null'

DSA Javascript

for (let i = 0; i < str.length; i++) {

single character string "A"

Stores one character at index 0 and prints '[A] -> null'

DSA Javascript

this.chars[i] = str[i]; // store character at index i

When to Use This Pattern

When you need to understand how strings are stored or accessed by index, think of strings as arrays of characters in memory.

Common Mistakes

Mistake: Trying to treat string as a single character instead of sequence
Fix: Remember string is a sequence; access characters by index one by one

Mistake: Assuming characters are stored randomly in memory
Fix: Characters are stored sequentially in order, like beads on a string

Summary

A string is a sequence of characters stored one after another in memory.

Use this when you want to understand or manipulate individual characters in a string.

The key insight is that each character has its own position and is stored in order.

Practice

1. What does the term immutable mean when talking about strings in JavaScript?

easy

A. Strings cannot be changed after they are created

B. Strings can be changed anytime

C. Strings are stored as numbers

D. Strings are always empty

Solution

1. Step 1: Understand string immutability

   In JavaScript, once a string is created, its content cannot be changed directly.

2. Step 2: Compare options with definition

   Strings cannot be changed after they are created - this matches the definition.

3. Final Answer:

   Strings cannot be changed after they are created -> Option A

4. Quick Check:

   Immutable means unchangeable = D [OK]

Hint: Remember: strings can't be changed once made [OK]

Common Mistakes:

• Thinking strings can be changed like arrays
• Confusing immutability with emptiness
• Assuming strings are stored as numbers

2. Which of the following is the correct way to create a string in JavaScript?

easy

A. const str = Hello World;

B. const str = (Hello World);

C. const str = `Hello World;

D. const str = 'Hello World';

Solution

1. Step 1: Check string syntax rules

   Strings must be enclosed in quotes: single (' '), double (" "), or backticks (` `).

2. Step 2: Validate each option

   const str = 'Hello World'; uses single quotes correctly. const str = Hello World; misses quotes. const str = `Hello World; misses closing backtick. const str = (Hello World); uses parentheses incorrectly.

3. Final Answer:

   const str = 'Hello World'; -> Option D

4. Quick Check:

   Quotes needed for strings = B [OK]

Hint: Strings need quotes around text [OK]

Common Mistakes:

• Forgetting quotes around string text
• Using mismatched or missing quotes
• Using parentheses instead of quotes

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

let s = 'hello';
s[0] = 'H';
console.log(s);

medium

A. hello

B. Hello

C. undefined

D. Error

Solution

1. Step 1: Understand string immutability in code

   Strings cannot be changed by assigning to an index like s[0] = 'H'. This operation is ignored.

2. Step 2: Check what console.log prints

   The original string 'hello' remains unchanged and is printed.

3. Final Answer:

   hello -> Option A

4. Quick Check:

   Strings unchanged by index assignment = A [OK]

Hint: Strings ignore index assignment, original stays same [OK]

Common Mistakes:

• Expecting first letter to change
• Thinking strings behave like arrays
• Assuming error will be thrown

4. Find the error in this code snippet that tries to change a string character:

let word = 'code';
word[2] = 'd';
console.log(word);

medium

A. Variable word is not declared

B. Strings are immutable; cannot assign to index

C. Missing semicolon after declaration

D. console.log syntax is wrong

Solution

1. Step 1: Analyze string modification attempt

   Assigning to a string index like word[2] = 'd' does not change the string because strings are immutable.

2. Step 2: Check other options for errors

   Semicolons are optional in JavaScript, variable is declared, and console.log syntax is correct.

3. Final Answer:

   Strings are immutable; cannot assign to index -> Option B

4. Quick Check:

   Immutable strings block index assignment = C [OK]

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

Common Mistakes:

• Thinking semicolon is mandatory here
• Assuming variable is undeclared
• Believing console.log syntax is incorrect

5. Given the code below, what will be the output?

const str1 = 'abc';
const str2 = str1 + 'd';
console.log(str1);
console.log(str2);

Choose the correct output representation.

hard

A. Both lines print abcd

B. abcd and abc printed on separate lines

C. abc and abcd printed on separate lines

D. Error because strings are immutable

Solution

1. Step 1: Understand string concatenation and immutability

   str1 remains 'abc' because strings are immutable. str2 is a new string 'abcd' created by adding 'd' to str1.

2. Step 2: Check console.log outputs

   console.log(str1) prints abc. console.log(str2) prints abcd.

3. Final Answer:

   abc and abcd printed on separate lines -> Option C

4. Quick Check:

   Original unchanged, new string created = A [OK]

Hint: Concatenation creates new string, original stays same [OK]

Common Mistakes:

• Thinking original string changes after concatenation
• Expecting error due to immutability
• Confusing order of printed strings