Comment convertir une Chaîne de caractères (numérique) dans un tableau Int en Swift

Je voudrais savoir comment puis-je convertir une Chaîne en un tableau Int en Swift.
En Java, j'ai toujours fait comme ceci:

String myString = "123456789";
int[] myArray = new int[myString.lenght()];
for(int i=0;i<myArray.lenght;i++){
   myArray[i] = Integer.parseInt(myString.charAt(i));
}

Merci à tous pour aider!

Je suis en retrait de la java tag, puisque cette question n'est pas vraiment à propos de Java.

OriginalL'auteur t0re199 | 2015-02-19

let str = "123456789"
let intArray = map(str) { String($0).toInt() ?? 0 }

map() itère Characters dans str
String($0) convertit Character à String
.toInt() convertit String à Int. En cas d'échec(??), l'utilisation 0.

Si vous préférez for boucle, essayez:

let str = "123456789"
var intArray: [Int] = []

for chr in str {
    intArray.append(String(chr).toInt() ?? 0)
}

OU, si vous souhaitez effectuer une itération sur les indices de la String:

let str = "123456789"
var intArray: [Int] = []

for i in indices(str) {
    intArray.append(String(str[i]).toInt() ?? 0)
}

Merci de m'aider!
toInt() n'est plus disponible dans String dans Swift 2.x.

OriginalL'auteur rintaro

9

Vous pouvez utiliser flatMap pour convertir les caractères en une chaîne de caractères et de contraindre les chaînes de caractères en un entier:

Swift 2 ou 3
```
let string = "123456789"
let digits = string.characters.flatMap{Int(String($0))}
print(digits)   // [1, 2, 3, 4, 5, 6, 7, 8, 9]"
```
Swift 4
```
let string = "123456789"
let digits = string.flatMap{Int(String($0))}
print(digits)   // [1, 2, 3, 4, 5, 6, 7, 8, 9]"
```
Swift 4.1
```
let digits = string.compactMap{Int(String($0))}
```
Swift 4.1 dénonçait .flatMap pour ce cas d'utilisation. Utilisation .compactMap à la place: let digits = string.compactMap{Int(String($0))}

OriginalL'auteur Leo Dabus
1

@rintaro réponse est bonne, mais je voulais juste ajouter que vous pouvez utiliser reduce d'éliminer les éventuels caractères qui ne peuvent pas être convertis à un Int, et même afficher un message d'avertissement si cela se passe:
```
let str = "123456789"
let intArray = reduce(str, [Int]()) { (var array: [Int], char: Character) -> [Int] in
    if let i = String(char).toInt() {
        array.append(i)
    } else {
        println("Warning: could not convert character \(char) to an integer")
    }
    return array
}
```
Les avantages sont:
- si intArray contient des zéros, vous savez qu'il y a un 0 dans str, et pas un autre caractère qui s'est transformé en un zéro
- vous obtiendrez dit que si il y a un non-Int personnage qui est peut-être bousiller les choses.
OriginalL'auteur Aaron Rasmussen
0
```
var myString = "123456789"
var myArray:[Int] = []

for index in 0..<countElements(myString) {
    var myChar = myString[advance(myString.startIndex, index)]
    myArray.append(String(myChar).toInt()!)
}

println(myArray)   // [1, 2, 3, 4, 5, 6, 7, 8, 9]"
```
Pour obtenir le iterator pointant vers un char de la string vous pouvez utiliser advance

La méthode pour convertir string à int dans Swift est toInt()

Vous avez une boucle dans votre boucle d'appel advance plus et plus comme ça, c'est une mauvaise idée, puisque vous êtes sur le programme étape par le biais de la chaîne depuis le début à chaque fois.

OriginalL'auteur Jérôme Leducq
0

Swift 3 mise à jour:

@appzYourLife : C'est correct toInt() méthode est plus disponible à la Chaîne dans Swift 3.
Comme une alternative de ce que vous pouvez faire est de :
```
intArray.append(Int(String(chr)) ?? 0)
```
L'enfermer dans Int() convertit Int.

OriginalL'auteur iCode

Swift 3

Int tableau de Chaîne de

let arjun = [1,32,45,5]
    print(self.get_numbers(array: arjun))

 func get_numbers(array:[Int]) -> String {
        let stringArray = array.flatMap { String(describing: $0) }
        return stringArray.joined(separator: ",")

String en Int Tableau

let arjun = "1,32,45,5"
    print(self.get_numbers(stringtext: arjun))

    func get_numbers(stringtext:String) -> [Int] {
    let StringRecordedArr = stringtext.components(separatedBy: ",")
    return StringRecordedArr.map { Int($0)!}   
}

OriginalL'auteur Arjun Yadav

0

Swift 3: Approche Fonctionnelle
1. Diviser le String en séparer String instances à l'aide de:
  components(separatedBy separator: String) -> [String]
Référence: Retourne un tableau contenant les chaînes à partir de la Chaîne, qui ont été divisés par un séparateur.
1. Utiliser le flatMap Array méthode pour contourner le nil coalescence lors de la conversion Int
Référence: Retourne un tableau contenant le non-néant les résultats de l'appel à la transformation donnée à chaque élément de cette séquence.

Mise en œuvre
```
let string = "123456789"
let intArray = string.components(separatedBy: "").flatMap { Int($0) }
```
Swift 4.1 dénonçait .flatMap pour ce cas d'utilisation. Au lieu de cela, utiliser .compactMap: let intArray = string.components(separatedBy: "").compactMap { Int($0) }
c'est faux, il en résulterait un tableau à un seul élément de la même valeur de l'entrée [123456789]. La première méthode components(separatedBy: "") seraient le résultat d'un seul élément de chaîne ["123456789"]
J'ai simplement remplacé le obsolète .flatMap avec la nouvelle .compactMap, @LeoDabus. Les deux résultats sont les mêmes. Imprimé en tant que Xcode de la console de débogage: [123456789] et [123456789]. Notez que je ne suis pas à même de juger si le résultat est approprié pour la question d'origine, mais simplement de remarquer pour quelqu'un qui vient ici que .flatMap a été dépréciée en faveur de .compactMap dans les cas où l'on tente de parvenir à un résultat qui élimine nil valeurs.

OriginalL'auteur Fabijan Bajo

Vous devez vous connecter pour publier un commentaire.

Swift 3: Approche Fonctionnelle