Introduction To Strings The Building Blocks of Text

All Notes

Code

Every piece of text you see in a program – from user input in a form, to a file path, a URL, or a simple message printed to the console – is handled using what we call strings. They are one of the most fundamental and frequently used data types in programming.

Understanding how strings work, how to manipulate them, and their underlying properties is crucial for any developer. This post will walk you through the essentials, using practical examples in Python, JavaScript, and Go.

What Are Strings?

At their core, strings are sequences of characters. Historically, these characters were limited to ASCII, representing English letters, numbers, and basic symbols. Today, with the widespread adoption of Unicode and UTF-8, strings can represent virtually any character from any language in the world, including emojis and complex symbols.

Think of a string as an ordered list of characters, where each character has a specific position (index).

Defining Strings: Quotes and Context

The most common way to define a string literal in code is by enclosing a sequence of characters in quotes. Different languages and scenarios allow for different types of quotes.

Single vs. Double Quotes

Most languages are flexible here. The choice often comes down to style consistency or handling internal quotes.

Python Example:

# Using double quotes
message_double = "Hello, World!"
print(message_double)

# Using single quotes
message_single = 'Python is fun.'
print(message_single)

# Handling quotes within a string
statement = "He said, 'This is great!'"
print(statement)

another_statement = 'It\'s a beautiful day.' # Escaping the single quote
print(another_statement)

Hello, World!
Python is fun.
He said, 'This is great!'
It's a beautiful day.

JavaScript Example:

// Using double quotes
let nameDouble = "Alice";
console.log(nameDouble);

// Using single quotes
let nameSingle = 'Bob';
console.log(nameSingle);

// Mixing quotes
let quote = "He exclaimed, 'Wow!'";
console.log(quote);

let contractions = 'She won\'t be late.'; // Escaping the single quote
console.log(contractions);

Alice
Bob
He exclaimed, 'Wow!'
She won't be late.

Go Example:

In Go, double quotes " are for interpreted string literals (where escape sequences like \n are processed), and backticks ` are for raw string literals (where escape sequences are ignored, useful for multiline strings or regular expressions).

package main

import "fmt"

func main() {
    // Interpreted string literal (double quotes)
    interpretedString := "Hello, Go!\nNew line here."
    fmt.Println(interpretedString)

    // Raw string literal (backticks) - ignores escape sequences
    rawString := `This is a raw string.
    \n does not create a newline here.
    It's good for multi-line text or regex patterns: C:\Users\GoProgram`
    fmt.Println(rawString)
}

Hello, Go!
New line here.
This is a raw string.
    \n does not create a newline here.
    It's good for multi-line text or regex patterns: C:\Users\GoProgram

Multiline Strings

Sometimes you need a string that spans multiple lines.

Python Example:

Python uses triple single or triple double quotes for multiline strings.

multiline_string = """
This is a string
that spans multiple lines.
It preserves line breaks and indentation.
"""
print(multiline_string)


This is a string
that spans multiple lines.
It preserves line breaks and indentation.

JavaScript Example:

