Unterschied zwischen String-Interpolation und String-Verkettung

Question

Wenn speziell nicht-optionale String Werte behandelt werden, was könnte der Unterschied zwischen String-Interpolation und String-Verkettung sein?

struct MyModel { 
    let value1: String 
    let value2: String 
    var displayNameByConcatenation: String { 
     return value1 + "-" + value2 
    } 
    var displayNameByInterpolation: String { 
     return "\(value1)-\(value2)" 
    } 
} 

• Wird es jedem Fall sein, wo displayNameByConcatenation und displayNameByInterpolation unterschiedlich sind? Wie bei langen Unicode-Strings?
• Ist es möglich, das Verhalten des Operators + oder das Verhalten der Interpolation irgendwie zu überschreiben, um sie im obigen Beispiel anders zu machen?
• Ist einer schneller/langsamer als der andere?

Beachten Sie, dass aus this question wir erfahren, dass String-Interpolation die description eines CustomStringConvertible verwenden. Aber ruft String Verkettung (Operator +) auch die description?

Answer 1

Von einer Geschwindigkeit Sicht Verkettung (value1 + "-" + value2) und Interpolation ("\(value1)-\(value2)") zu unterscheiden, hier sind meine Ergebnisse auf einem iPhone 6:

concatenation: 0.0225991666084155 
interpolation: 0.0346928749931976 

Basierend auf diesen Ergebnissen Verkettung schneller ist.

Probieren Sie es selbst:

import UIKit 

class ViewController: UIViewController { 
    override func viewDidAppear(_ animated: Bool) { 
     super.viewDidAppear(animated) 

     DispatchQueue.global(qos: .default).async { 
      ViewController.buildDataAndTest() 
     } 
    } 

    private static func buildDataAndTest() { 
     let characterSet = CharacterSet.alphanumerics 
     characterSet.cacheAllCharacters() 
     let data: [(String, String)] = (0...10_000).map { _ in 
      (characterSet.randomString(length: 72), characterSet.randomString(length: 36)) 
     } 
     _ = testCIA(data) 
     _ = testInterpol(data) 
     print("concatenation: " + String(resultConcatenation)) 
     print("interpolation: \(resultInterpolation)") 
    } 

    /// concatenation in array 
    static var resultConcatenation: CFTimeInterval = 0 
    private static func testCIA(_ array: [(String, String)]) -> String { 
     var foo = "" 
     let start = CACurrentMediaTime() 
     for (a, b) in array { 
      foo = foo + " " + a + "+" + b 
     } 
     resultConcatenation = CACurrentMediaTime() - start 
     return foo 
    } 

    /// interpolation 
    static var resultInterpolation: CFTimeInterval = 0 
    private static func testInterpol(_ array: [(String, String)]) -> String { 
     var foo = "" 
     let start = CACurrentMediaTime() 
     for (a, b) in array { 
      foo = "\(foo) \(a)+\(b)" 
     } 
     resultInterpolation = CACurrentMediaTime() - start 
     return foo 
    } 
} 

extension CharacterSet { 
    static var cachedCharacters: [Character] = [] 

    public func cacheAllCharacters() { 
     CharacterSet.cachedCharacters = allCharacters() 
    } 

    public func allCharacters() -> [Character] { 
     var allCharacters = [Character]() 
     for plane: UInt8 in 0 ... 16 where hasMember(inPlane: plane) { 
      for unicode in UInt32(plane) << 16 ..< UInt32(plane + 1) << 16 { 
       if let uniChar = UnicodeScalar(unicode), contains(uniChar) { 
        allCharacters.append(Character(uniChar)) 
       } 
      } 
     } 
     return allCharacters 
    } 

    // http://stackoverflow.com/a/42895178/1033581 
    public func randomString(length: Int) -> String { 
     let charArray = CharacterSet.cachedCharacters 
     let charArrayCount = UInt32(charArray.count) 
     var randomString = "" 
     for _ in 0 ..< length { 
      randomString += String(charArray[Int(arc4random_uniform(charArrayCount))]) 
     } 
     return randomString 
    } 
} 

Answer 2

String Interpolation:

• weniger eingeben
• ruft intern zu bespannen
• schneller während der Laufzeit

einen Nachteil:

• Zeichenfolge begrenzen

Sowohl Interpolation und Verkettung hat seine eigene Stärke und Schwäche

benötigen Verkettung mit vordefinierten Zeichenfolge zu verwenden, eine bessere Leistung zu erhalten

Answer 3

„Concatenation ermöglicht es Ihnen zusammen zu kombinieren, um Streicher und es funktioniert nur auf zwei Saiten . "

Ein Update. Nicht sicher, was frühere Versionen von Swift erlaubt, aber zur Zeit können Sie mehr als 2 Strings zusammen in derselben Anweisung verketten:

let str = "Hallo, mein Name ist"

var concat = str + "2" + "3" + "4" + "5" + "funktioniert" // zeigt "Hallo, mein Name ist 2345 funktioniert"

Da beide Operanden von + Strings sein müssen, müssen Sie ein wenig mehr Arbeit verrichten Wenn Sie einer Zeichenfolge eine Zahl hinzufügen möchten:

var concat2 = str + Zeichenfolge (2) // zeigt "Hallo, mein Name ist 2"

Grund warum Interpolation statt Verkettung, hier ist ein Zitat aus Apples Intro für Interpolation: "String-Interpolation ist eine Möglichkeit, einen neuen String-Wert aus einer Mischung von Konstanten, Variablen, Literalen und Ausdrücken zu konstruieren" Mit anderen Worten, Sie können verwenden Interpolation mit Zahlen, booleschen Werten usw., ohne sie zuvor in Strings umzuwandeln, was Sie tun müssten, wenn Sie eine Verkettung verwenden würden.

Unterschiedliche zwischen Verkettungs und Interpolation

Verkettungs Arbeiten mit Strings nur

let str = "Hallo"

lassen anotherString = "mein Name ist"

let myName = str + anotherString

Ausgang: Hallo, mein Name ist

Interpolation Swift verwendet String Interpolation den Namen eines konstanten oder variablen als Platzhalter in einer längeren Zeichenfolge enthalten, und Swift aufzufordern es mit dem aktuellen zu ersetzen Wert dieser Konstante oder Variable.

Lassen Sie Temp = 52 Lassen Sie TemperaturDisplay = "Die aktuelle Temperatur ist (Temp) Fahrenheit."

// Sie können auch die Auswertung eines Ausdrucks ersetzen String Interpolation

lassen celciusTempDisplay = "Die aktuelle Temperatur ((temp-30)/2) Celcius."