Matrice dalle chiavi del dizionario in rapido

Prova di riempire rapidamente un array con stringhe delle chiavi di un dizionario.

var componentArray: [String]

let dict = NSDictionary(contentsOfFile: NSBundle.mainBundle().pathForResource("Components", ofType: "plist")!)
componentArray = dict.allKeys

Ciò restituisce un errore di: 'AnyObject' non identico alla stringa

Anche provato

componentArray = dict.allKeys as String 

ma get: 'String' non è convertibile in [String]

Swift 3 e Swift 4

componentArray = Array(dict.keys) // for Dictionary

componentArray = dict.allKeys // for NSDictionary

Con Swift 3, Dictionaryha una keysproprietà. keysha la seguente dichiarazione:

var keys: LazyMapCollection<Dictionary<Key, Value>, Key> { get }

Una raccolta contenente solo le chiavi del dizionario.

Si noti che LazyMapCollectionche può facilmente essere mappati a un Arraycon Array's init(_:)inizializzatore.

Da NSDictionarya[String]

Il seguente AppDelegateframmento di classe iOS mostra come ottenere una matrice di stringhe ( [String]) usando la keysproprietà di un NSDictionary:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    let string = Bundle.main.path(forResource: "Components", ofType: "plist")!
    if let dict = NSDictionary(contentsOfFile: string) as? [String : Int] {
        let lazyMapCollection = dict.keys
        
        let componentArray = Array(lazyMapCollection)
        print(componentArray)
        // prints: ["Car", "Boat"]
    }
    
    return true
}

Da [String: Int]a[String]

In un modo più generale, il seguente codice Playground mostra come ottenere una matrice di stringhe ( [String]) usando la keysproprietà di un dizionario con chiavi stringa e valori interi ( [String: Int]):

let dictionary = ["Gabrielle": 49, "Bree": 32, "Susan": 12, "Lynette": 7]
let lazyMapCollection = dictionary.keys

let stringArray = Array(lazyMapCollection)
print(stringArray)
// prints: ["Bree", "Susan", "Lynette", "Gabrielle"]

Da [Int: String]a[String]

Il seguente codice Playground mostra come ottenere una matrice di stringhe ( [String]) usando la keysproprietà di un dizionario con chiavi intere e valori stringa ( [Int: String]):

let dictionary = [49: "Gabrielle", 32: "Bree", 12: "Susan", 7: "Lynette"]
let lazyMapCollection = dictionary.keys
    
let stringArray = Array(lazyMapCollection.map { String($0) })
// let stringArray = Array(lazyMapCollection).map { String($0) } // also works
print(stringArray)
// prints: ["32", "12", "7", "49"]

Matrice dalle chiavi del dizionario in Swift

componentArray = [String] (dict.keys)

dict.allKeysnon è una stringa. È [String]esattamente come ti dice il messaggio di errore (supponendo, ovviamente, che le chiavi siano tutte stringhe; questo è esattamente ciò che stai affermando quando lo dici).

Quindi, o inizia digitando componentArrayas [AnyObject], perché è così che è stato digitato nell'API Cocoa, oppure, se lo fai dict.allKeys, esegui il cast [String], perché è così che hai digitato componentArray.

extension Array {
    public func toDictionary<Key: Hashable>(with selectKey: (Element) -> Key) -> [Key:Element] {
        var dict = [Key:Element]()
        for element in self {
            dict[selectKey(element)] = element
        }
        return dict
    }
}

NSDictionary è Class (passa per riferimento) Dictionary is Structure (passa per valore ) ====== Matrice da NSDictionary ======

NSDictionary ha allKeys e allValues ottengono proprietà con tipo [Any] .

  let objesctNSDictionary = 
    NSDictionary.init(dictionary: ["BR": "Brazil", "GH": "Ghana", "JP": "Japan"])
            let objectArrayOfAllKeys:Array = objesctNSDictionary.allKeys
            let objectArrayOfAllValues:Array = objesctNSDictionary.allValues
            print(objectArrayOfAllKeys)
            print(objectArrayOfAllValues)

====== Matrice dal dizionario ======

Riferimento Apple per le proprietà di chiavi e valori del dizionario .

let objectDictionary:Dictionary = 
            ["BR": "Brazil", "GH": "Ghana", "JP": "Japan"]
    let objectArrayOfAllKeys:Array = Array(objectDictionary.keys)          
    let objectArrayOfAllValues:Array = Array(objectDictionary.values)
    print(objectArrayOfAllKeys)
    print(objectArrayOfAllValues)

dict.keys.sorted() 

che fornisce [String] https://developer.apple.com/documentation/swift/array/2945003-sorted

Dalla documentazione ufficiale di Apple sull'array :

init(_:) - Crea un array contenente gli elementi di una sequenza.

Dichiarazione

Array.init<S>(_ s: S) where Element == S.Element, S : Sequence

parametri

s - La sequenza di elementi da trasformare in un array.

Discussione

È possibile utilizzare questo inizializzatore per creare un array da qualsiasi altro tipo conforme al protocollo Sequence ... È inoltre possibile utilizzare questo inizializzatore per convertire una sequenza complessa o un tipo di raccolta in un array. Ad esempio, la proprietà keys di un dizionario non è un array con una propria memoria, è una raccolta che mappa i suoi elementi dal dizionario solo quando vi si accede, risparmiando il tempo e lo spazio necessari per allocare un array. Se è necessario passare quelle chiavi a un metodo che accetta un array, utilizzare questo inizializzatore per convertire tale elenco dal suo tipo di LazyMapCollection<Dictionary<String, Int>, Int> to a simple [String].

func cacheImagesWithNames(names: [String]) {
    // custom image loading and caching
 }

let namedHues: [String: Int] = ["Vermillion": 18, "Magenta": 302,
        "Gold": 50, "Cerise": 320]
let colorNames = Array(namedHues.keys)
cacheImagesWithNames(colorNames)

print(colorNames)
// Prints "["Gold", "Cerise", "Magenta", "Vermillion"]"

Puoi usare dizionario.map in questo modo:

let myKeys: [String] = myDictionary.map{String($0.key) }

La spiegazione: la mappa scorre attraverso myDictionary e accetta ogni coppia chiave e valore come $ 0. Da qui puoi ottenere $ 0.key o $ 0.value. All'interno della chiusura finale {}, puoi trasformare ogni elemento e restituirlo. Dal momento che vuoi $ 0 e lo vuoi come stringa, allora converti usando String (tasto $ 0.). Raccogli gli elementi trasformati in una matrice di stringhe.

Questa risposta sarà per il dizionario rapido con i tasti String. Come questo qui sotto .

let dict: [String: Int] = ["hey": 1, "yo": 2, "sup": 3, "hello": 4, "whassup": 5]

Ecco l'estensione che userò.

extension Dictionary {
  func allKeys() -> [String] {
    guard self.keys.first is String else {
      debugPrint("This function will not return other hashable types. (Only strings)")
      return []
    }
    return self.flatMap { (anEntry) -> String? in
                          guard let temp = anEntry.key as? String else { return nil }
                          return temp }
  }
}

E riceverò tutte le chiavi in ​​seguito usando questo.

let componentsArray = dict.allKeys()

Swift 5

var dict = ["key1":"Value1", "key2":"Value2"]

let k = dict.keys

var a: [String]()
a.append(contentsOf: k)

Questo funziona per me.

// Old version (for history)
let keys = dictionary.keys.map { $0 }
let keys = dictionary?.keys.map { $0 } ?? [T]()

// New more explained version for our ducks
extension Dictionary {

    var allKeys: [Dictionary.Key] {
        return self.keys.map { $0 }
    }
}