JavaScript uses backticks (`) for template literals, which also support multiline strings natively.

let multilineJS = `
This is a multiline
string in JavaScript.
It's part of ES6 template literals.
`;
console.log(multilineJS);


This is a multiline
string in JavaScript.
It's part of ES6 template literals.

Go Example:

As seen above, Go’s backtick raw string literals are perfect for multiline text.

String Immutability: A Core Concept

This is a critical concept to grasp: strings are immutable in many popular languages (Python, Java, JavaScript, Go, Ruby, C#).

What does “immutable” mean? It means that once a string object is created in memory, its content cannot be changed. Any operation that appears to modify a string (like converting to uppercase, concatenating, or replacing a character) actually creates a new string object in memory with the desired changes. The original string remains untouched.

Why does this matter?

Performance: Repeated string concatenation in a loop can be inefficient, as each operation creates a new string. For heavy string building, dedicated “string builder” types (like StringBuilder in Java, strings.Builder in Go) are often more performant.
Thread Safety: Immutability makes strings inherently thread-safe, as their state cannot be modified by multiple threads simultaneously.
Predictability: You can rely on a string’s content not changing unexpectedly.

Immutability in Action:

Python Example:

my_string = "hello"
print(f"Original string: {my_string}, ID: {id(my_string)}")

# This doesn't change 'my_string', it creates a NEW string
my_string_upper = my_string.upper()
print(f"Uppercase string: {my_string_upper}, ID: {id(my_string_upper)}")

# The original 'my_string' is unchanged
print(f"Original string after upper(): {my_string}, ID: {id(my_string)}")

# Concatenation also creates a new string
new_string = my_string + " world"
print(f"Concatenated string: {new_string}, ID: {id(new_string)}")
print(f"Original string unchanged by concat: {my_string}, ID: {id(my_string)}")

# Attempting to change a character directly will result in an error
try:
    my_string[0] = 'H' # This will raise a TypeError
except TypeError as e:
    print(f"Error trying to modify char: {e}")

Original string: hello, ID: 140722240505136
Uppercase string: HELLO, ID: 140722240505008
Original string after upper(): hello, ID: 140722240505136
Concatenated string: hello world, ID: 140722240505360
Original string unchanged by concat: hello, ID: 140722240505136
Error trying to modify char: 'str' object does not support item assignment

As you can see, id() (which gives the memory address of an object) changes when string operations occur, proving a new object is created. Direct character assignment fails.

Common String Operations

Let’s explore the most frequent tasks you’ll perform with strings.

1. Concatenation: Joining Strings

Combining two or more strings into one.

Python:

Using the + operator or f-strings.

part1 = "Hello"
part2 = "World"
greeting = part1 + ", " + part2 + "!"
print(greeting)

name = "Alice"
age = 30
info = f"My name is {name} and I am {age} years old." # F-string for easy concat/formatting
print(info)

Hello, World!
My name is Alice and I am 30 years old.

JavaScript:

Using the + operator or template literals.

let firstName = "John";
let lastName = "Doe";
let fullName = firstName + " " + lastName;
console.log(fullName);

let item = "Laptop";
let price = 1200;
let productInfo = `The ${item} costs $${price}.`; // Template literal
console.log(productInfo);

John Doe
The Laptop costs $1200.

Go:

Using + or fmt.Sprintf. For many concatenations in a loop, strings.Builder is more efficient.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Using + operator
	p1 := "Go"
	p2 := "Lang"
	message := p1 + " " + p2 + " is great!"
	fmt.Println(message)

	// Using fmt.Sprintf for formatted string building
	user := "Bob"
	score := 95
	greeting := fmt.Sprintf("Welcome, %s! Your score is %d.", user, score)
	fmt.Println(greeting)

	// Using strings.Builder for efficient concatenation
	var sb strings.Builder
	sb.WriteString("Builder example: ")
	sb.WriteString("First part. ")
	sb.WriteString("Second part.")
	fmt.Println(sb.String())
}

Go Lang is great!
Welcome, Bob! Your score is 95.
Builder example: First part. Second part.

2. Length: Getting String Size

Finding out how many characters are in a string.

Python:

len() function.

text = "Programming"
length = len(text)
print(f"Length of '{text}': {length}")

# Note: Python's len() counts Unicode characters (code points)
# "你好" (Ni Hao) consists of 2 characters, even though it's more bytes in UTF-8
emoji_text = "Hello 👋" # '👋' is a single character
print(f"Length of '{emoji_text}': {len(emoji_text)}")

Length of 'Programming': 11
Length of 'Hello 👋': 7

JavaScript:

.length property.

let phrase = "Hello Developers";
console.log(`Length of '${phrase}': ${phrase.length}`);

// Note: JavaScript's .length counts UTF-16 code units.
// For some emojis/Astral Plane characters, one character might be two code units.
// This is less common for typical text, but important for full Unicode handling.
let emojiPhrase = "🚀 Blast Off";
console.log(`Length of '${emojiPhrase}': ${emojiPhrase.length}`); // 🚀 is 2 code units

Length of 'Hello Developers': 16
Length of '🚀 Blast Off': 12

Go:

len() for byte length, utf8.RuneCountInString for character count. This distinction is crucial in Go.

package main

import (
	"fmt"
	"unicode/utf8" // For character counting
)

func main() {
	strASCII := "abcdefg"
	fmt.Printf("len(\"%s\") (bytes): %d\n", strASCII, len(strASCII))

	strUTF8 := "你好世界" // Ni Hao Shi Jie (Hello World in Chinese)
	// len() gives byte length for UTF-8 encoded string
	fmt.Printf("len(\"%s\") (bytes): %d\n", strUTF8, len(strUTF8))
	// To get character count (runes), use utf8.RuneCountInString
	fmt.Printf("utf8.RuneCountInString(\"%s\") (characters): %d\n", strUTF8, utf8.RuneCountInString(strUTF8))

    emojiStr := "👋 Go!"
    fmt.Printf("len(\"%s\") (bytes): %d\n", emojiStr, len(emojiStr))
    fmt.Printf("utf8.RuneCountInString(\"%s\") (characters): %d\n", emojiStr, utf8.RuneCountInString(emojiStr))
}

len("abcdefg") (bytes): 7
len("你好世界") (bytes): 12
utf8.RuneCountInString("你好世界") (characters): 4
len("👋 Go!") (bytes): 9
utf8.RuneCountInString("👋 Go!") (characters): 5

Note: In Go, strings are sequences of bytes, not characters. len() returns the number of bytes. If your string contains multi-byte UTF-8 characters (like Chinese characters or emojis), len() will not give you the character count. Use unicode/utf8.RuneCountInString for accurate character counts.

3. Accessing Characters and Substrings (Indexing & Slicing)

Strings are ordered sequences, meaning each character has an index, starting from 0.

Python:

Indexing [] and slicing [:]. Negative indices count from the end.

word = "Example"
print(f"First character: {word[0]}")
print(f"Last character: {word[-1]}")

# Slicing: [start:end:step] (end is exclusive)
print(f"Substring (index 1 to 3): {word[1:4]}") # 'xam'
print(f"From beginning to index 4: {word[:5]}") # 'Examp'
print(f"From index 2 to end: {word[2:]}") # 'ample'
print(f"Full string (copy): {word[:]}")
print(f"Every second character: {word[::2]}") # 'Eap'
print(f"Reversed string: {word[::-1]}") # 'elpmaxE'

First character: E
Last character: e
Substring (index 1 to 3): xam
From beginning to index 4: Examp
From index 2 to end: ample
Full string (copy): Example
Every second character: Eap
Reversed string: elpmaxE

JavaScript:

[] for character access, substring(), slice(), charAt() for substrings.

let data = "JavaScript";
console.log(`First character: ${data[0]}`); // Or data.charAt(0)
console.log(`Character at index 4: ${data.charAt(4)}`); // 'S'

// slice(startIndex, endIndex_exclusive)
console.log(`Substring (index 0 to 4): ${data.slice(0, 5)}`); // 'JavaS'
console.log(`From index 4 to end: ${data.slice(4)}`); // 'Script'

// substring(startIndex, endIndex_exclusive) - similar to slice,
// but handles negative arguments differently. slice is generally preferred.
console.log(`Substring (index 0 to 4): ${data.substring(0, 5)}`); // 'JavaS'

First character: J
Character at index 4: S
Substring (index 0 to 4): JavaS
From index 4 to end: Script
Substring (index 0 to 4): JavaS

Go:

Indexing returns bytes. Slicing with str[start:end] also operates on bytes. To work with characters (runes), you need to convert to a []rune slice first.

package main

import "fmt"

func main() {
	text := "golang"
	// Accessing bytes by index
	fmt.Printf("Byte at index 0: %c\n", text[0]) // Prints 'g'

	// Slicing bytes
	fmt.Printf("Byte slice (0-3): %s\n", text[0:4]) // "gola"

	// Working with runes (characters) for proper Unicode handling
	unicodeText := "Go你好" // "GoNiHao" - 2 ASCII, 2 Chinese chars
	runes := []rune(unicodeText) // Convert string to a slice of runes
	fmt.Printf("Rune at index 0: %c\n", runes[0]) // 'G'
	fmt.Printf("Rune at index 2: %c\n", runes[2]) // '你'

	// Slicing runes
	fmt.Printf("Rune slice (0-3): %s\n", string(runes[0:4])) // "Go你好"
	fmt.Printf("Rune slice (2-end): %s\n", string(runes[2:])) // "你好"
}

Byte at index 0: g
Byte slice (0-3): gola
Rune at index 0: G
Rune at index 2: 你
Rune slice (0-3): Go你好
Rune slice (2-end): 你好

Note: Directly indexing a Go string str[i] gives you the byte at that position, not necessarily a character (rune), especially for multi-byte UTF-8 characters. To get individual characters or character-based slices, convert the string to a []rune slice first.

4. Searching and Finding Substrings

Checking if a string contains another string, or finding its position.

Python:

in operator, find(), index().

sentence = "The quick brown fox jumps over the lazy dog."

# 'in' operator for checking existence
print(f"'fox' in sentence: {'fox' in sentence}")
print(f"'cat' in sentence: {'cat' in sentence}")

# find() returns the lowest index where the substring is found, or -1 if not found
print(f"Index of 'brown': {sentence.find('brown')}")
print(f"Index of 'the' (first occurrence): {sentence.find('the')}")
print(f"Index of 'the' (from specific start): {sentence.find('the', 20)}") # Start search from index 20
print(f"Index of 'zebra': {sentence.find('zebra')}") # -1

# index() is similar to find() but raises a ValueError if not found
try:
    print(f"Index of 'dog': {sentence.index('dog')}")
    print(f"Index of 'lion': {sentence.index('lion')}") # This will raise ValueError
except ValueError as e:
    print(f"Error finding 'lion': {e}")

'fox' in sentence: True
'cat' in sentence: False
Index of 'brown': 10
Index of 'the' (first occurrence): 0
Index of 'the' (from specific start): 31
Index of 'zebra': -1
Index of 'dog': 39
Error finding 'lion': substring not found

JavaScript:

includes(), indexOf(), startsWith(), endsWith().

let textJS = "Learn JavaScript, it's a versatile language.";

console.log(`Contains 'JavaScript': ${textJS.includes('JavaScript')}`);
console.log(`Contains 'Python': ${textJS.includes('Python')}`);

console.log(`Index of 'language': ${textJS.indexOf('language')}`);
console.log(`Index of 'script' (not found): ${textJS.indexOf('script')}`); // Case-sensitive!

console.log(`Starts with 'Learn': ${textJS.startsWith('Learn')}`);
console.log(`Ends with 'language.': ${textJS.endsWith('language.')}`);

Contains 'JavaScript': true
Contains 'Python': false
Index of 'language': 30
Index of 'script' (not found): -1
Starts with 'Learn': true
Ends with 'language.': true

Go:

Functions in the strings package.

package main

import (
	"fmt"
	"strings"
)

func main() {
	mainString := "Go programming is powerful."

	// Check if substring exists
	fmt.Printf("Contains 'Go': %t\n", strings.Contains(mainString, "Go"))
	fmt.Printf("Contains 'Java': %t\n", strings.Contains(mainString, "Java"))

	// Find index of first occurrence
	fmt.Printf("Index of 'programming': %d\n", strings.Index(mainString, "programming"))
	fmt.Printf("Index of 'xyz' (not found): %d\n", strings.Index(mainString, "xyz")) // -1

	// Check prefix/suffix
	fmt.Printf("Starts with 'Go programming': %t\n", strings.HasPrefix(mainString, "Go programming"))
	fmt.Printf("Ends with 'powerful.': %t\n", strings.HasSuffix(mainString, "powerful."))
}

Contains 'Go': true
Contains 'Java': false
Index of 'programming': 3
Index of 'xyz' (not found): -1
Starts with 'Go programming': true
Ends with 'powerful.': true

5. Replacing Substrings

Substituting one part of a string with another.

Python:

.replace(old, new, count) method.

data = "apple, banana, apple, orange"
new_data = data.replace("apple", "grape")
print(f"Replaced all apples: {new_data}")

# Replace only the first occurrence
single_replace = data.replace("apple", "kiwi", 1)
print(f"Replaced first apple: {single_replace}")

Replaced all apples: grape, banana, grape, orange
Replaced first apple: kiwi, banana, apple, orange

JavaScript:

.replace(searchValue, replaceValue) method. Note that .replace() by default replaces only the first occurrence. To replace all, you need a regular expression with the g (global) flag.

let textReplace = "The cat sat on the mat. The cat was happy.";
let newText = textReplace.replace("cat", "dog"); // Replaces only the first 'cat'
console.log(`Replaced first: ${newText}`);

// To replace all occurrences, use a regular expression with the 'g' flag
let allReplaced = textReplace.replace(/cat/g, "dog");
console.log(`Replaced all: ${allReplaced}`);

Replaced first: The dog sat on the mat. The cat was happy.
Replaced all: The dog sat on the mat. The dog was happy.

Go:

strings.Replace() and strings.ReplaceAll().

package main

import (
	"fmt"
	"strings"
)
func main() {
	original := "one two three one four one"
	// Replace only n occurrences (n=1 for first, n=-1 for all)
	fmt.Printf("Replace first 'one': %s\n", strings.Replace(original, "one", "zero", 1))
	fmt.Printf("Replace all 'one': %s\n", strings.Replace(original, "one", "zero", -1))

	// strings.ReplaceAll is a convenient shortcut for n=-1
	fmt.Printf("ReplaceAll 'one': %s\n", strings.ReplaceAll(original, "one", "zero"))
}

Replace first 'one': zero two three one four one
Replace all 'one': zero two three zero four zero
ReplaceAll 'one': zero two three zero four zero

6. Case Conversion

Changing a string to all uppercase, all lowercase, or proper case.

Python:

.upper(), .lower(), .capitalize(), .title().

s = "PyThOn PrOgRaMmInG"
print(f"Original: {s}")
print(f"Uppercase: {s.upper()}")
print(f"Lowercase: {s.lower()}")
print(f"Capitalized (first char only): {s.capitalize()}")
print(f"Title case (first char of each word): {s.title()}")

Original: PyThOn PrOgRaMmInG
Uppercase: PYTHON PROGRAMMING
Lowercase: python programming
Capitalized (first char only): Python programming
Title case (first char of each word): Python Programming

JavaScript:

.toUpperCase(), .toLowerCase().

let sJS = "Hello World";
console.log(`Original: ${sJS}`);
console.log(`Uppercase: ${sJS.toUpperCase()}`);
console.log(`Lowercase: ${sJS.toLowerCase()}`);

Original: Hello World
Uppercase: HELLO WORLD
Lowercase: hello world

Go:

strings.ToUpper(), strings.ToLower().

package main

import (
	"fmt"
	"strings"
)

func main() {
	strGo := "Welcome To Go!"
	fmt.Printf("Original: %s\n", strGo)
	fmt.Printf("Uppercase: %s\n", strings.ToUpper(strGo))
	fmt.Printf("Lowercase: %s\n", strings.ToLower(strGo))
}

Original: Welcome To Go!
Uppercase: WELCOME TO GO!
Lowercase: welcome to go!

7. Trimming Whitespace

Removing leading, trailing, or both leading and trailing whitespace characters.

Python:

.strip(), .lstrip(), .rstrip().

ws_string = "   Hello, World!   \n"
print(f"Original (repr): {repr(ws_string)}") # repr() shows raw string with newlines
print(f"Stripped: {repr(ws_string.strip())}")
print(f"Left stripped: {repr(ws_string.lstrip())}")
print(f"Right stripped: {repr(ws_string.rstrip())}")

# You can also specify characters to strip
chars_to_strip = " ,!H"
custom_strip = "   ,Hello!   ".strip(chars_to_strip)
print(f"Custom stripped: {repr(custom_strip)}")

Original (repr): '   Hello, World!   \n'
Stripped: 'Hello, World!'
Left stripped: 'Hello, World!   \n'
Right stripped: '   Hello, World!'
Custom stripped: 'ello'

JavaScript:

.trim(), .trimStart(), .trimEnd().

let wsJs = "   JavaScript is fun.   \t";
console.log(`Original (repr): '${wsJs}'`);
console.log(`Trimmed: '${wsJs.trim()}'`);
console.log(`Trimmed Start: '${wsJs.trimStart()}'`);
console.log(`Trimmed End: '${wsJs.trimEnd()}'`);

Original (repr): '   JavaScript is fun.   	'
Trimmed: 'JavaScript is fun.'
Trimmed Start: 'JavaScript is fun.   	'
Trimmed End: '   JavaScript is fun.'

Go:

strings.TrimSpace(), strings.TrimLeft(), strings.TrimRight(), strings.Trim().

package main

import (
	"fmt"
	"strings"
)

func main() {
	wsGo := "\t  Go Lang  \n"
	fmt.Printf("Original (repr): '%s'\n", wsGo)
	fmt.Printf("Trimmed Space: '%s'\n", strings.TrimSpace(wsGo))
	fmt.Printf("Trimmed Left: '%s'\n", strings.TrimLeft(wsGo, "\t ")) // Trim spaces and tabs from left
	fmt.Printf("Trimmed Right: '%s'\n", strings.TrimRight(wsGo, " \n")) // Trim spaces and newlines from right

	// Trim specific characters from both ends
	customTrim := "---Hello, World!---"
	fmt.Printf("Custom Trimmed: '%s'\n", strings.Trim(customTrim, "-"))
}

Original (repr): '	  Go Lang  
'
Trimmed Space: 'Go Lang'
Trimmed Left: 'Go Lang  
'
Trimmed Right: '	  Go Lang'
Custom Trimmed: 'Hello, World!'

8. Splitting and Joining

Splitting a string into a list/array of substrings based on a delimiter, and joining a list/array of strings back into one.

Python:

.split() and .join().

csv_data = "apple,banana,orange"
fruits = csv_data.split(",")
print(f"Split string: {fruits}")

sentence_split = "This is a sample sentence."
words = sentence_split.split(" ")
print(f"Split by space: {words}")

# Joining a list of strings
new_sentence = " ".join(words)
print(f"Joined words: {new_sentence}")

path_components = ["usr", "local", "bin"]
full_path = "/".join(path_components)
print(f"Joined path: /{full_path}")

Split string: ['apple', 'banana', 'orange']
Split by space: ['This', 'is', 'a', 'sample', 'sentence.']
Joined words: This is a sample sentence.
Joined path: /usr/local/bin

JavaScript:

.split() and .join().

let tagsString = "web, frontend, javascript, css";
let tagsArray = tagsString.split(", ");
console.log(`Split tags: ${tagsArray}`);

let urlParts = "www.example.com/api/v1/users".split("/");
console.log(`Split URL: ${urlParts}`);

let colors = ["red", "green", "blue"];
let colorsString = colors.join("-");
console.log(`Joined colors: ${colorsString}`);

let pathSegments = ["home", "user", "documents"];
let finalPath = pathSegments.join("/");
console.log(`Joined path: /${finalPath}`);

Split tags: web,frontend,javascript,css
Split URL: www.example.com,,api,v1,users
Joined colors: red-green-blue
Joined path: /home/user/documents

Go:

strings.Split() and strings.Join().

package main

import (
	"fmt"
	"strings"
)

func main() {
	commaSeparated := "item1,item2,item3"
	items := strings.Split(commaSeparated, ",")
	fmt.Printf("Split items: %v\n", items) // %v for default representation of value

	line := "word1 word2   word3"
	words := strings.Fields(line) // Splits by one or more consecutive white space characters
	fmt.Printf("Split fields: %v\n", words)

	parts := []string{"hello", "world", "go"}
	joined := strings.Join(parts, " ")
	fmt.Printf("Joined parts: %s\n", joined)

	ipParts := []string{"192", "168", "1", "100"}
	ipAddress := strings.Join(ipParts, ".")
	fmt.Printf("Joined IP: %s\n", ipAddress)
}

Split items: [item1 item2 item3]
Split fields: [word1 word2 word3]
Joined parts: hello world go
Joined IP: 192.168.1.100

Note: strings.Fields() is a handy Go function to split a string by any sequence of Unicode white space characters, returning a slice of strings.

String Formatting: Creating Dynamic Strings

Creating strings with dynamic content is a very common task, especially for generating output messages, logs, or reports.

Python:

F-strings (formatted string literals) are the modern, highly readable way. .format() is also widely used.

product = "Laptop"
price = 1200.50
quantity = 2

# F-strings (Python 3.6+)
print(f"Ordered {quantity} x {product} at ${price:.2f} each. Total: ${quantity * price:.2f}")

# .format() method
print("Ordered {} x {} at ${:.2f} each. Total: ${:.2f}".format(quantity, product, price, quantity * price))

# Positional and keyword arguments with .format()
print("Hello, {name}. Your balance is {bal:.2f}.".format(name="Alice", bal=123.456))
print("The order is {1} x {0}".format("Book", 5)) # Positional index

Ordered 2 x Laptop at $1200.50 each. Total: $2401.00
Ordered 2 x Laptop at $1200.50 each. Total: $2401.00
Hello, Alice. Your balance is 123.46.
The order is 5 x Book

JavaScript:

Template literals (with backticks `) are the modern way using $ and curly braces {}.

