Julia Strings

Julia provides powerful string processing capabilities with Unicode support and various string operations.

String Basics

Creating Strings

# Create string with double quotes
s = "Hello, Julia!"
println(s)

# Multi-line string (triple quotes)
multiline = """
This is line one
This is line two
This is line three
"""
println(multiline)

# Raw string (no escaping)
raw_str = raw"C:\Users\name\Documents"
println(raw_str)  # C:\Users\name\Documents

Characters and Strings

# Characters use single quotes
c = 'A'
println(typeof(c))  # Char

# Strings use double quotes
s = "A"
println(typeof(s))  # String

# Characters are Unicode code points
println(Int('A'))   # 65
println(Char(65))   # 'A'
println('中')       # Chinese character
println(Int('中'))  # 20013

Escape Characters

# Common escape characters
println("newline\nnew line")
println("tab\tindent")
println("backslash\\")
println("quote\"")
println("single quote\'")

# Unicode escape
println("\u4e2d\u6587")  # 中文
println("\U0001F600")    # 😀

String Operations

Concatenation

# Using * to concatenate
s1 = "Hello"
s2 = "World"
s3 = s1 * " " * s2
println(s3)  # Hello World

# Using string function
s4 = string(s1, " ", s2)
println(s4)  # Hello World

# Using join
words = ["Hello", "Julia", "World"]
s5 = join(words, ", ")
println(s5)  # Hello, Julia, World

String Interpolation

name = "Julia"
version = 1.10

# Using $ for interpolation
println("Welcome to $name!")
println("Version: $version")

# Expression interpolation with $()
println("2 + 3 = $(2 + 3)")
println("Uppercase: $(uppercase(name))")

# Nested expressions
data = [1, 2, 3]
println("Sum: $(sum(data))")

Repeating Strings

# Using ^ operator
s = "ab" ^ 3
println(s)  # ababab

# Using repeat function
s = repeat("ab", 3)
println(s)  # ababab

Length and Indexing

s = "Hello, Julia!"

# Length
println(length(s))  # 13 (character count)
println(sizeof(s))  # 13 (byte count, same for ASCII)

# Indexing (1-based)
println(s[1])       # 'H'
println(s[end])     # '!'
println(s[end-1])   # 'a'

# Substring
println(s[1:5])     # "Hello"
println(s[8:end])   # "Julia!"

# Unicode strings
s_cn = "你好，世界"
println(length(s_cn))  # 5 (character count)
println(sizeof(s_cn))  # 15 (byte count, UTF-8)

Iterating Strings

s = "Julia"

# Iterate characters
for c in s
    println(c)
end

# Iterate with index
for (i, c) in enumerate(s)
    println("$i: $c")
end

# Collect to array
chars = collect(s)
println(chars)  # ['J', 'u', 'l', 'i', 'a']

String Functions

Case Conversion

s = "Hello, Julia!"

println(uppercase(s))   # HELLO, JULIA!
println(lowercase(s))   # hello, julia!
println(titlecase(s))   # Hello, Julia!

# First letter case
println(uppercasefirst("hello"))  # Hello
println(lowercasefirst("HELLO"))  # hELLO

Stripping Whitespace

s = "  Hello, Julia!  "

# Strip both ends
println(strip(s))       # "Hello, Julia!"

# Strip left
println(lstrip(s))      # "Hello, Julia!  "

# Strip right
println(rstrip(s))      # "  Hello, Julia!"

# Strip specific characters
s2 = "...Hello..."
println(strip(s2, '.'))  # "Hello"

Finding and Replacing

s = "Hello, Julia! Hello, World!"

# Find substring
println(findfirst("Julia", s))  # 8:12 (range)
println(findlast("Hello", s))   # 15:19
println(findall("Hello", s))    # Two ranges

# Check contains
println(contains(s, "Julia"))    # true
println(occursin("Julia", s))    # true (different argument order)

# Start and end checks
println(startswith(s, "Hello"))  # true
println(endswith(s, "World!"))   # true

# Replace
println(replace(s, "Hello" => "Hi"))
# "Hi, Julia! Hi, World!"

# Replace only first occurrence
println(replace(s, "Hello" => "Hi", count=1))
# "Hi, Julia! Hello, World!"

Splitting and Joining

# Split string
s = "apple,banana,cherry"
parts = split(s, ",")
println(parts)  # ["apple", "banana", "cherry"]

# Split by whitespace
s2 = "Hello   World"
println(split(s2))  # ["Hello", "World"]

