Je commence à apprendre swiften suivant l'iBook- The Swift Programming Languageon Swift fourni par Apple. Le livre dit que pour créer un dictionnaire vide, il faut utiliser la [:]même chose que pour déclarer un tableau comme []:

J'ai déclaré un tableau vide comme suit:

let emptyArr = [] // or String[]()

Mais en déclarant un dictionnaire vide, j'obtiens une erreur de syntaxe:

let emptyDict = [:]

Comment déclarer un dictionnaire vide?

var emptyDictionary = [String: String]()

­

var populatedDictionary = ["key1": "value1", "key2": "value2"]

Remarque : si vous souhaitez modifier le contenu du dictionnaire au fil du temps, déclarez-le comme une var(variable). Vous pouvez déclarer un dictionnaire vide comme une let(constante), mais cela ne sert à rien si vous avez l'intention de modifier son contenu au fil du temps, car la constante ne peut pas être modifiée après son initialisation.

Ancienne réponse :

Créer un dictionnaire vide de type <String, String>ressemblerait à ceci:

var emptyDictionary = Dictionary<String, String>()

Vous ne pouvez pas utiliser tant [:]que les informations de type ne sont pas disponibles.

Vous devez le fournir explicitement dans ce cas:

var dict = Dictionary<String, String>()

varsignifie qu'il est modifiable, vous pouvez donc y ajouter des entrées. Inversement, si vous en faites un, letvous ne pouvez plus le modifier ( letsignifie constant).

Vous pouvez utiliser la [:]notation abrégée si les informations de type peuvent être déduites, par exemple

var dict = ["key": "value"]

// stuff

dict = [:] // ok, I'm done with it

Dans le dernier exemple, le dictionnaire est connu pour avoir un type Dictionary<String, String>à la première ligne. Notez que vous n'avez pas eu à le spécifier explicitement, mais il a été déduit.

La documentation Swift recommande la méthode suivante pour initialiser un dictionnaire vide:

var emptyDict = [String: String]()

J'étais un peu confus lorsque je suis tombé sur cette question pour la première fois, car différentes réponses montraient différentes façons d'initialiser un dictionnaire vide. Il s'avère qu'il existe en fait de nombreuses façons de le faire, bien que certaines soient un peu redondantes ou trop verbeuses étant donné la capacité de Swift à déduire le type.

var emptyDict = [String: String]()
var emptyDict = Dictionary<String, String>()
var emptyDict: [String: String] = [:]
var emptyDict: [String: String] = [String: String]()
var emptyDict: [String: String] = Dictionary<String, String>()
var emptyDict: Dictionary = [String: String]()
var emptyDict: Dictionary = Dictionary<String, String>()
var emptyDict: Dictionary<String, String> = [:]
var emptyDict: Dictionary<String, String> = [String: String]()
var emptyDict: Dictionary<String, String> = Dictionary<String, String>()

Une fois que vous avez un dictionnaire vide, vous pouvez ajouter une paire clé-valeur comme celle-ci:

emptyDict["some key"] = "some value"

Si vous souhaitez à nouveau vider votre dictionnaire, vous pouvez effectuer les opérations suivantes:

emptyDict = [:]

Les types sont toujours <String, String>parce que c'est ainsi qu'il a été initialisé.

Utilisez cela fonctionnera.

var emptyDict = [String: String]()

Vous pouvez simplement le déclarer comme ceci:

var emptyDict:NSMutableDictionary = [:]

Vous devez donner un type au dictionnaire

// empty dict with Ints as keys and Strings as values
var namesOfIntegers = Dictionary<Int, String>()

Si le compilateur peut déduire le type, vous pouvez utiliser la syntaxe plus courte

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type Int, String

Rapide:

var myDictionary = Dictionary<String, AnyObject>()

Je joue avec ça aussi. Il semble étrange que vous puissiez simplement déclarer un dictionnaire vide, puis y ajouter une paire clé / valeur comme ceci:

var emptyDictionary = Dictionary<String, Float>()
var flexDictionary = [:]
emptyDictionary["brian"] = 4.5
flexDictionary["key"] = "value" // ERROR : cannot assign to the result of this expression