let city = "New York";
let temperature = 25.7;

// Template literals (ES6+)
console.log(`The temperature in ${city} is ${temperature}°C.`);

let userPoints = 1500;
let level = "Gold";
console.log(`User ${user} has ${userPoints} points and is a ${level} member.`); // User is undefined

let greeting = "Hello";
let person = "Dave";
let message = `${greeting}, ${person}! You have ${5 + 3} new messages.`;
console.log(message);

The temperature in New York is 25.7°C.
User undefined has 1500 points and is a Gold member.
Hello, Dave! You have 8 new messages.

Note: In the second JavaScript example, user was not defined. This highlights that variables need to be declared before they can be used in template literals.

Go:

fmt package functions like fmt.Sprintf() (for formatting into a string) and fmt.Printf() (for formatting and printing to console). Uses verb placeholders like %s, %d, %f.

package main

import "fmt"

func main() {
	item := "Keyboard"
	cost := 75.99
	count := 3

	// fmt.Sprintf to create a formatted string
	invoice := fmt.Sprintf("You bought %d units of %s at $%.2f each. Total: $%.2f.",
		count, item, cost, float64(count)*cost)
	fmt.Println(invoice)

	// fmt.Printf to print directly
	name := "Charlie"
	age := 42
	fmt.Printf("Name: %s, Age: %d years.\n", name, age)

	// More formatting verbs
	fmt.Printf("Binary: %b, Decimal: %d, Hex: %x\n", 10, 10, 10)
	fmt.Printf("Float (default): %f, Float (2 decimal): %.2f, Scientific: %e\n", 3.14159, 3.14159, 3.14159)
}

