Array (Array) in Swift

在本教程中，您将学习数组，创建数组，访问数组的值以及数组中的一些常见操作。

在上一篇文章中，我们学习了如何创建可以保存单个值的某些数据类型变量/常量。Tipi di Dati in Swift文章中，我们学习了如何创建可以保存单个值的某些数据类型变量/常量。

但是，如果我们要存储相同数据类型的多个值怎么办。我们在Swift中使用称为 数组 的东西。

什么是数组？

数组只是一个容器，可以在一个有序列表中保存一个数据类型的多个数据（值），即，您以与定义数组中各项相同的顺序来获取元素。

数组可以存储任何类型的数据例如 Int，String，Class 等值。

如何在Swift中声明数组？

您可以通过在方括号内 [] 指定数据类型来创建一个空数组。

请记住，您必须在方括号内包括类型，否则Swift会将其视为普通数据类型，并且您只能在其中存储一个值。

示例1：声明一个空数组

let emptyIntArr: [Int] = []
print(emptyIntArr)

Quando si esegue il programma, l'output è:

[　]

在上面的程序中，我们声明了一个常量 emptyIntArr，该常量可以存储整数数组并使用0值初始化。

oppure

还可以如下定义一个空数组：

let emptyIntArr: Array<Int> = Array()
print(emptyIntArr)

oppure

Poiché Swift è un linguaggio di inferenza del tipo, puoi anche creare array senza specificare il tipo, ma devi inizializzare con alcuni valori in modo che il compilatore possa inferire il tipo:

Esempio 2: Dichiarare un array con determinati valori

let　someIntArr　=　[1,　2,　3,　4,　5,　6,　7,　8,　9]
print(someIntArr)

Quando si esegue il programma, l'output è:

[1,　2,　3,　4,　5,　6,　7,　8,　9]

Nel programma sopra, abbiamo dichiarato una costante someIntArr che può memorizzare un array di Integer senza specificare esplicitamente il tipo. Inoltre, usiamoValori 1, 2, 3, 4, 5, 6, 7, 8, 9 Inizializzato l'array.

Esempio 3: Dichiarare un array contenente un singolo valore ripetuto un numero specificato di volte

Puoi anche ripetere un valore una determinata numero di volte per formare un array in Swift. Questo viene fatto utilizzando l'inizializzatore dell'array insieme a repeating e count.

let　arrWithRepeatingValues　=　Array(repeating:　"Hello,　World",　count:　4)
print(arrWithRepeatingValues)

Quando si esegue il programma, l'output è:

["Hello,　World",　"Hello,　World",　"Hello,　World",　"Hello,　World"]

Nel programma sopra, abbiamo definito una costante arrWithRepeatingValues che memorizza la stringa Hello, World di array,e ripeti lo stesso valore 4 volte, come specificato in count nell'esempio.

Attenzione:In Swift, non puoi creare array di lunghezza fissa come in altri linguaggi di programmazione. Un array di lunghezza fissa significa che l'array non può contenere più elementi rispetto a quelli definiti durante l'inizializzazione.

Come vengono memorizzati i valori nell'array?

Supponiamo che tu abbia una costante che può memorizzare un array di stringhe, come segue:

let intArr = [21, 34, 54, 12]

La rappresentazione grafica di come i valori vengono memorizzati nell'array è come segue:

Tutti gli array che crei iniziano dall'indice 0. Il primo elemento è memorizzato all'indice 0, il secondo elemento è memorizzato nell'indice successivo (1) e così via.

Come accedere agli elementi di un array in Swift?

Puoi usare SottoPer accedere agli elementi dell'array, utilizzare la sintassi di accesso, ovvero includere l'indice del valore da accedere all'interno dei parentesi quadre dopo il nome dell'array.

Supponiamo che tu abbia dichiarato un array intArr come descritto sopra. Il primo elemento è intArr[0], il secondo elemento è intArr[1] e così via.

Esempio 4: come accedere agli elementi dell'array

let intArr = [21, 34, 54, 12]
print(intArr[0])
print(intArr[1])
print(intArr[2])
print(intArr[3])

Quando si esegue il programma, l'output è:

21
34
54
12

Puoi anche accedere agli elementi dell'array utilizzando un ciclo for-in. Per ulteriori informazioni, consultaCiclo for-in in Swift.

Come modificare/aggiungere elementi in un array in Swift?

Puoi modificare gli elementi dell'array utilizzando la sintassi di indici e l'operatore di assegnazione, ovvero devi includere il numero di indice del valore che desideri aggiornare dopo il nome dell'array, seguiti dall'operatore di assegnazione e dal nuovo valore.

Esempio 5: modifica degli elementi dell'array

var intArr = [21, 34, 54, 12]
intArr[0] = 12
intArr[1] = 42
intArr[2] = 45
intArr[3] = 21
print(intArr)

Quando si esegue il programma, l'output è:

[12, 42, 45, 21]

Puoi anche modificare tutti gli elementi dell'array con i nuovi valori seguenti, come illustrato di seguito:

Esempio 6: modifica completa dell'array