Mais vous pouvez créer un dictionnaire qui accepte différents types de valeur en utilisant le type "Tout" comme ceci:

var emptyDictionary = Dictionary<String, Any>()
emptyDictionary["brian"] = 4.5
emptyDictionary["mike"] = "hello"

Vous devez indiquer explicitement le type de données ou le type peut être déduit lorsque vous déclarez quoi que ce soit dans Swift.

Swift 3

L'exemple ci-dessous déclare un dictionnaire avec la clé comme Inttype et la valeur comme Stringtype.

Méthode 1: initialiseur

let dic = Dictionary<Int, String>()

Méthode 2: syntaxe abrégée

let dic = [Int:String]()

Méthode 3: Dictionnaire littéral

var dic = [1: "Sample"]
// dic has NOT to be a constant
dic.removeAll()

Swift 4

let dicc = NSDictionary()

//MARK: - This is empty dictionary
let dic = ["":""]

//MARK:- This is variable dic means if you want to put variable 
let dic2 = ["":"", "":"", "":""]

//MARK:- Variable example
let dic3 = ["name":"Shakeel Ahmed", "imageurl":"https://abc?abc.abc/etc", "address":"Rawalpindi Pakistan"]

//MARK: - This is 2nd Variable Example dictionary
let dic4 = ["name": variablename, "city": variablecity, "zip": variablezip]

//MARK:- Dictionary String with Any Object
var dic5a = [String: String]()
//MARK:- Put values in dic
var dic5a = ["key1": "value", "key2":"value2", "key3":"value3"]

var dic5b = [String:AnyObject]()
dic5b = ["name": fullname, "imageurl": imgurl, "language": imgurl] as [String : AnyObject]

or
//MARK:- Dictionary String with Any Object
let dic5 = ["name": fullname, "imageurl": imgurl, "language": imgurl] as [String : AnyObject]

//MARK:- More Easy Way
let dic6a = NSDictionary()
let dic6b = NSMutalbeDictionary()

Si vous souhaitez créer un dictionnaire générique avec n'importe quel type

var dictionaryData = [AnyHashable:Any]()

J'utilise habituellement

var dictionary:[String:String] = [:]
dictionary.removeAll()

Déclaration et initialisation de dictionnaires dans Swift

Dictionnaire de la chaîne

var stringDict: [String: String] = [String: String]()

OU

var stringDict: Dictionary<String, String> = Dictionary<String, String>()

Dictionnaire d'Int

var stringDict: [String: Int] = [String: Int]()

OU

var stringDict: Dictionary<String, Int> = Dictionary<String, Int>()

Dictionnaire AnyObject

var stringDict: [String: AnyObject] = [String: AnyObject]()

OU

var stringDict: Dictionary<String, AnyObject> = Dictionary<String, AnyObject>()

Dictionnaire de Array of String

var stringDict: [String: [String]] = [String: [String]]()

OU

var stringDict: Dictionary<String, Array<String>> = Dictionary<String, Array<String>>()

Tableau de dictionnaires de chaîne

var stringDict: [[String: String]] = [[String: String]]()

OU

var stringDict: Array<Dictionary<String, String>> = Array<Dictionary<String, String>>()

Vous pouvez le déclarer nul avec les éléments suivants:

var assoc : [String:String]

Alors la bonne chose est que vous avez déjà composé (notez que j'ai utilisé var et not let, pensez à ceux-ci comme mutables et immuables). Ensuite, vous pouvez le remplir plus tard:

assoc = ["key1" : "things", "key2" : "stuff"]

Vous pouvez utiliser le code suivant:

var d1 = Dictionary<Int, Int>()
var d2 = [Int: Int]()
var d3: Dictionary<Int, Int> = [Int : Int]()
var d4: [Int : Int] = [:]

var dictList = String: Chaîne pour le dictionnaire en swift var arrSectionTitle = Chaîne pour le tableau en swift

C'est très pratique pour trouver votre chemin

var dict: Dictionnaire = [:]

var parking = [Dictionary < String, Double >()]

^ ceci ajoute un dictionnaire pour une entrée [string: double]