You bought 3 units of Keyboard at $75.99 each. Total: $227.97.
Name: Charlie, Age: 42 years.
Binary: 1010, Decimal: 10, Hex: a
Float (default): 3.141590, Float (2 decimal): 3.14, Scientific: 3.141590e+00

Note: Go’s fmt package is inspired by C’s printf and offers extensive formatting options with various verbs. Remember fmt.Sprintf returns a string, while fmt.Printf prints to standard output.

A Brief Word on Encoding and Unicode

While many common string operations work intuitively, it’s important to be aware of character encodings, especially when dealing with internationalization or file I/O.

ASCII: The oldest standard, representing 128 characters (English letters, numbers, basic symbols).
Unicode: A universal character set that assigns a unique number (code point) to every character in every writing system.
UTF-8: The most common encoding of Unicode characters. It’s a variable-width encoding, meaning different characters take up different numbers of bytes (1 to 4 bytes for most common characters). It’s backward-compatible with ASCII.

Modern languages like Python 3, JavaScript, and Go handle Unicode by default, but how they interpret “characters” and “length” can differ due to their internal representations (e.g., Python 3 strings are sequences of Unicode code points, Go strings are UTF-8 byte sequences, JS strings are UTF-16 code units). This usually only becomes critical when dealing with string length calculations for multi-byte characters or complex text manipulation.

