preface
Learning is like rowing upstream; not to advance is to drop back. Mutual encouragement!!
Today I want to share with you an article about Text interpolation and localization in SwiftUI. If you gain something, a little like with a little attention to support. The original | address
Interpolation in Text
Text is the simplest and most common View in SwiftUI. For basic use, we can create a Text by passing in a string literal:
1. Text("Hello World")
Copy the code
In iOS 14 (SwiftUI 2.0), Apple has made a number of enhancements to Text interpolation. In addition to simple Text, we can insert an Image directly into a Text:
1. Text("Hello (Image(systemName: "globe"))")
Copy the code
ImageOutside,TextString interpolation can also accept a number of other “weird” types, some of which even accept formatter for the incoming property, which brings us a lot of convenience:
Text("Date: (Date(), style: .date)")
Text("Time: (Date(), style: .time)")
Text("Meeting: (DateInterval(start: Date(), end: Date(timeIntervalSinceNow: 3600)))")
let fomatter: NumberFormatter = {
let f = NumberFormatter()
f.numberStyle = .currency
return f
}()
Text("Pay: (123 as NSNumber, formatter: fomatter)")
Copy the code
At the same time, however, some of the most common string interpolation methods are not supported in Text. Typically, we can experience two errors with appendInterpolation:
Text("3 == 3 is \(true)") // Error: // No exact matches in call to instance method 'appendInterpolation' struct Person { let name: String let place: String } Text("Hi, \(Person(name: "Geralt", place: // Instance method 'appendInterpolation' requires that 'Person' conform to '_FormatSpecifiable'Copy the codeAppendInterpolation = _FormatSpecifiable = _FormatSpecifiable = appendInterpolation = _FormatSpecifiable How do you make these types work with Text?
I intend to spend two articles exploring this topic and related API design.
In this article, we’ll start by looking at why Text can accept Image or Date as interpolation, but not Bool or Person, referring to the custom string interpolation feature introduced in Swift 5. Later in the next installment, we’ll explore the deeper aspects behind this topic and see how localization in SwiftUI actually works. We will also discuss how to solve the corresponding problems and use these features to write more correct and beautiful SwiftUI code.
Hero behind the scene: LocalizedStringKey
SwiftUI put multilingual localization support in the first place, in the direct use to initialize a string literal Text, the call to the method in fact is the init (_ : tableName: bundle: the comment:) :
extension Text {
init(
_ key: LocalizedStringKey,
tableName: String? = nil,
bundle: Bundle? = nil,
comment: StaticString? = nil
)
}
Copy the codeText uses the input key to find the localized string file in the bundle and renders the result for the device language.
Because LocalizedStringKey meet ExpressibleByStringInterpolation ExpressibleByStringLiteral (and his father agreement), it can directly convert by string literals. In other words, in the example above, whether the interpolated Image or Date is the Image or Date, the result, as input to the Text initialization method, is actually a LocalizedStringKey instance.
For string literals, Text uses the LocalizedStringKey overload above. If the String is stored in a String first, such as let s = “hello”, then Text(s) will pick another StringProtocol initialization method: init< s >(_ content: s) where s: StringProtocol.
Another important initialization method for Text is init(verbatim:). If you don’t need localization at all, using this method will let you use the input string directly, skipping LocalizedStringKey entirely.
We can prove this by simply trying to print the above interpolated string as normal string interpolation would:
print("Hello (Image(systemName: "globe"))") // Hello Image(provider: SwiftUI.ImageProviderBox<SwiftUI.Image.(unknown context at $1b472d684).NamedImageProvider>) print("Date: (Date(), style:.date)") // Cannot infer contextual base in reference to member 'Date'Copy the codeImage interpolation directly uses the standard description of struct and returns a normal string; The interpolation of Date does not accept additional parameters, giving a compilation error. Either way, you can’t pass it to Text as a simple string and get the final rendering.
In fact, in the Text initialization method, this kind of interpolation uses the LocalizedStringKey correlation interpolation method. This is also a new feature in Swift 5 that allows us to interpolate any type of input (such as Image) and even set some parameters (such as Date and its.date style parameter) while interpolating.
StringInterpolation
Plain string interpolation is a feature that Swift has had since its inception. We can use (variable) to add a value to a String literal that can be represented as a String:
print("3 == 3 is (true)")
// 3 == 3 is true
let luckyNumber = 7
print("My lucky number is (luckNumber).")
// My lucky number is 7.
let name = "onevcat"
print("I am (name).")
// I am onevcat.
Copy the codeIn Swift 5, literal interpolation is enhanced. We can keep a type to ExpressibleByStringInterpolation customize interpolation behavior. This feature has been discussed quite a bit, but let’s take a look at its basic usage again to get you familiar and recall it more quickly.
Swift String in the standard library is to meet the agreement, to extend the String supported by the type of interpolation, we can expand the String. StringInterpolation types of implementation, it needed to add the appropriate type. Use the Person shown above as an example. Without modification, print will print the Person value in the Swift struct default format:
struct Person {
let name: String
let place: String
}
print("Hi, (Person(name: "Geralt", place: "Rivia"))")
// Hi, Person(name: "Geralt", place: "Rivia")
Copy the codeIf we want a name more role play, can consider to extend the String. StringInterpolation, add a appendInterpolation (_ person: Person) method, which defines the behavior of a string literal when it receives a Person:
extension String.StringInterpolation { mutating func appendInterpolation(_ person: Person) {// call 'appendLiteral(_ literal: String)' accepts' String 'arguments appendLiteral("(person.name) of (person.place)")}}Copy the codeNow, the Person interpolation in String will change:
print("Hi, (Person(name: "Geralt", place: "Rivia"))")
// Hi, Geralt of Rivia
Copy the codeIn the case of multiple parameters, we can in the String. StringInterpolation add new parameters, and the interpolation with similar “method call” writing, the parameter passed in:
Struct Person {let name: String let place: String var nickName: String? } extension Person {var formalTitle: String {"(name) of (place)"} Bool) -> String { isFriend ? (nickName ?? formalTitle) : formalTitle } } extension String.StringInterpolation { mutating func appendInterpolation(_ person: Person, isFriend: Bool) { appendLiteral(person.title(isFriend: isFriend)) } }Copy the codeCall with isFriend:
let person = Person(
name: "Geralt", place: "Rivia", nickName: "White Wolf"
)
print("Hi, (person, isFriend: true)")
// Hi, White Wolf
Copy the codeString interpolation for LocalizedStringKey
Image and Date
Now that we know the StringInterpolation, we can see how LocalizedStringKey handles interpolation in Text context. Similar to ordinary String, LocalizedStringKey also abide by the ExpressibleByStringInterpolation, And SwiftUI already provides some common extensions for its StringInterpolation. In the current SwiftUI implementation (iOS 14), they include:
extension LocalizedStringKey.StringInterpolation {
mutating func appendInterpolation(_ string: String)
mutating func appendInterpolation<Subject>(_ subject: Subject, formatter: Formatter? = nil) where Subject : ReferenceConvertible
mutating func appendInterpolation<Subject>(_ subject: Subject, formatter: Formatter? = nil) where Subject : NSObject
mutating func appendInterpolation<T>(_ value: T) where T : _FormatSpecifiable
mutating func appendInterpolation<T>(_ value: T, specifier: String) where T : _FormatSpecifiable
mutating func appendInterpolation(_ text: Text)
mutating func appendInterpolation(_ image: Image)
mutating func appendInterpolation(_ date: Date, style: Text.DateStyle)
mutating func appendInterpolation(_ dates: ClosedRange<Date>)
mutating func appendInterpolation(_ interval: DateInterval)
}
Copy the codeIn the example in the first part of this article, the interpolation of Image and Date style is done using exactly the method declared above. After receiving the correct parameter type, the final LocalizedStringKey is obtained by creating the appropriate Text. We can easily write two appendInterpolation implementations in our example:
mutating func appendInterpolation(_ image: Image) {
appendInterpolation(Text(image))
}
mutating func appendInterpolation(_ date: Date, style: Text.DateStyle) {
appendInterpolation(Text(date, style: style))
}
Copy the codeBool and Person
Now, it’s easy to see why Bool and Person can’t be used directly in Text in the top example.
The Bool:
Text("3 == 3 is (true)") // No exact matches in call to instance method 'appendInterpolation'Copy the codeLocalizedStringKey does not extend the appendInterpolation method to Bool, so there is no way to generate an instance of LocalizedStringKey using interpolation.
For Person, the initial error is relatively hard to understand:
Text("Hi, (Person(name: "Geralt", place: // Instance method 'appendInterpolation' requires that 'Person' conform to '_FormatSpecifiable'Copy the codeWith the existing appendInterpolation implementation in SwiftUI, you can see that it actually uses:
mutating func appendInterpolation<T>(_ value: T) where T : _FormatSpecifiable
Copy the codeThis is the closest overloaded method, but since Person does not implement the _FormatSpecifiable private protocol, there is essentially no interpolation method. To fix this, we can either add appendInterpolation to the Person or have it comply with the _FormatSpecifiable private protocol. However, the two methods are fundamentally different, and can sometimes have unexpected results depending on the actual use scenario. We’ll cover this topic in more detail in the next post in this series.
summary
- SwiftUI 2.0 can be used to
TextThe interpolationImage和DateSuch nonStringValue, which makes it very easy to mix text or format text. - Flexible interpolation benefits from the introduction of Swift 5.0
ExpressibleByStringInterpolation. You can have theStringCustom interpolation, and even for any type of custom string interpolation. - Class with a string literal
TextIs the type of the argumentLocalizedStringKey. LocalizedStringKeyAcceptance is achievedImageorDateInterpolation method, so we can create inTextWhen directly insertedImageOr formattedDate.LocalizedStringKeyDon’t acceptBoolOr interpolation parameters of a custom type. We could add related methods, but that would have side effects.
The iOS data | address