Come convertire "Indice" per digitare "Int" in Swift?

Voglio convertire l'indice di una lettera contenuta in una stringa in un valore intero. Ho tentato di leggere i file di intestazione ma non riesco a trovare il tipo per Index, sebbene sembri conforme al protocollo ForwardIndexTypecon metodi (ad esempio distanceTo).

var letters = "abcdefg"
let index = letters.characters.indexOf("c")!

// ERROR: Cannot invoke initializer for type 'Int' with an argument list of type '(String.CharacterView.Index)'
let intValue = Int(index)  // I want the integer value of the index (e.g. 2)

Qualsiasi aiuto è apprezzato.

modifica / aggiorna:

Xcode 11 • Swift 5.1 o successivo

extension StringProtocol {
    func distance(of element: Element) -> Int? { firstIndex(of: element)?.distance(in: self) }
    func distance<S: StringProtocol>(of string: S) -> Int? { range(of: string)?.lowerBound.distance(in: self) }
}

extension Collection {
    func distance(to index: Index) -> Int { distance(from: startIndex, to: index) }
}

extension String.Index {
    func distance<S: StringProtocol>(in string: S) -> Int { string.distance(to: self) }
}

Test del parco giochi

let letters = "abcdefg"

let char: Character = "c"
if let distance = letters.distance(of: char) {
    print("character \(char) was found at position #\(distance)")   // "character c was found at position #2\n"
} else {
    print("character \(char) was not found")
}

let string = "cde"
if let distance = letters.distance(of: string) {
    print("string \(string) was found at position #\(distance)")   // "string cde was found at position #2\n"
} else {
    print("string \(string) was not found")
}

Swift 4

var str = "abcdefg"
let index = str.index(of: "c")?.encodedOffset // Result: 2

Nota: se la stringa contiene più caratteri, otterrà solo quello più vicino da sinistra

var str = "abcdefgc"
let index = str.index(of: "c")?.encodedOffset // Result: 2

encodedOffsetè stato deprecato da Swift 4.2 .

Messaggio di deprecazione : encodedOffsetè stato deprecato poiché l'utilizzo più comune non è corretto. Usalo utf16Offset(in:)per ottenere lo stesso comportamento.

Quindi possiamo usare in utf16Offset(in:)questo modo:

var str = "abcdefgc"
let index = str.index(of: "c")?.utf16Offset(in: str) // Result: 2

Per eseguire un'operazione sulle stringhe basata sull'indice, non è possibile farlo con l'approccio numerico dell'indice tradizionale. perché swift.index viene recuperato dalla funzione indici e non è nel tipo Int. Anche se String è un array di caratteri, non possiamo ancora leggere elemento per indice.

Questo è frustrante.

Quindi, per creare una nuova sottostringa di ogni carattere pari della stringa, controlla il codice sottostante.

let mystr = "abcdefghijklmnopqrstuvwxyz"
let mystrArray = Array(mystr)
let strLength = mystrArray.count
var resultStrArray : [Character] = []
var i = 0
while i < strLength {
    if i % 2 == 0 {
        resultStrArray.append(mystrArray[i])
      }
    i += 1
}
let resultString = String(resultStrArray)
print(resultString)

Uscita: acegikmoqsuwy

Grazie in anticipo

Ecco un'estensione che ti permetterà di accedere ai limiti di una sottostringa come Ints invece che come String.Indexvalori:

import Foundation

/// This extension is available at
/// https://gist.github.com/zackdotcomputer/9d83f4d48af7127cd0bea427b4d6d61b
extension StringProtocol {
    /// Access the range of the search string as integer indices
    /// in the rendered string.
    /// - NOTE: This is "unsafe" because it may not return what you expect if
    ///     your string contains single symbols formed from multiple scalars.
    /// - Returns: A `CountableRange<Int>` that will align with the Swift String.Index
    ///     from the result of the standard function range(of:).
    func countableRange<SearchType: StringProtocol>(
        of search: SearchType,
        options: String.CompareOptions = [],
        range: Range<String.Index>? = nil,
        locale: Locale? = nil
    ) -> CountableRange<Int>? {
        guard let trueRange = self.range(of: search, options: options, range: range, locale: locale) else {
            return nil
        }

        let intStart = self.distance(from: startIndex, to: trueRange.lowerBound)
        let intEnd = self.distance(from: trueRange.lowerBound, to: trueRange.upperBound) + intStart

        return Range(uncheckedBounds: (lower: intStart, upper: intEnd))
    }
}

Basta essere consapevoli che questo può portare a stranezze, motivo per cui Apple ha scelto di renderlo difficile. (Anche se è una decisione progettuale discutibile: nascondere una cosa pericolosa semplicemente rendendola difficile ...)

Puoi leggere di più nella documentazione String di Apple , ma il tldr è che deriva dal fatto che questi "indici" sono in realtà specifici dell'implementazione. Rappresentano gli indici nella stringa dopo che è stata renderizzata dal sistema operativo e quindi possono passare da sistema operativo a sistema operativo a seconda della versione della specifica Unicode utilizzata. Ciò significa che l'accesso ai valori in base all'indice non è più un'operazione a tempo costante, perché la specifica UTF deve essere eseguita sui dati per determinare il posto giusto nella stringa. Questi indici inoltre non si allineeranno con i valori generati da NSString, se si collega ad esso, o con gli indici negli scalari UTF sottostanti. Sviluppatore avvertimento.