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]"

Next - Operator Declarations by Example


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



Share Tweet Send
0 Comments
Loading...
You've successfully subscribed to Developer Insider
Great! Next, complete checkout for full access to Developer Insider
Welcome back! You've successfully signed in
Success! Your account is fully activated, you now have access to all content.