Opérations de tableau rapide - Créer, accéder et modifier
Python (tout comme Java) et d'autres langues Swift Support des types de données, les opérateurs, les déclarations de boucle, les déclarations conditionnelles, les collections, et il peut être possible d'implémenter la programmation orientée objet.
Dans ce guide rapide, nous verrons ce qu'est une collection de tableaux à Swift et comment créer, accéder et modifier des éléments dans une collection de table.
Avant d'aller à la création du tableau, nous verrons ce qu'est un tableau et comment le déclarer et l'initialiser.
Tableau rapide
Array in Swift est une collection qui stocke plusieurs éléments avec le même type de données.
Dans Swift, nous devons spécifier le type de données pour représenter le type de données du tableau tout en créant un tableau.
Il y a deux façons de déclarer un tableau dans Swift.
Déclaration de tableau
La première façon que nous pouvons déclarer un tableau est d'utiliser des crochets - [].
Ici, nous utiliserons le laisser mot-clé pour définir un tableau. Ensuite, nous spécifierons le nom du tableau qui représente le nom d'un tableau suivi d'un type de données.
Syntaxe:
Soit Swift_Array: [DataType] = []
Soit swift_array: [int] = []
Ici, vous pouvez voir que nous avons déclaré un tableau vide nommé - Swift_Array avec type de données - Int.
INT représente l'entier qui stocke uniquement les valeurs de type entier.
La deuxième façon de déclarer un tableau consiste à utiliser le Déployer() fonction.
Ici, nous utiliserons le laisser mot-clé pour définir un tableau. Ensuite, nous spécifierons le nom du tableau qui représente le nom d'un tableau suivi d'un type de données.
Syntaxe:
Laissez Swift_Array: Array= Array ()
Donc, ce sont les deux façons possibles de déclarer un tableau à Swift.
Exemple:
Ici, nous créons deux tableaux rapides vides nommés - swift_array1 et swift_array2 et les affichant.
// Créer Swift_Array
Soit swift_array1: [int] = []
// Afficher Swift_Array
imprimer (swift_array1)
// Créer Swift_Array
Laissez Swift_Array2: Array= Array ()
// Afficher Swift_Array
imprimer (swift_array2)
Sortir:
Comme les tableaux sont vides, les tableaux vides sont retournés.
Création de tableau
Maintenant, nous verrons comment créer un tableau à Swift avec certains éléments de type entier.
Nous pouvons spécifier directement des éléments dans un tableau rapide sans spécifier le type de données également.
Syntaxe:
Soit Swift_Array: [DataType] = [élément1, élément2,…]
(OU)
Soit Swift_Array = [Element1, Element2,…]
Où swift_array est le nom du tableau.
Exemple:
Créons deux tableaux rapides avec cinq valeurs entières et affichons-les.
// Créer Swift_Array avec des valeurs
Soit Swift_Array1: [int] = [10,20,30,40,50]
// Afficher Swift_Array
imprimer (swift_array1)
// Créer Swift_Array avec des valeurs sans spécifier le type de données
Soit Swift_Array2 = [10,20,30,40,50]
// Afficher Swift_Array
imprimer (swift_array2)
Sortir:
Donc, nous avons créé des tableaux de deux manières. swift_array1 est créé en spécifiant le type de données - int et swift_array2 est créé sans spécifier le type de données.
Accéder aux éléments à partir de Swift Array
Si nous voulons afficher l'intégralité du tableau Swift, nous utilisons la déclaration print (). Maintenant, si vous souhaitez obtenir seulement un élément particulier du tableau, les positions d'index sont utilisées.
L'index commence par 0. En utilisant l'index, il est possible d'accéder aux éléments à partir du tableau rapide.
Syntaxe:
swift_array [index]
Où Swift__Array est un tableau rapide d'entrée Swift et l'index représente une valeur entière qui spécifie la position d'index.
Exemple 1:
Maintenant, nous allons créer un tableau entier nommé - swift_array1 avec 10 éléments et accéder aux éléments.
// Créer Swift_Array avec des valeurs
Soit Swift_Array1: [int] = [10,20,30,40,50,1,2,3,4,5]
// Afficher Swift_Array
print ("Tableau rapide réel: \ (swift_array1)")
// Accédez au 4ème élément
print ("élément présent à index - 3 est \ (swift_array1 [3]).")
// accéder au 8ème élément
print ("élément présent à l'index - 7 est \ (swift_array1 [7]).")
// Accédez au 1er élément
print ("élément présent à l'index - 0 est \ (swift_array1 [0]).")
Sortir:
Ainsi, des éléments concernant les positions d'index ont été retournés.
Exemple 2:
Maintenant, nous allons créer un tableau de chaînes nommé - swift_array1 avec 4 éléments et accéder aux éléments.
// Créer Swift_Array avec des chaînes
Soit swift_array1: [string] = ["swift1", "swift2", "swift3", "swift4"]
// Afficher Swift_Array
print ("Tableau rapide réel: \ (swift_array1)")
// Accédez au 1er élément
print ("élément présent à l'index - 0 est \ (swift_array1 [0]).")
// Accédez au 3ème élément
print ("élément présent à l'index - 2 est \ (swift_array1 [2]).")
Sortir:
Ainsi, les éléments de chaîne par rapport aux positions d'index ont été retournés.
Modification des éléments dans un tableau rapide
Il est possible de modifier les éléments particuliers du tableau rapide ou du tableau rapide entièrement en utilisant des positions d'index.
L'index commence par 0. À une position d'index particulière, nous attribuerons le nouvel élément.
Si vous souhaitez modifier l'intégralité du tableau, vous pouvez passer les nouveaux éléments dans le nouveau tableau et aucun besoin d'index n'est fourni.
Syntaxe:
Pour un élément particulier - swift_array [index] = new_element
Pour l'ensemble du tableau - swift_array = [new_element,…]
Où, Swift_Array est un tableau Swift d'entrée et New_element est l'élément qui remplace l'élément existant dans le tableau Swift.
Exemple 1:
Nous avons créé quatre chaînes et mis à jour certaines chaînes en utilisant la position d'index.
// Créer Swift_Array avec des chaînes
var swift_array1: [string] = ["swift1", "swift2", "swift3", "swift4"]
// Afficher Swift_Array
print ("Tableau rapide réel: \ (swift_array1)")
// Mette à jour le 1er élément de 'SW-1'
swift_array1 [0] = "SW-1"
// Mette à jour le 3ème élément vers 'SW-3'
swift_array1 [2] = "SW-3"
// Afficher Swift_Array
print ("Array Swift mis à jour: \ (swift_array1)")
Sortir:
Ainsi, SW-1 remplace Swift1 et SW-3 remplace SWIFT3.
Exemple 2:
Nous avons créé cinq entiers et mis à jour certaines valeurs en utilisant la position d'index.
// Créer Swift_Array avec des entiers
var swift_array1: [int] = [34,56,53,23,56]
// Afficher Swift_Array
print ("Tableau rapide réel: \ (swift_array1)")
// Mette à jour le 1er élément à 1
swift_array1 [0] = 1
// Mette à jour le 3ème élément à 3
swift_array1 [2] = 3
// Mette à jour le 5ème élément à 5
swift_array1 [4] = 5
// Afficher Swift_Array
print ("Array Swift mis à jour: \ (swift_array1)")
Sortir:
Ainsi, 1 remplace 34, 3 remplace 53 et 5 remplace 56.
Exemple 3:
Maintenant, nous allons essayer de mettre à jour l'intégralité du tableau.
Ici, nous avons créé deux tableaux qui contiennent des chaînes et des entiers et mis à jour tous les éléments dans les deux tableaux rapides.
// Créer Swift_Array avec des entiers
var swift_array1: [int] = [34,56,53,23,56]
// Créer Swift_Array avec des chaînes
var swift_array2: [string] = ["swift1", "swift2"]
// Afficher Swift_Array
Print ("réel Array entier Swift: \ (Swift_Array1)")
// Mette à jour l'ensemble du tableau
swift_array1 = [100,200,300,400,500]
// Afficher Swift_Array
print ("Array Swift mis à jour: \ (swift_array1)")
// Afficher Swift_Array
print ("Array de chaîne Swift réel: \ (swift_array2)")
// Mette à jour l'ensemble du tableau
swift_array2 = ["Hello", "LinuxHint"]
// Afficher Swift_Array
print ("Array Swift mis à jour: \ (swift_array2)")
Sortir:
Les valeurs dans le tableau entier (SWIFT_ARRAY1) sont mises à jour à 100 200 300 400 et 500. Les valeurs du tableau des chaînes (SWIFT_ARRAY2) sont mises à jour vers «Hello», «Linuxhint».
Conclusion
Dans ce guide de tableau rapide, nous avons vu comment créer un tableau dans Swift. Nous pouvons le faire en utilisant la fonction Array () ou en utilisant []. Ensuite, nous avons exploré comment accéder aux éléments à partir d'un tableau via des positions d'index et il est possible de modifier les éléments en utilisant également les positions d'index. Nous avons discuté de différents exemples pour accéder et modifier des éléments particuliers ou tous les éléments du tableau.