var intArr = [21, 34, 54, 12]
intArr = [1, 2, 3]
print(intArr)

Quando si esegue il programma, l'output è:

[1, 2, 3]

Ma per aggiungere un nuovo elemento a un array esistente, non puoi utilizzare la sintassi di indici. Se lo fai, ciò causerebbe un errore. Non puoi eseguire l'operazione seguente:

Esempio 7: aggiungere un nuovo elemento all'array utilizzando la sintassi di indici (non valido)

var intArr = [21, 34, 54, 12]
intArr[4] = 10

Quando si esegue il programma, l'output è:

errore fatale: Indice fuori gamma

Il programma sopra ha dato un errore quando ha assegnato un nuovo valore all'array intArr. Questo è perché intArr non ha assegnato ulteriore memoria per l'indice 4 e non può memorizzare il valore assegnato.

Per inserire correttamente un nuovo elemento nell'array, utilizziamo il metodo append() dell'array. Ne parleremo più avanti dell'uso di append().

Funzioni e attributi integrati degli array

1. Proprietà isEmpty

Questa proprietà determina se l'array è vuoto. Se un array non contiene alcun valore, restituisce true, altrimenti restituisce false.

Esempio 8: come funziona isEmpty?

let intArr = [21, 34, 54, 12]
print(intArr.isEmpty)

Quando si esegue il programma, l'output è:

false

2. Proprietà first

Questa proprietà serve per accedere al primo elemento dell'array.

Esempio 9: come funziona first?

let intArr = [21, 34, 54, 12]
print(intArr.first)

Quando si esegue il programma, l'output è:

Optional(21)

Allo stesso modo, puoi accedere all'ultimo elemento dell'array utilizzando l'attributo last.

3. Funzione append (aggiungere)

La funzione append aggiunge/aggiunge elementi alla fine dell'array.

Esempio 10: come funziona append?

var intArr = [21, 34, 54, 12]
intArr.append(32)
print(intArr)

Quando si esegue il programma, l'output è:

[21, 34, 54, 12, 32]

Puoi anche aggiungere il contenuto di un array a un altro array, come illustrato di seguito:

var firstArr = [1, 2, 3, 4]
var secondArr = [5, 6, 7, 8]
firstArr.append(contentsOf: secondArr)
print(firstArr)

Quando si esegue il programma, l'output è:

[1, 2, 3, 4, 5, 6, 7, 8]

4. Funzione insert() (inserimento)

Questa funzione viene utilizzata per inserire/aggiungere elementi all'indice specifico dell'array.

Esempio 11: come funziona insert()?

var intArr = [21, 34, 54, 12]
intArr.insert(22, at: 1)
print(intArr)

Quando si esegue il programma, l'output è:

[21, 22, 34, 54, 12]

Allo stesso modo, è possibile utilizzare remove(at:) per eliminare l'elemento specificato all'indice specificato.

5. Funzione remove() (rimozione)

Questa funzione elimina e restituisce il valore specificato nella posizione specificata dell'array.

Esempio 12: come funziona remove()?

var strArr = ["ab", "bc", "cd", "de"]
let removedVal = strArr.remove(at: 1)
print("Il valore rimosso è \(removedVal)")
print(strArr)

Quando si esegue il programma, l'output è:

Il valore rimosso è bc
["ab", "cd", "de"]

Allo stesso modo, è possibile utilizzare removeFirst per eliminare l'elemento primo dell'array, removeLast per eliminare l'ultimo elemento dell'array e removeAll per svuotare l'array.

6. Funzione reversed() (inverso)

Questa funzione restituisce gli elementi dell'array in ordine inverso.

Esempio 13: come funziona reversed()?

var intArr = [21, 22, 23, 24]
let reversedArr = Array(intArr.reversed())
print(reversedArr)

Quando si esegue il programma, l'output è:

[24, 23, 22, 21]

7. Proprietà count (conteggio)

Questa proprietà restituisce il numero totale di elementi dell'array.

Esempio 14: conteggio

let floatArr = [10.2, 21.3, 32.0, 41.3]
print(floatArr.count)

Quando si esegue il programma, l'output è:

4

Attenzione

Quando si utilizza la sintassi degli indici per accedere agli elementi dell'array in Swift, è necessario assicurarsi che il valore si trovi all'interno dell'indice, altrimenti ciò causerebbe un crash in fase di esecuzione. Vediamo un esempio:

let intArr = [21, 34, 54, 12]
print(intArr[-1])

Quando si esegue il programma, l'output è:

errore fatale: Indice fuori gamma

Nel programma sopra, l'indice in -1Nessun valore. Pertanto, quando si tenta di accedere al valore dell'indice, si verifica un crash in tempo di esecuzione.

Per prevenire questo problema, prima trovare l'indice dell'elemento da eliminare. Poi elimina l'elemento all'indice, come mostrato di seguito:

var intArr = [21, 34, 54, 12]
if let index = intArr.index(of: 34) {
　　　　print("trovato index")
　　　　let val = intArr.remove(at: index)
　　　　print(val)
}

Quando si esegue il programma, l'output è:

trovato index
34