Best Practices and Tips

Be Consistent with Quotes: Pick a style (single or double quotes) and stick to it within your project for readability. Use the alternative when you need to embed quotes within a string without escaping.
Embrace Modern Formatting: Use f-strings (Python), template literals (JavaScript), or fmt.Sprintf (Go) for dynamic string creation. They are generally more readable and less error-prone than manual concatenation.
Understand Immutability: Remember that string operations create new strings. For heavy string building (e.g., constructing a large string in a loop), consider using string builder mechanisms if available in your language (e.g., strings.Builder in Go, or an array and join in JavaScript/Python) for better performance.
Mind Character Encoding: While often handled behind the scenes, be aware of Unicode and UTF-8 when dealing with text from diverse languages, especially when reading from/writing to files, network streams, or calculating precise string lengths in Go.
Use Library Functions: Don’t reinvent the wheel. Languages provide rich string libraries (str methods in Python, String methods in JS, strings package in Go) for common operations.

Conclusion

Strings are the backbone of text manipulation in programming. From simple messages to complex data parsing, mastering string operations is an essential skill. By understanding how to define, manipulate, and format strings, along with crucial concepts like immutability, you’ll be well-equipped to handle any text-related task your development journey throws at you.

Practice these examples, try to build small programs that interact with strings, and you’ll quickly find yourself comfortable and proficient. Happy coding!

How Hamiltonian Mechanics Shapes Orbital Simulation Engines

Jun 17, 2025

Understanding and Using Bridges for Developers

Jun 18, 2025

How YouTube Uses Caching Trees for Video Recommendation

Jun 17, 2025

Factory Pattern Explained

Jun 18, 2025

How DNS Impacts Site Speed (and How to Fix It)

Jun 17, 2025

Meta’s $100M Talent Raid - 8 OpenAI Researchers Join Superintelligence Labs

Jul 10, 2025