Swift - indices

L'accès aux éléments membres d'une collection, d'une séquence et d'une liste dans Classes, Structures et Enumerations se fait à l'aide d'indices. Ces indices sont utilisés pour stocker et récupérer les valeurs à l'aide d'index. Les éléments de tableau sont accessibles à l'aide de someArray [index] et ses éléments membres suivants dans une instance de Dictionary sont accessibles en tant que someDicitonary [key].

Pour un seul type, les indices peuvent aller d'une déclaration à plusieurs déclarations. Nous pouvons utiliser l'indice approprié pour surcharger le type de valeur d'index passé à l'indice. Les indices vont également d'une dimension unique à plusieurs dimensions selon les exigences des utilisateurs pour leurs déclarations de type de données d'entrée.

Syntaxe de la déclaration d'indice et son utilisation

Récapitulons les propriétés calculées. Les indices suivent également la même syntaxe que celle des propriétés calculées. Pour les instances de type de requête, les indices sont écrits entre crochets suivis du nom de l'instance. La syntaxe de l'indice suit la même structure syntaxique que celle de la syntaxe «méthode d'instance» et «propriété calculée». Le mot-clé 'indice' est utilisé pour définir les indices et l'utilisateur peut spécifier un ou plusieurs paramètres avec leurs types de retour. Les indices peuvent avoir des propriétés en lecture-écriture ou en lecture seule et les instances sont stockées et récupérées à l'aide des propriétés «getter» et «setter» comme celles des propriétés calculées.

Syntaxe

subscript(index: Int) −> Int {
   get {
      // used for subscript value declarations
   }
   set(newValue) {
      // definitions are written here
   }
}

Exemple 1

struct subexample {
   let decrementer: Int
   subscript(index: Int) -> Int {
      return decrementer / index
   }
}
let division = subexample(decrementer: 100)

print("The number is divisible by \(division[9]) times")
print("The number is divisible by \(division[2]) times")
print("The number is divisible by \(division[3]) times")
print("The number is divisible by \(division[5]) times")
print("The number is divisible by \(division[7]) times")

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

The number is divisible by 11 times
The number is divisible by 50 times
The number is divisible by 33 times
The number is divisible by 20 times
The number is divisible by 14 times

Exemple2

class daysofaweek {
   private var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
      "Thursday", "Friday", "saturday"]
   subscript(index: Int) -> String {
      get {
         return days[index]
      }
      set(newValue) {
         self.days[index] = newValue
      }
   }
}
var p = daysofaweek()

print(p[0])
print(p[1])
print(p[2])
print(p[3])

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Sunday
Monday
Tuesday
Wednesday

Options en indice

Les indices prennent un à plusieurs paramètres d'entrée et ces paramètres d'entrée appartiennent également à n'importe quel type de données. Ils peuvent également utiliser des paramètres variables et variadiques. Les indices ne peuvent pas fournir de valeurs de paramètre par défaut ni utiliser de paramètres d'entrée-sortie.

La définition de plusieurs indices est appelée «surcharge d'indice» où une classe ou une structure peut fournir plusieurs définitions d'indice selon les besoins. Ces indices multiples sont déduits en fonction des types de valeurs déclarées entre les accolades en indice.

struct Matrix {
   let rows: Int, columns: Int
   var print: [Double]
   init(rows: Int, columns: Int) {
      self.rows = rows
      self.columns = columns
      print = Array(count: rows * columns, repeatedValue: 0.0)
   }
   subscript(row: Int, column: Int) -> Double {
      get {
         return print[(row * columns) + column]
      }
      set {
         print[(row * columns) + column] = newValue
      }
   }
}
var mat = Matrix(rows: 3, columns: 3)

mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0

print("\(mat[0,0])")

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

1.0

L'indice Swift 4 prend en charge un paramètre unique pour plusieurs déclarations de paramètres pour les types de données appropriés. Le programme déclare la structure 'Matrix' comme une matrice matricielle 2 * 2 dimensionnelle pour stocker les types de données 'Double'. Le paramètre Matrix est entré avec des types de données Integer pour déclarer des lignes et des colonnes.

Une nouvelle instance pour la matrice est créée en passant le nombre de lignes et de colonnes à l'initialisation comme indiqué ci-dessous.

var mat = Matrix(rows: 3, columns: 3)

Les valeurs de matrice peuvent être définies en passant les valeurs de ligne et de colonne dans l'indice, séparées par une virgule, comme indiqué ci-dessous.

mat[0,0] = 1.0  
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0