String by Example - Swift Programming Language

Overview

A string literal is a sequence of characters surrounded by double quotes (").

1. Creating and Initializing Strings

1.1 Initializing Strings

let name = "vineeta"  
print(name)  
  • String interpolations are string literals that evaluate any included expressions and convert the results to string form.
  • String interpolations give you an easy way to build a string from multiple pieces.
  • Wrap each expression in a string interpolation in parentheses, prefixed by a backslash.
let name = "Vineeta"  
print( "Welcome, \(name)!")  

1.2 Initializing Multiline string

  • Multiline string literals are enclosed in three double quotation marks ("""), with each delimiter on its own line.
  • Indentation is stripped from each line of a multiline string literal to match the indentation of the closing delimiter.
let banner = """  
          __,
         (          o   /) _/_
          `.  , , , ,  //  /
        (___)(_(_/_(_ //_ (__
                     /)
                    (/
        """
print(banner)  

1.3 Initializing an Empty String

var emptyString = ""  
var anotherEmptyString = String()  
var anotherOneEmptyString: String

let newString = String()  

2. Modifying and Comparing Strings

  • Strings always have value semantics. Modifying a copy of a string leaves the original unaffected.

2.1 Strings can be combined using the concatenation operator (+).

let name : String = "Vineeta"  
let greetMsg =  name + " We're glad you're here!"  
print(greetMsg)                 

//prints Vineeta We're glad you're here!

2.2 String Mutability

  • String can be modified (or mutated) by assigning it to a variable (in which case it can be modified), or to a constant (in which case it cannot be modified).
var variableString = "Horse"  
variableString += " and carriage"  
print(variableString)  

2.3 Compairing String

  • Comparing strings for equality using the equal-to operator (==) or a relational operator (like < or >=).
let cafe1 = "Cafe\u{301}"  
let cafe2 = "Café"  
print(cafe1 == cafe2)  

3. Measuring the Length of a String

  • A single string can have greatly differing lengths when measured by its different views.
let name = "Vineeta"  
print(name.count)                            // prints 7  
print(name.utf8.count)                       // prints 7  
print(name.utf16.count)                      // prints 7  
print(name.unicodeScalars.count)             // prints 7  

4. Inspecting a String - isEmpty

let name = "Vineeta"  
if name.isEmpty{  
    print("empty tag ")
}else{
    print("Name: \(name)")
}
// prints Name:Vineeta

5. Changing Case

5.1 uppercase

var name = "Vineeta"  
print(name.uppercased())  
//prints VINEETA

5.2 lowercased

var name = "Vineeta"  
print(name.lowercased())  
//prints vineeta

6. Finding Substrings

  • Any String instance can be bridged to NSString using the type-cast operator (as), and any String instance that originates in Objective-C may use an NSString instance as its storage.
  • import Foundation framework to your code to use NSString instances.

6.1 hasSuffix

import Foundation  
var str = "My name is Vineeta"  
if str.hasSuffix("Vineeta"){  
    print("true")
}else{
    print("false")
}
//prints true

6.2 hasPrefix

import Foundation  
var str = "My name is Vineeta"  
if str.hasPrefix("My"){  
    print("true")
}else{
    print("false")
}
// prints true 

7. Finding Characters

7.1 contains

  • Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
let cast = ["Vivek", "vineet", "vineeta", "akshay"]  
print(cast.contains("vineet"))  
//prints true 
print(cast.contains("James"))  
//prints false

7.2 contains(where:)

  • Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
let expenses = [21.37, 55.21, 9.32, 10.18, 388.77, 11.41]  
let hasBigPurchase = expenses.contains { $0 > 100 }  
print(hasBigPurchase)  
//prints true

7.3 first(where:)

  • Returns the first element of the sequence that satisfies the given predicate.
let numbers = [3, 7, 4, -2, 9, -6, 10, 1]  
if let firstNegative = numbers.first(where: { $0 < 0 }) {  
print("The first negative number is \(firstNegative).")  
}
// prints "The first negative number is -2."

7.4 index(of:)

  • Returns the first index where the specified value appears in the collection.
var students = ["Akshay", "vivek", "vineet", "vineeta"]  
if let i = students.index(of: "Maxime") {  
students[i] = "Max"  
}
print(students)  
//prints ["Akshay", "vivek", "vineet", "vineeta"]

7.5 index(where:)

  • Returns the first index in which an element of the collection satisfies the given predicate.
import Foundation  
let students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]  
if let i = students.index(where: { $0.hasPrefix("A") }) {  
print("\(students[i]) starts with 'A'!")  
}
// prints Abena starts with 'A'!

7.6 max()

  • Returns the maximum element in the sequence.
let heights = [67.5, 65.7, 64.3, 61.1, 58.5, 60.3, 64.9]  
let greatestHeight = heights.max()  
print(greatestHeight ?? "nothing in there")  
//prints 67.5

7.7 max(by:)

  • Returns the maximum element in the sequence, using the given predicate as the comparison between elements.
let hues = ["Heliotrope": 296, "Coral": 16, "Aquamarine": 156]  
let greatestHue = hues.max { a, b in a.value < b.value }  
print(greatestHue ?? "nothing")  
//prints (key: "Heliotrope", value: 296)

8. Appending Strings and Characters

8.1 append(_:)

  • Adds an element to the end of the collection.
var numbers = [1, 2, 3, 4, 5]  
numbers.append(100)  
print(numbers)  
//prints [1, 2, 3, 4, 5, 100]

8.2 append(_:)

  • Appends the given string to this string.
var name = "rachel"  
name.append("ross")  
print(name)  
//prints rachelross

9. Inserting Characters

9.1 insert(_:at:)

  • Inserts a new character at the specified position.
var name = "rachel"  
name.insert("a", at:name.startIndex)  
print(name)  
//prints arachelross

9.2 insert(_:at:)

  • Inserts a new element into the collection at the specified position.
numbersArray.insert(100, at: 3)  
numbersArray.insert(200, at: numbersArray.endIndex)  
print(numbersArray)  
//prints [1, 2, 100, 3, 4, 5, 200]

10. Removing Substrings

10.1 remove(at:)

  • Removes and returns the character at the specified position.
var nonempty = "non-empty"  
if let i = nonempty.characters.index(of: "-") {  
    nonempty.remove(at: i)
}
print(nonempty)  
//prints nonempty

10.2 remove(at:)

  • Removes and returns the element at the specified position.
var measurements = [1.2, 1.5, 2.9, 1.2, 1.6]  
let removed = measurements.remove(at: 2)  
print(measurements)  
// Prints "[1.2, 1.5, 1.2, 1.6]"

10.3 removeAll(keepingCapacity:)

  • Replaces this string with the empty string.
var measurements = [1.2, 1.5, 2.9, 1.2, 1.6]  
let removeAll = measurements.removeAll()  
print(measurements)  
//prints []

10.4 removeFirst()

  • Removes and returns the first element of the collection.
var bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"]  
bugs.removeFirst()  
print(bugs)  
// Prints "["Bumblebee", "Cicada", "Damselfly", "Earwig"]"

10.5 removeFirst(_:)

  • Removes the specified number of elements from the beginning of the collection.
var bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"]  
bugs.removeFirst(3)  
print(bugs)  
// Prints "["Damselfly", "Earwig"]"

10.6 removeLast()

  • Removes and returns the last element of the collection.
var bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"]  
bugs.removeLast()  
print(bugs)  
//prints ["Aphid", "Bumblebee", "Cicada", "Damselfly"]

10.7 removeLast(_:)

  • Removes the specified number of elements from the end of the collection.
var bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"]  
bugs.removeLast(2)  
print(bugs)  
//prints ["Aphid", "Bumblebee"]

10.8 removeSubrange(_:)

  • Removes the elements in the specified subrange from the collection.
var measurements = [1.2, 1.5, 2.9, 1.2, 1.6]  
measurements.removeSubrange(1..<4)  
print(measurements)  
//prints [1.2, 1.6]

10.9 removeSubrange(_:)

  • Removes the elements in the specified subrange from the collection.
var measurements = [1.2, 1.5, 2.9, 1.2, 1.5]  
measurements.removeSubrange(1..<4)  
print(measurements)  
// Prints "[1.2, 1.5]"

10.10 filter(_:)

  • Returns a new collection of the same type containing, in order, the elements of the original collection that satisfy the given predicate.
let cast = ["Vivien", "Marlon", "Kim", "Karl"]  
let shortNames = cast.filter { $0.count < 5 }  
print(shortNames)  
// Prints "["Kim", "Karl"]"

11. Getting Characters and Bytes

11.1 subscript(_:)

  • Accesses the character at the given position.
let greeting = "Hello, friend!"  
if let i = greeting.characters.index(where: { $0 >= "A" && $0 <= "Z" }) {  
    print("First capital letter: \(greeting[i])")
}
//prints First capital letter: H

11.2 first

  • The first element of the collection.
let numbersArr = [10, 20, 30, 40, 50]  
if let firstNumber = numbersArr.first {  
    print(firstNumber)
}
//prints 10

11.3 last

  • The last element of the collection.
let numbersArr = [10, 20, 30, 40, 50]  
if let firstNumber = numbersArr.last {  
    print(firstNumber)
}
//prints 50

12. Related String Types

12.1 Substring

  • A slice of a string.
let greeting = "Hi there! It's nice to meet you! đź‘‹"  
let endOfSentence = greeting.index(of: "!")!  
let firstSentence = greeting[...endOfSentence]  
print(firstSentence)  
// firstSentence == "Hi there!"

12.2 Converting a Substring to a String

  • This example defines a rawData string with some unstructured data, and then uses the string’s prefix(while:) method to create a substring of the numeric prefix.
let rawInput = "126 a.b 22219 zzzzzz"  
let numericPrefix = rawInput.prefix(while: { "0"..."9" ~= $0 })  
print(numericPrefix)  
//prints 126

13. Describing a String

13.1 description

let rawInput = "126 a.b 22219 zzzzzz"  
print(rawInput.description)  
// prints 126 a.b 22219 zzzzzz

13.2 debugDescription

  • A representation of the string that is suitable for debugging.
let rawInput = "126 a.b 22219 zzzzzz"  
print(rawInput.debugDescription)  
// prints "126 a.b 22219 zzzzzz"

13.3 customMirror

  • A mirror that reflects the String instance.
let rawInput = "126 a.b 22219 zzzzzz"  
print(rawInput.customMirror)  
// prints Mirror for String

13.4 customPlaygroundQuickLook

let rawInput = "126 a.b 22219 zzzzzz"  
print(rawInput.customPlaygroundQuickLook)  
// prints text("126 a.b 22219 zzzzzz")

13.5 hashValue

  • The string’s hash value.
let rawInput = "126 a.b 22219 zzzzzz"  
print(rawInput.hashValue)  
// prints 9200157961725904825

14. Creating a Range Expression

14.1 ..<(_:)

  • Returns a partial range up to, but not including, its upper bound.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers[..<3])  
//prints [10, 20, 30]

14.2 ...(_:)

  • Returns a partial range extending upward from a lower bound.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers[3...])  
//prints [40, 50, 60, 70]

14.3 ...(_:)

  • Returns a partial range up to, and including, its upper bound.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers[...3])  
//prints [10, 20, 30, 40]

15. Manipulating Indices

15.1 startIndex

  • The position of the first character in a nonempty string.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers.startIndex)  
//prints 0

15.2 endIndex

  • A string’s “past the end” position—that is, the position one greater than the last valid subscript argument.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers.endIndex)  
//prints 7

15.3 index(after:)

  • Returns the position immediately after the given index.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers.index(after: 3))  
//prints 4

15.4 index(_:offsetBy:)

  • Returns an index that is the specified distance from the given index.
let s = "Swift"  
let i = s.index(s.startIndex, offsetBy: 4)  
print(s[i])  
// prints t

15.5 index(_:offsetBy:limitedBy:)

  • Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.
let s = "Swift"  
if let i = s.index(s.startIndex, offsetBy: 4, limitedBy: s.endIndex) {  
    print(s[i])
}
// prints "t"

15.6 index(before:)

let numbers = [10, 20, 30, 40, 50, 60, 70]  
print(numbers.index(before: 3))  
//prints 2

15.7 distance(from:to:)

  • Returns the distance between two indices.
let numbers = [10, 20, 30, 40, 50, 60, 70]  
let numDistance = numbers.distance(from: 0, to: 3)  
print(numDistance)  
//prints 3

16. Iterating over a String's Characters

16.1 forEach(_:)

  • Calls the given closure on each element in the sequence in the same order as a for-in loop.
let numberWords = ["one", "two", "three"]  
for word in numberWords {  
    print(word)
}
// prints "one"
// prints "two"
// prints "three"

numberWords.forEach { word in  
    print(word)
}
// prints "one"
// prints "two"
// prints "three"

16.2 enumerated()

  • Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero, and x represents an element of the sequence.
for (n, c) in "Swift".enumerated() {  
    print("\(n): '\(c)'")
}
//prints 0: 'S'
//prints 1: 'w'
//prints 2: 'i'
//prints 3: 'f'
//prints 4: 't'

17. Sorting a String's Characters

17.1 sorted()

  • Returns the elements of the sequence, sorted.
let students: Set = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]  
let sortedStudents = students.sorted()  
print(sortedStudents)  
//prints ["Abena", "Akosua", "Kofi", "Kweku", "Peter"]

17.2 sorted(by:)

  • Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.
let students: Set = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]  
let descendingStudents = students.sorted(by: >)  
print(descendingStudents)  
//prints ["Peter", "Kweku", "Kofi", "Akosua", "Abena"]

17.3 reversed()

  • Returns a view presenting the elements of the collection in reverse order.
let word = "Backwards"  
for char in word.reversed() {  
    print(char, terminator: "")
}
//prints sdrawkcaB

18. Working with String Views

18.1 characters

  • A view of the string’s contents as a collection of characters.
let word = "Backwards"  
for char in word.characters{  
    print(char)
}
//prints B
//a
//c
//k
//w
//a
//r
//d
//s

18.2 init(_:)

  • Creates a string from the given character view
let poem = """  
      'Twas brillig, and the slithy toves /
      Did gyre and gimbal in the wabe: /
      All mimsy were the borogoves /
      And the mome raths outgrabe.
      """
let excerpt = String(poem.characters.prefix(22)) + "..."  
print(excerpt)  
// Prints "'Twas brillig, and the..."

18.3 withMutableCharacters(_:)

  • Applies the given closure to a mutable view of the string’s characters.
var str = "All this happened, more or less."  
let afterSpace = str.withMutableCharacters { chars -> String.CharacterView in  
    if let i = chars.index(of: " ") {
        let result = chars[chars.index(after: i)...]
        chars.removeSubrange(i...)
        return result
    }
    return String.CharacterView()
}

print(str)  
// Prints "All"
print(String(afterSpace))  
// Prints "this happened, more or less."

18.4 unicodeScalars

  • The string’s value represented as a collection of Unicode scalar values.
let word = "Backwards"  
for char in word.unicodeScalars{  
    print(char)
}
//prints B
// a
// c
// k
// w
// a
// r
// d
// s

18.5 init(_:)

  • Creates a string corresponding to the given collection of Unicode scalars.
let picnicGuest = "Deserving porcupine"  
if let i = picnicGuest.unicodeScalars.index(of: " ") {  
    let adjective = String(picnicGuest.unicodeScalars[..<i])
    print(adjective)
}
//prints Deserving

18.6 utf16

  • A UTF-16 encoding of self.
let picnicGuest = "Deserving porcupine"  
print(picnicGuest.utf16.count)  
//prints 19

18.7 utf8

  • A UTF-8 encoding of self.
let picnicGuest = "Deserving porcupine"  
print(picnicGuest.utf8.count)  
//prints 19

19. Transforming a String's Characters

19.1 map(_:)

  • Returns an array containing the results of mapping the given closure over the sequence’s elements.
let cast = ["Vivien", "Marlon", "Kim", "Karl"]  
let lowercaseNames = cast.map { print($0.lowercased()) }  
//prints vivien
// marlon
// kim
// karl
let letterCounts = cast.map { print($0.count) }  
//prints 6
// 6
// 3
// 4

19.2 reduce(::)

  • Returns the result of combining the elements of the sequence using the given closure.
let numbers = [1, 2, 3, 4]  
let numberSum = print(numbers.reduce(0, { x, y in  
    x + y
}))
//prints 10

20. Getting C Strings - utf8CString

  • A contiguously stored null-terminated UTF-8 representation of the string.
let s = "Hello!"  
let bytes = s.utf8CString  
print(bytes)  
// Prints "[72, 101, 108, 108, 111, 33, 0]"

You can download the swift playground of all above examples from Here




Related Article