# Limit split count
println(split(s, ",", limit=2))  # ["apple", "banana,cherry"]

# Join strings
parts = ["apple", "banana", "cherry"]
println(join(parts, ", "))  # "apple, banana, cherry"
println(join(parts, " & "))  # "apple & banana & cherry"

Character Operations

# Character classification
println(isdigit('5'))     # true
println(isletter('A'))    # true
println(isspace(' '))     # true
println(ispunct('.'))     # true
println(isuppercase('A')) # true
println(islowercase('a')) # true

# String classification
println(isascii("Hello"))     # true
println(isascii("你好"))      # false
println(isnumeric("123"))     # Check each character

Padding and Alignment

# Padding
println(lpad("42", 5, '0'))   # "00042"
println(rpad("Hello", 10))    # "Hello     "

# Specify padding character
println(lpad("test", 10, '-'))  # "------test"
println(rpad("test", 10, '-'))  # "test------"

String Comparison

s1 = "apple"
s2 = "banana"
s3 = "Apple"

# Equality comparison
println(s1 == "apple")   # true

# Lexicographic comparison
println(s1 < s2)         # true

# Case-insensitive comparison
println(lowercase(s1) == lowercase(s3))  # true

# cmp function
println(cmp("a", "b"))   # -1
println(cmp("b", "a"))   # 1
println(cmp("a", "a"))   # 0

String Building

Using IOBuffer

For lots of string concatenation, IOBuffer is more efficient:

io = IOBuffer()

for i in 1:5
    print(io, "Item $i, ")
end

result = String(take!(io))
println(result)  # "Item 1, Item 2, Item 3, Item 4, Item 5, "

Using sprint

# sprint captures output as string
s = sprint() do io
    println(io, "Line 1")
    println(io, "Line 2")
    print(io, "Line 3")
end
println(s)

Formatted Output

@sprintf Macro

using Printf

# Format string
s = @sprintf("Integer: %d, Float: %.2f, String: %s", 42, 3.14159, "hello")
println(s)

# Common format specifiers
@printf("%d\n", 42)        # Integer
@printf("%f\n", 3.14)      # Float
@printf("%.2f\n", 3.14159) # 2 decimal places
@printf("%e\n", 12345.0)   # Scientific notation
@printf("%s\n", "hello")   # String
@printf("%c\n", 'A')       # Character
@printf("%x\n", 255)       # Hexadecimal: ff
@printf("%o\n", 64)        # Octal: 100
@printf("%b\n", 10)        # Binary: 1010

# Width and alignment
@printf("%10d\n", 42)      # Right-aligned, width 10
@printf("%-10d\n", 42)     # Left-aligned
@printf("%010d\n", 42)     # Zero-padded

Unicode Support

# Julia natively supports Unicode
s = "你好，世界！"
println(s)
println(length(s))  # 6 characters

# Unicode identifiers
α = 0.5
β = 1.5
result = α + β
println(result)  # 2.0

# String normalization
using Unicode
s1 = "café"
println(normalize(s1, :NFC))  # Normalize

Substring Type

s = "Hello, Julia!"

# SubString is a view, no copy
sub = SubString(s, 1, 5)
println(sub)         # "Hello"
println(typeof(sub)) # SubString{String}

# Convert to String
str = String(sub)
println(typeof(str)) # String

Practical Examples

Parse CSV Line

function parse_csv_line(line)
    fields = split(line, ",")
    return strip.(fields)  # Strip whitespace from each field
end

line = "  apple , banana ,  cherry  "
println(parse_csv_line(line))  # ["apple", "banana", "cherry"]

Template Strings

function render_template(template, data)
    result = template
    for (key, value) in data
        result = replace(result, "{$key}" => string(value))
    end
    return result
end

template = "Hello, {name}! You have {count} messages."
data = Dict("name" => "Alice", "count" => 5)
println(render_template(template, data))
# "Hello, Alice! You have 5 messages."

Word Count

function word_count(text)
    words = split(lowercase(text))
    counts = Dict{String, Int}()
    for word in words
        w = strip(word, ['.', ',', '!', '?'])
        counts[w] = get(counts, w, 0) + 1
    end
    return counts
end

text = "Hello world! Hello Julia. Julia is great!"
println(word_count(text))

Next Steps

After learning strings, continue with:

• Regular Expressions - Pattern matching
• File I/O - Text file processing
• Functions - Custom string functions