Swift Strings

• A string is a series of characters
• Swift strings are represented by the String type
• Contents of a String can be accessed as a collection of Character values
• Swift's String and Character types are Unicode-compliant
• Syntax for string creation and manipulation is readable, similar to C
• String concatenation combines two strings with the + operator
• String mutability is managed by choosing between a constant or a variable
• Strings can insert constants, variables, literals, and expressions via string interpolation
• Swift's String type is a fast, modern string implementation composed of Unicode characters

String Literals

• Predefined String values can be included within code as string literals
• String literals are a sequence of characters surrounded by double quotation marks (")
• You can use a string literal as an initial value for a constant or variable
• Swift infers a type of String for constants initialized with a string literal value

Multiline String Literals

• For strings spanning several lines, use multiline string literals, which are surrounded by three double quotation marks (""")
• Multiline string literals include all lines between the opening and closing quotation marks
• The string begins on the first line after the opening quotation marks (""") and ends on the line before the closing quotation marks
• Line breaks inside a multiline string literal appear in the string's value
• Use a backslash (\) at the end of a line to prevent line breaks from being part of the string's value
• To start or end a multiline string literal with a line feed, use a blank line as the first or last line
• Multiline strings can be indented to match surrounding code
• Whitespace before the closing quotation marks determines which whitespace is ignored before other lines
• Extra whitespace at the beginning of a line beyond the indentation of the closing quotes is included

Special Characters in String Literals

• String literals can include special characters:
  • Escaped special characters: \0 (null), \\ (backslash), \t (horizontal tab), \n (line feed), \r (carriage return), \" (double quote), \' (single quote)
  • Unicode scalar values: \u{n}, where n is a 1–8 digit hexadecimal number
• Double quotation marks (") can be included inside a multiline string literal without escaping
• To include the text """ in a multiline string, escape at least one of the quotation marks

Extended String Delimiters

• String literals can be placed within extended delimiters (quotation marks and number signs #) to include special characters without invoking their effect
• Printing #"Line 1\nLine 2"# prints the line feed escape sequence (\n) rather than printing the string across two lines
• The number of number signs within the string following the escape character (\) should match the number of number signs surrounding the string
• String literals created using extended delimiters can also be multiline string literals
• Extended delimiters can include the text """ in a multiline string, overriding the default behavior

Initializing an Empty String

• Create an empty String by assigning an empty string literal to a variable or initializing a new String instance

  • var emptyString = ""
    var anotherEmptyString = String()
    

• Check if a String value is empty using its Boolean isEmpty property

String Mutability

• Assign a String to a variable to allow modification
• Assign a String to a constant to prevent modification

Strings Are Value Types

• Swift's String type is a value type
• When a String is passed to a function/method or assigned to a constant/variable, it is copied
• Swift's compiler optimizes string usage so that actual copying takes place only when absolutely necessary.

Working with Characters

• Access individual Character values of a String by iterating with a for-in loop
• Create a stand-alone Character constant or variable from a single-character string literal by providing a Character type annotation
• Construct String values by passing an array of Character values as an argument to its initializer

Concatenating Strings and Characters

• Use the addition operator (+) to concatenate String values and create a new String value
• Append a String value to an existing String variable with the addition assignment operator (+=)
• Append a Character value to a String variable using the String type’s append() method
• Ensure every line ends with a line break when building up longer strings with multiline string literals

String Interpolation

• String interpolation constructs a new String value from a mix of constants, variables, literals, and expressions
• Insert items into a string literal by wrapping them in parentheses, prefixed by a backslash (\)
• Use extended string delimiters to create strings containing characters that would otherwise be treated as a string interpolation
• To use string interpolation inside a string that uses extended delimiters, match the number of number signs after the backslash to the number of number signs surrounding the string.

Unicode

• Unicode is an international standard for encoding, representing, and processing text
• Swift’s String and Character types are fully Unicode-compliant

Unicode Scalar Values

• Swift’s native String type is built from Unicode scalar values
• A Unicode scalar value is a unique 21-bit number for a character or modifier

Extended Grapheme Clusters

• Swift's Character type represents a single extended grapheme cluster
• An extended grapheme cluster is a sequence of one or more Unicode scalars that produce a single human-readable character

Counting Characters

• Use the count property to retrieve a count of Character values in a string
• String concatenation and modification may not always affect string character count
• Appending a combining acute accent to "cafe" results in "café", but the character count remains 4

Accessing and Modifying a String

String Indices

• Each String value has an associated index type, String.Index, corresponding to the position of each Character
• Swift strings cannot be indexed by integer values due to variable memory allocation for different characters
• startIndex property accesses the position of the first Character of a String
• endIndex property is the position after the last character in a String
• endIndex property isn’t a valid argument to a string’s subscript
• startIndex and endIndex are equal when a String is empty
• Access indices before and after a given index using the index(before:) and index(after:) methods of String
• Use the index(_:offsetBy:) method to access an index farther away from the given index, instead of calling index(before:) and index(after:) multiple times.
• Use subscript syntax to access the Character at a particular String index
• Accessing an index outside of a string’s range or a Character at an index outside of a string’s range will trigger a runtime error
• Use indices property to access all of the indices of individual characters in a string

Inserting and Removing

• Use the insert(_:at:) method to insert a single character at a specified index in a string
• Use the insert(contentsOf:at:) method to insert the contents of another string at a specified index
• Use the remove(at:) method to remove a single character at a specified index in a string
• Use the removeSubrange(_:) method to remove a substring at a specified range