Swift - Indizes

Der Zugriff auf die Elementelemente einer Sammlung, Sequenz und Liste in Klassen, Strukturen und Aufzählungen erfolgt mit Hilfe von Indizes. Diese Indizes werden zum Speichern und Abrufen der Werte mithilfe des Index verwendet. Auf Array-Elemente wird mit Hilfe von someArray [Index] zugegriffen, und auf die nachfolgenden Elementelemente in einer Dictionary-Instanz kann als someDicitonary [Schlüssel] zugegriffen werden.

Für einen einzelnen Typ können Indizes von einzelnen bis zu mehreren Deklarationen reichen. Wir können den entsprechenden Index verwenden, um den Typ des an den Index übergebenen Indexwerts zu überladen. Die Indizes reichen auch von einer Dimension bis zu mehreren Dimensionen, je nach den Anforderungen des Benutzers für seine Eingabedatentypdeklarationen.

Syntax der tiefgestellten Deklaration und ihre Verwendung

Lassen Sie uns einen Rückblick auf die berechneten Eigenschaften geben. Auch Indizes folgen der gleichen Syntax wie berechnete Eigenschaften. Bei der Abfrage von Instanzen vom Typ werden Indizes in eine eckige Klammer gefolgt vom Instanznamen geschrieben. Die tiefgestellte Syntax folgt der gleichen Syntaxstruktur wie die Syntax 'Instanzmethode' und 'berechnete Eigenschaft'. Das Schlüsselwort 'subscript' wird zum Definieren von Indizes verwendet, und der Benutzer kann einzelne oder mehrere Parameter mit ihren Rückgabetypen angeben. Indizes können schreibgeschützte oder schreibgeschützte Eigenschaften haben, und die Instanzen werden mithilfe der Eigenschaften 'getter' und 'setter' wie die berechneten Eigenschaften gespeichert und abgerufen.

Syntax

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

Beispiel 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")

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

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

Beispiel2

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])

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

Sunday
Monday
Tuesday
Wednesday

Optionen im Index

Indizes verwenden einzelne bis mehrere Eingabeparameter, und diese Eingabeparameter gehören auch zu jedem Datentyp. Sie können auch variable und variable Parameter verwenden. Indizes können keine Standardparameterwerte bereitstellen oder In-Out-Parameter verwenden.

Das Definieren mehrerer Indizes wird als "Indexüberladung" bezeichnet, bei der eine Klasse oder Struktur nach Bedarf mehrere Indexdefinitionen bereitstellen kann. Diese mehreren Indizes werden basierend auf den Wertetypen abgeleitet, die in den Indexklammern deklariert sind.

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])")

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

1.0

Der Swift 4-Index unterstützt einzelne Parameter für mehrere Parameterdeklarationen für geeignete Datentypen. Das Programm deklariert die 'Matrix'-Struktur als 2 * 2-dimensionale Array-Matrix zum Speichern von' Double'-Datentypen. Der Matrix-Parameter wird mit Integer-Datentypen zum Deklarieren von Zeilen und Spalten eingegeben.

Eine neue Instanz für die Matrix wird erstellt, indem die Anzahl der Zeilen und Spalten wie unten gezeigt an die Initialisierung übergeben wird.

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

Matrixwerte können definiert werden, indem Zeilen- und Spaltenwerte in den Index übergeben werden, die wie unten gezeigt durch ein Komma getrennt sind.

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