Unterschied zwischen String und StaticString

Ich war das surfen im docs, und ich fand StaticString. Es besagt:

Eine einfache Zeichenfolge, die die Darstellung von text, die "erkennbar zur compile-Zeit".

Ich ursprünglich dachte, dass String hat das gleiche Verhalten wie NSString, die zur Kompilierzeit bekannt ist, aber es sieht so aus, dass ich falsch lag. Also meine Frage ist Wann sollen wir verwenden StaticString statt einer String, und der einzige Unterschied ist, dass StaticString bekannt ist zur compile-Zeit?

Eine Sache, die ich fand, ist

var a: String = "asdf" //"asdf"
var b: StaticString = "adsf" //{(Opaque Value), (Opaque Value), (Opaque Value)}

sizeofValue(a)  //24
sizeofValue(b)  //17

So wie es aussieht StaticString hat ein bisschen weniger Speicherbedarf.

InformationsquelleAutor Dániel Nagy | 2015-08-27

string swift

7

Scheint es, dass StaticString können string-Literale. Sie können nicht zuweisen einer variable vom Typ String zu es, und es kann nicht mutiert (mit += zum Beispiel).

"Erkennbar zur compile-Zeit" bedeutet nicht, dass der Wert gehalten, der durch die variable bestimmt werden, die zur compile-Zeit, nur dass kein Wert zugewiesen ist, ist es zur Kompilierzeit bekannt ist.

Betrachten Sie dieses Beispiel, das funktioniert:
```
var str: StaticString

for _ in 1...10 {
    switch arc4random_uniform(3) {
    case 0: str = "zero"
    case 1: str = "one"
    case 2: str = "two"
    default: str = "default"
    }
    print(str)
}
```
Jede Zeit, die Sie geben können, Swift mehr Informationen darüber, wie eine variable verwendet werden, es können optimieren Sie den code verwenden. Durch die Beschränkung auf eine variable StaticString Swift kennt die variable nicht mutiert, so dass es speichern kann, ist es effizienter, und der Zugriff auf die einzelnen Zeichen effizienter zu gestalten.

In der Tat StaticString umgesetzt werden könnte, mit nur einer Adresse-Zeiger und eine Länge. Die Adresse verweist, ist nur der Ort, in den statischen code, wo die Zeichenkette definiert ist. Ein StaticString brauchen wir nicht zu verweisen gezählt, da es sich nicht (müssen) gibt es in den heap. Es ist weder zugewiesen noch freigegeben, so dass keine Referenz-Zählung benötigt werden.

"Erkennbar zur compile-Zeit" ist ziemlich streng. Auch dies funktioniert nicht:
```
let str: StaticString = "hello " + "world"
```
welche schlägt fehl mit Fehler:

Fehler: 'String' nicht konvertierbar 'StaticString'
- Ich bin ein wenig verwirrt über "den Wert gehalten, der durch die variable bestimmt werden, die zur compile-Zeit, nur dass kein Wert zugewiesen ist, ist es erkennbar zur compile-Zeit." Was ist dann der Unterschied zwischen erkennbares zur compile-Zeit und ermittelt im compile-Zeit? Und StaticStrings werden nicht mutiert, aber Sie können neu zugewiesen werden, wie gut. Also im Grunde der compiler nicht sicher sein kann, über Ihren Wert.
- Der compiler weiß nicht, welchen Wert eine variable vom Typ StaticString halten wird zur compile-Zeit, aber es muss wissen, dass jeder Wert, der zugewiesen werden soll, die variable ist ein string-literal, das war zur Kompilierzeit bekannt ist. Was Swift wird tun, mit diesen Informationen ist nur bekannt, zu der Autoren von Swift, bis Sie release der open-source-code.
InformationsquelleAutor vacawama
4

StaticString erkennbar ist zur compile-Zeit. Dies kann dazu führen Optimierungen durch. Beispiel:

EDIT: Das Teil funktioniert nicht, siehe edit unten

