Search⌘ K
AI Features
Home
Courses
Learn Data Structures and Algorithms in JavaScript

Basic String Operations

Explore fundamental string operations in JavaScript including slicing, concatenation, repeating, splitting, and joining. Understand the immutability of strings and analyze the time and space complexity of each operation. This lesson helps you build efficient string algorithms by recognizing the costs associated with common string manipulations.

We'll cover the following...

Now that we’ve established that strings are immutable and that any apparent modification produces a new string rather than altering the original, the next step is to build familiarity with the operations that are actually available on strings. These operations form the practical foundation of string algorithm implementation. Each one has a defined behavior and a measurable cost, and understanding both is essential before moving on to writing algorithms that use them.

Slicing: Extracting part of a string

Slicing is the operation of extracting a contiguous portion of a string. The extracted portion is called a substring, and it is returned as a new string. The original string remains unchanged.

In JavaScript, slicing uses the following syntax:

s.slice(start, end)

The result contains all characters from the start index up to, but not including, the end index. Consider the following example:

Javascript (babel-node)
// Initialization of the string data
let s = "hello world";
// Accessing the first five characters (indices 0 to 4)
// The character at index 5 (' ') is excluded.
console.log(`Substring from index 0 to 5: "${s.slice(0, 5)}"\n`);
// Accessing characters from index 6 to the end (indices 6 to 10)
// This represents the second word in the sequence.
console.log(`Substring from index 6 to 11: "${s.slice(6, 11)}"\n`);
// Accessing a shorter prefix (indices 0 to 2)
console.log(`Substring from index 0 to 3: "${s.slice(0, 3)}"`);

In this example, s.slice(0, 5) extracts the first five characters, and s.slice(6, 11) extracts the last five. The character at the end index is never included in the result.

Now, let’s look at the following visualizer for a better understanding of slicing in strings:

Omitting start and end in slicing

If the start or end value is omitted, JavaScript slice() uses default values:

  • When the start index is omitted, the slice begins at the first character.

  • When the end index is omitted, the slice extends to the last character.

  • When both are omitted, the entire string is returned as a new copy.

Javascript (babel-node)
let s = "hello world";
// Accessing from the start of the string to index 4 (indices 0 to 4)
// When the start index is omitted, it defaults to 0.
console.log(`Substring from the start to index 5: "${s.slice(0, 5)}"\n`);
// Accessing from index 6 to the end of the string
// When the end index is omitted, it defaults to the length of the string.
console.log(`Substring from index 6 to the end: "${s.slice(6)}"\n`);
// Accessing the entire string sequence
// Omitting both indices creates a complete shallow copy of the string.
console.log(`Full string copy using slicing: "${s.slice()}"`);

Complexity analysis of slicing

Producing a slice of length kk requires allocating a new string and copying kk characters into it. Slicing therefore takes O(k)O(k) ...