Angenommen, Sie haben eine Funktion, die berechnet, der Int für einige String Werte für einige Konstanten, die Sie definieren, die zur compile-Zeit.
```
let someString = "Test"
let otherString = "Hello there"

func numberForString(string: String) -> Int {
    return string.stringValue.unicodeScalars.reduce(0) { $0 * 1 << 8 + Int($1.value) }
}

let some = numberForString(someString)
let other = numberForString(otherString)
```
Wie diese, würde die Funktion ausgeführt werden, die mit "Test" und "Hallo", wenn es wirklich aufgerufen wird, in das Programm, wenn die app startet, zum Beispiel. Auf jeden Fall bei der Laufzeit. Jedoch, wenn Sie ändern Ihre Funktion zu nehmen StaticString
```
func numberForString(string: StaticString) -> Int {
    return string.stringValue.unicodeScalars.reduce(0) { $0 * 1 << 8 + Int($1.value) }
}
```
weiß der compiler, dass die Weitergabe in StaticString erkennbar ist zur compile-Zeit, so denke, was es tut? Es führt die Funktion rechts zur compile-Zeit (Wie genial ist das!). Ich Las einmal einen Artikel über die Autorin überprüft die generierte assembly, und er fand tatsächlich die bereits berechnete zahlen.

Wie Sie sehen können, dies kann nützlich sein, in einigen Fällen, wie erwähnt, nicht ab-Laufzeit-performance für Dinge, die getan werden kann zur compile-Zeit.

EDIT: Dániel Nagy und mir hatte ein Gespräch. Das obige Beispiel von mir funktioniert nicht, da die Funktion stringValue von StaticString können nicht zum Zeitpunkt der Kompilierung bekannt (denn es gibt eine String). Hier ist ein besseres Beispiel:
```
func countStatic(string: StaticString) -> Int {
    return string.byteSize    //Breakpoint here
}

func count(string: String) -> Int {
    return string.characters.count    //Breakpoint here
}

let staticString : StaticString = "static string"
let string : String = "string"


print(countStatic(staticString))
print(count(string))
```
In einem release-build nur die zweite breakpoint wird ausgelöst, in der Erwägung, dass, wenn Sie ändern die erste Funktion zu
```
func countStatic(string: StaticString) -> Int {
    return string.stringValue.characters.count    //Breakpoint here
}
```
beide Haltepunkte ausgelöst.

Anscheinend gibt es einige Methoden, die getan werden kann zur compile-Zeit, während andere nicht können. Ich Frage mich, wie der compiler die zahlen das tatsächlich.
- Also im Grunde, wenn ich Debuggen und setzen einen breakpoint in der Funktion, die verwendet das StaticString, sollte es nicht einmal eingeben?
- Hmm ich weiß nicht, vielleicht hat es erwischt wird beim kompilieren, können Sie es ausprobieren denke ich
- Ich habe es versucht und du hattest Recht! Aber kannst du deine Antwort mit einem kleinen Zusatz? Ich habe diese: func test() -> String { return StaticString(stringLiteral: "hejj").stringValue } Methode zu testen, was Sie behaupteten, setzen Sie einen Haltepunkt, um es, und sehen, was passiert ist. Die Standard-Swift-compiler-Optimierung ist Keine, aber wenn Sie dies ändern, um die Schnellste oder der Schnellste, nicht aktiviert, ist der kompilierte Wert wurde eingefügt, so dass das Programm nicht gestoppt, an der breakpont. So können Sie fügen Sie diese Swift-compiler-Optimierungen änderungen an Ihrer Antwort?
- Warten Sie, es ist die Arbeit mit regulären String als gut:S
- Hmm kann ich nicht verifizieren, bei mir Stoppt am breakpoint, egal was, release/debug-build. Hast du vielleicht den Haken bei "Debug-executable"?
- Wo finde ich diese option?
- Wäre unter dem Menüpunkt: Produkt - >Schema>Bearbeiten von Schema - >Ausführen - >Info, aber ich bin zu Fragen, wie es hört nicht auf den Haltepunkt für Sie, weil es Stoppt jedes mal bei mir
- Lassen Sie uns weiter, diese Diskussion im chat.
- Das problem ist, dass es nicht nicht am Haltepunkt beendet, auch wenn Sie String, StaticString ist hier nicht unbedingt erforderlich
- Ich denke ich hab es jetzt, schauen Sie sich meine Bearbeiten
InformationsquelleAutor Kametrixom

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.