Les lecteurs de Vikidia demandent des articles en plus. Voyez la liste d'articles à créer, et venez nous aider à les rédiger !
Utilisateur:Azg/Brouillon:Langage Swift
Swift est un langage de programmation puissant développé par Apple en 2014.
Ce langage est inspiré de l'Objective-C, un autre langage de programmation. Ce langage est de haut niveau : c'est à dire qu'il est proche du langage humain. Il est moyennement typé : Swift propose une sécurité de programmation avec le typage. Le Swift a été créé dans le but de développé des applications pour mobiles, avec une meilleur simplicité que l'Objective-C, mais les 2 langages sont combinables.
Ce langage est compilé par LLVM, c'est à dire que LLVM va transformer le Swift en binaire, des 0 et des 1 que le mobile comprend. LLVM est une machine virtuelle de bas niveau. Apple est aidé par la communauté Swift est d'autres personnes pour le développement du langage.
Informations sur le Swift[modifier | modifier le wikicode]
Swift est un langage de programmation développé par Chris Lattner, la première version a été conçue le 2 juin 2014, ce qui fait de Swift un langage récent. Le Swift a été conçu à partir de nombreux langages : Objective-C, C#, Ruby, D, Haskell, CLU, Rust, Scala, Python et Racket. La version actuelle du Swift est la version 5.0.
Fonctionnalités de Swift[modifier | modifier le wikicode]
Swift est un langage capable de développer des applications. Son utilisation commence a dominé celle de l'Objective-C, Swift devient le langage référence pour le développement d'applications mobiles. Swift est rapide lors de son exécution. Ce langage est hybride : à la fois procédural et objet, hors, la POO du Swift est plus puissante que la syntaxe procédurale. Swift fonctionne sur les plateformes iOS et OS x. Avec son union avec Objective-C, Swift devient encore plus puissant. L'ordinateur sait lire directement du binaire, donc Swift doit être compilé en binaire pour son exécution. C'est pourquoi les compilateurs, machines virtuelles etc on été inventé. Ici, le traducteur du Swift est une machine virtuelle de bas niveau : LLVM.
Une des fonctionnalités de Swift sont les Framework, démontrés ci-dessous. En effet, Swift est reconnu par ses fonctionnalités sur son code et en dehors du code.
Framework[modifier | modifier le wikicode]
Une des belles fonctionnalités de Swift sont les Framework. Ils permettent de gérer du code très facilement, seulement en l'important. Ces Framework sont utiles lorsque le code est long ou que l'on doit faire quelque chose non en programmation et que l'on peut y remédier. Avec ces fonctionnalités, on peut créer plus de choses. Ce sont comme des fonctions très complexes.
Xcode[modifier | modifier le wikicode]
Xcode est un logiciel adapté en environnement de développement pour mobile. Cet environnement permet de développer des applications. Il permet de faire exécuter du code, ce code doit appartenir au Swift, au Ruby ou à l'Objective-C. Seule la version x.10 inclus la version 5.0 du Swift.
Sur Xcode, on développe des programmes dans un Playground. Le logiciel peut être téléchargé gratuitement sur Mac App Store.
Codes en Swift[modifier | modifier le wikicode]
Ce paragraphe va décrire un peu Swift dans son codage, avec des exemples de base en Swift. Les instructions ne sont pas finies par un point virgule comme dans d'autres langages.
Les commentaires[modifier | modifier le wikicode]
Les commentaires sont des morceaux de code qui ne sera pas exécuter mais qui donnera plutôt des informations pour le développeur. Les commentaires sont extrêmement utile lorsque le code est complexe, sinon le développeur risque de ce perdre et devra tout recommencer, mais plutôt en vain.
Les commentaires peuvent s'étaler sur une seule ligne, on les appelle les commentaires mono-lignes, ou peuvent s'étaler sur plusieurs lignes, se sont des commentaires multilignes. Les commentaires mono-lignes commencent à partir de la déclaration de ces barres : //. Si le commentaire s'étale sur la prochaine ligne, ceci ne sera plus un commentaire, et c'est là que les commentaires multilignes interviennent. Un commentaire multilignes est ouvert par */ et est fermé par /*, alors que les commentaires mono-lignes sont fermé par la fin de ligne. Dans les commentaires multilignes, chaque ligne qui ne sera pas fermée doit être précédée d'une étoile. Les commentaires multilignes ont un avantage en plus : ils peuvent être utilisés sur seulement une ligne. Ces commentaires sont alors plus favorables que les mono-lignes. Voici des exemples de code concernant les commentaires :
//Ceci est un commentaire mono-ligne
/*Et celui-ci…
*est multilignes
*/
Hello World[modifier | modifier le wikicode]
Pour afficher un texte à l'écran, Swift propose une fonction obtenue via une bibliothèque : la fonction "print". Cette fonction prend une variante : "println", qui elle, une fois la fin du texte qui doit être afficher à l'écran, retourne à la ligne pour un prochain affichage. Cette fonction utilise la sortie standard. Voici le code d'affichage du célèbre "Hello World" :
println("Hello Word !")
Les guillemets ne sont pas obligatoires pour afficher seulement une variable (voir ci-dessous).
Calculs[modifier | modifier le wikicode]
Les calculs sont fait de cette manière :
- l'addition a pour signe +
- la soustraction a pour signe +
- la multiplication a pour signe *
- la division a pour signe /
Pour des opérations plus complexes, il faut utiliser des fonctions, voir ci-dessous.
Réservation d'une case en mémoire vive[modifier | modifier le wikicode]
Lorsqu'on a besoin de garder une donnée en mémoire, Swift le nous permet grâce a une de ses fonctionnalités, issues de la plupart des langages de programmation. Ces fonctionnalités sont "Le corp d'un programme", sans elle, un programme ne pourrait rien retenir pour utiliser après des données.
Variables[modifier | modifier le wikicode]
Une variable réserve dans la mémoire vive du mobile un espace pour stocker dans la case une valeur, sous forme d'un entier, réel, caractère, chaîne, booléen etc. Les variables sont présentes dans touts les autre langages de programmation. Une variable, comme son nom l'indique, peut changer de valeur par la suite. Pour préciser la variable qui devra changer de valeur, on met directement le nom de la variable et on l'affecte une nouvelle valeur, cette valeur peut changer de type. Sa déclaration se fait grâce au mot clé "var", le typage de la variable n'est pas obligatoire :
var nomDeLaVariable = "Valeur"; //Une variable est déclaré, sa valeur est "Valeur" (sans prendre en compte les guillemets)
Et avec le typage :
var nomDeLaVariable:String = "Valeur" //La variable a été déclaré avec son typage
Constantes[modifier | modifier le wikicode]
Les constantes réservent comme pour les variables leur contenu en mémoire, hors, cette valeur ne pourra jamais changer, sinon LLVM va retourner une erreur. L'utilisation d'une constante se fait pareillement qu'une variable, le mot clé "var" est remplacé par le mot clé "let". Voici un exemple :
let langage = "Swift" //La constante ne peut plus changer de valeur
var commentaire = "multilignes" //La variable peut changer…
commentaire = "mono-ligne" //Et elle a changé
Tuples[modifier | modifier le wikicode]
Les tuples sont des variables pouvant contenir plusieurs valeurs. Ces valeur peuvent être de différents types. Le mot clé "var" déclare un tuple, les valeurs sont mises dans des parenthèses. Les tuples ont presque les même fonctionnalités que les variables. Voici un exemple :
var bonjour = (aString: "Bonjour", aString: "Hello")
On précède le type de variable par a ou an, ça dépend si l'initial du mot d'après est une voyelle (ceci est de l'anglais).
Convention de nommage des variables, constantes et tuples[modifier | modifier le wikicode]
Le typage de ces trois bases du Swift est toutefois recommandé pour renforcer la sécurité du code et être sûr que LLVM fera bien son travail et ne retournera pas une erreur.
Les nom des variables peuvent causer problème lors de l'exécution : il existe certains mots réservés en Swift (mais aussi dans d'autres langages) qui eux ne peuvent pas être un nom de variable. Si ces mots sont utilisés comme nom de variable, LLVM renvoie une erreur. Ces mot sont des mots que Swift utilise pour travailler, tels que : var, let etc. Un autre point : si dans une chaîne on se retrouve avec un guillemet il faut utiliser le caractère d'échappement \ pour que LLVM comprend que ce n'est pas la fin de la valeur de la variable.
Il y a aussi une règle importante : Swift ne tolère pas les noms de variables contenant des espaces, caractères spéciaux ou même que la variable commence par une majuscule ! Toutefois, les petit "traits en bas" (_), appelé underscore, est toléré et plutôt utilisé pour remplacer les espaces par ces caractères.
Afficher variables…[modifier | modifier le wikicode]
Pour afficher une chaîne contenant une variable… dedans, il y a une règle à respecter : on ajoute un texte à un autre par concaténation. La concaténation se définie par ça. Afficher une variable ne nécessite aucun guillemet, mais quand on a un texte avec guillemets et qu'on doit mettre une variable dedans, la concaténation intervient. Cette méthode est celle-ci :
print("Hello " + "Word") /*On concatène : Hello (avec un espace après pour ne pas coller le prochain mot) et Word, eux tous sont des chaînes de caractères donc ils sont délimités par des guillemets*/
Et pour alors les variables :
var a = 1
print("a vaut : " + a)
Et l'affichage d'une variable est possible.
Calculs et opérateurs[modifier | modifier le wikicode]
En Swift, les calculs se font comme dans la plupart des langages. La notation des opérateurs est proche de celle du langage humain. On a le choix entre :
- L'opérateur d'addition : +
- L'opérateur de soustraction : -
- L'opérateur de multiplication : *
- L'opérateur de division : /
- L'opérateur d'incrémentation : ++
- L'opérateur de décrémentation : --
Et plein d'autres…
La bibliothèque mathématique Swift fournit un grand nombre de fonctions mathématiques pour des calculs plus complexes tels que les sinus, cosinus, tangentes etc.
Opérateurs logiques[modifier | modifier le wikicode]
Un opérateur logique est un opérateur important de Swift faisant la logique entre 2 valeurs, vérifiant si tel nombre est par exemple supérieur à l'autre… Les opérateurs logiques ne sont pas à confondre avec les fonctions logiques, qui eux sont issus de bibliothèques et vérifie comme les opérateurs logiques quelque chose mais qu'un opérateur logique ne peut faire. Un opérateur logique renvoie le booléen "true" si la vérification est conclue avec succès, sinon, il renvoie le booléen "false". Ces opérateurs sont importants pour faire fonctionner un morceau de code qui doit avoir une vérification tels que les conditions et les boucles. Les booléens peuvent aussi être une valeur de variable. Voici un tableau représentant les opérateurs logiques :
| Opérateurs logiques | Significations |
|---|---|
| == | Vérifie l'égalité avec Transtypage |
| === | Vérifie l'égalité sans Transtypage |
| < | Vérifie qu'une donnée est plus petite qu'une autre |
| > | Vérifie qu'une donnée est plus grande qu'une autre |
| <= | Vérifie qu'une donnée est plus petite ou égale à une autre |
| >= | Vérifie qu'une donnée est plus grande ou égale à une autre |
| != | Vérifie qu'une donnée est différente d'une autre avec Transtypage |
| !== | Vérifie qu'une donnée est différente d'une autre sans Transtypage |
| ! | Vérifie la négation |
| !< | Vérifie qu'une donnée n'est pas plus petite qu'une autre |
| !> | Vérifie qu'une donnée n'est pas plus grande qu'une autre |
Il existe des opérateurs de combinaisons, ils servent à combiner des conditions :
| Opérateurs de combinaisons | Significations |
|---|---|
| && | Et |
Il en existe un autre mais son affichage dans le tableau est impossible : ||, signifiant "Ou".
Boucles[modifier | modifier le wikicode]
Les boucles permettent de répéter plusieurs instructions à la fois, en fonctions d'une vérification par un opérateur/une fonction logique. Les boucles ont plusieurs déclarations : avec les mots clés : "do while", "while" et "for". La boucle do while veut dire : Faire… Tant que; la boucle while veut dire : Tant que et for veut dire : Pour. Voici des exemples de codes avec ces boucles, les commentaires expliquent le code.
Boucle while :
var i = 1 //La variable i est égal à 1
while i < 10 {
print("i vaut : " + i) //Tant que i est plus petit que 10 : afficher à l'écran "i vaut valeur de i"
i++ //Tant que i est plus petit que 10 : incrémenter i à chaque affichage
}
Boucle do while :
var i = 10
do {
print(i)
i--
} while i > 0
La boucle for ne va pas être présentée car son utilisation est un peu complexe, elle ne fait donc pas partie vraiment des bases. En plus, cette boucle a le même fonctionnement que la boucle while, juste la vision de cette boucle est différente.
Voici le fonctionnement d'une boucle : on déclare après les mots clés une vérification, qui va renvoyer la valeur "true" ou "false". Si la valeur renvoyée est "true", le code va être encore exécuté, si la valeur est "false", c'est qu'il n'y aura pas encore une exécution du code, en général.
Conditions[modifier | modifier le wikicode]
Un des fondamentaux principes de Swift : les conditions. Les conditions se servent des opérateurs logiques/fonctions logiques pour vérifier quelque chose et exécuter du code en variation du renvoi des opérateurs logiques, elles permettent de réagir face à plusieurs, donc de les gérer avec les opérateurs logiques/fonctions logiques. Il existe plusieurs conditions ayant pourtant la même fonctionnalité. Quand il y a déclaration de condition de type "if elseif else", l'écriture d'un mot clé "if", on doit demander une vérification de quelque chose par un opérateur logique ou une fonction logique. Cet/Cette opérateur logique/fonction logique va renvoyer une valeur "true" ou "false".
A partir de ces 2 booléens, un des codes peut être exécuté. Si le booléen renvoyée est "true", le code situé au niveau des accolades juste après la vérification à coté du "if" va être exécuté. Hors, si la valeur renvoyée est "false", le contenu des accolades va être ignoré, et on passe directement au niveau du : soit un else if, soit un else. Dans le 1er cas, on devra vérifier autre chose, ce qui va renvoyer un des 2 booléens.
Si le "true" est renvoyé, le code exécuté est celui au niveau des accolades après la vérification, si la valeur retournée est "false", on arrive dans le même cas. Le "else", lui, va définir dans ses accolades les instructions à faire si la valeur renvoyée est "false" au début et qu'il n'y a pas de "else if", hors, s'il y a un "else if", après il pourrait y'en avoir un, et donc le code sera exécuter si le dernier "elseif" renvoie la valeur "false".
Voilà comment fonctionne les conditions.
Les mots clés sont toutefois en anglais : "if" veut dire si|else veut dire sinon, else if veut dire sinon si.
Voici des exemples de conditions, les commentaires vous guideront :
var nombre = 24 //Déclaration d'une variable nombre valant 24
if nombre < 42 { /*Déclaration d'une condition "si la variable nombre est plus petite que 42", ouverture des accolades contenant les instructions à exécuter si la valeur renvoyée est "true"*/
print("La variable nombre est plus petite que 42, elle vaut " + nombre) //Si la valeur renvoyée est "true", afficher ce texte à l'écran
} else if nombre > 42 { //Sinon si la variable est plus grande que 42, renvoyer "true", et donc exécuter le code entre les accolades suivantes
print("La variable nombre est plus grande que 42, elle vaut " + nombre) //Si la valeur renvoyée est "false", afficher ce texte à l'écran
} else { //Si le cas n'est pas correspondant aux 2 autres
print("La variable nombre est égale à 42") /*Si aucun cas n'est correspondant (c'est à dire que les valeurs renvoyées sont toutes "false"), exécuter les instructions dans les accolades du "else"*/
}
Il existe aussi 2 cas dont un doit être appelé de manière un peu complexe, le 1er est le "if" sans le "else", c'est à dire qu'il n'y a aucune instruction à faire dans le cas de la valeur renvoyée "false". Le 2ème est le cas un peu complexe. Si on veut qu'il y'ai plusieurs cas sans le "else", on ne doit pas agir en finissant directement avec "else if", mis on doit toujours terminer avec un "else". Le dernier "else if" doit être un "else" et dans se "else" doit se contenir une instruction "if" toute seule. Voici un exemple :
let note = 19
if note === 20 {
println("Vous avez eu 20/20 ! Bravo !")
} else {
if note < 20 {
println("Vous pouvez faire mieux")
}
}
Il existe une autre condition appelée à l'aide du mot clé switch avec un fonctionnement similaire à la précédente :
let endurance = "20 km"
switch endurance { //On déclare la condition qui vérifie la valeur de endurance
case "20 km": //Si la valeur est 20 km...
print("Endurance vaut " + endurance)
case "30 km", "40 km": //Si la valeur est 30 km ou 40 km
print("Endurance vaut " + endurance)
default: //Fonctionne comme else
print("Ceci est default")
}
Il existe aussi une condition appelée "condition ternaire" mais qui ne fait pas vraiment partie des bases. Elle est facultative.
Fonctions[modifier | modifier le wikicode]
Les fonctions sont des morceaux de code réutilisables et autonomes, une suite d'instructions figure dedans, une valeur sera retourner ou pas. C'est la base d'un langage de programmation. Une fonction fait exécuter du code une fois traduit en binaire. Si on peut par exemple calculer le cosinus de 0 (cos(0)), on doit utiliser une fonction capable de calculer un calcul complexe.
Il existe 2 types de fonctions : les fonctions natives de Swift, et les fonctions utilisateurs. Une fonction native est elle-même fournie par Swift, ou une de ses extensions. Les fonctions utilisateurs, quant à elles, sont écrites par vous-même, ou fournies par des bibliothèques Swift, préservant un grand nombre de fonctions prête à employer. Ces fonctions ont la particularité : elles ont été écrite par des développeurs Swift, ou des personnes connaissant le Swift. Les fonctions ont alors été mises à disponibilité de vous.
Fonctions natives[modifier | modifier le wikicode]
Les fonctions natives de Swift répondent à des besoins spécifiques. Elles sont similaires aux fonctions utilisateurs.
Fonctions utilisateurs[modifier | modifier le wikicode]
Une fonction utilisateur est l'ensemble d'instructions pouvant être appelées depuis le programme. Les fonctions utilisateurs servent à exécuter des tâches complexes, nécessitant d'être séparé du code pour une meilleur lisibilité. Une syntaxe peut appelée les instructions incluent dans la fonction pour les exécuter par la suite.
Code[modifier | modifier le wikicode]
Déclaration de la fonction[modifier | modifier le wikicode]
Pour déclarer une fonction en Swift, on utilise le mot clé "func" suivi du nom de la fonction. La convention de nommage d'une fonction est la même que celle des variables. Après cette déclaration, on ajoute des parenthèses. Ces parenthèses vont être expliquées plus loin.
Par la suite, on ouvre un bloc d'accolades, dedans y figurent les instructions de la fonction.
Ce code va reprendre ce qui a été dit.
func ecrire() {
print "Ecriture !"
}
ecrire() //Appel de la fonction : affiche "Ecriture" (sans les guillemets)
Passage de paramètres[modifier | modifier le wikicode]
On peut passer des paramètres (ou arguments), se sont des valeurs que l'on passe à des fonctions lors de son utilisation. Celle-ci est placée entre les parenthèses. On doit préciser le nom des paramètres et leur type à la déclaration de la fonction. Le paramètre va être alors une variable. Lors de l'utilisation de la fonction vous pourrez alors donnez la valeur du paramètre.
func ecrire(texte: String) { //Déclaration d'un paramètre "texte" devant être une valeur de type "String"
print("Ecriture de "+ texte) Traitement du paramètre étant variable
}
ecrire(texte: "Bonjour !") //Appel de la fonction écrire avec paramètre de type String "Bonjour !". Affiche donc "Ecriture de Bonjour !"
Pour passer plusieurs paramètres, il faut les séparer par des virgules.
Retourner une valeur[modifier | modifier le wikicode]
Une fonction peut retourner une valeur spécifique. Cette valeur retournée est propre à la fonction. Pour retourner une valeur, il faut déjà, à la déclaration de la fonction, utiliser après la fin de parenthèse contenant dedans les arguments le symbole ->, composé d'un tiret et d'un signe supérieur à …, on écrit après ça le type de la valeur de retour. Dans les instructions à exécuter lors de l'appel de la fonction, on met la syntaxe "return valeurARetourner".
func aditionner(nombre1: Int, nombre2: Int) -> Int {
print(nombre1+ " + " +nombre2+ " = ")
return nombre1 + nombre2
}
aditionner(nombre1: 5, nombre2: 4)
Programmation orienté objet[modifier | modifier le wikicode]
Nous avons vu dans les précédentes sections la programmations procédurales, c'est à dire faite par procédures. Swift, puissant, permet d'aller plus loin. La programmation orienté objet (POO) est une fonctionnalité puissante de Swift qui introduit de nombreux autres concepts. D'autres langages de programmations utilisent
La programmation orienté objet est apparue en 1960, créée par Ole-Johan Dahl et Kristen Nygaard, des norvégiens. Pour compléter ce nouveau mode de programmation, Alan Kay continue d'y travailler sur vers 1970.
La programmation orienté se présente comme un code plus lisible, mieux représenté et permettant de séparer des données pour que des objets (voir ci-dessous) les utilise, et donc que l'objet a des caractéristiques propre à lui. Cette façon de programmer présente divers avantages :
- Code modélisable : l'UML est une représentation schématique d'un programme écrit en objet. Ce shéma serait utile pour représenter le programme de façon claire.
- Le code est réutilisable
- Un code modulaire
Bien sûr, la POO possède d'autres avantages.
Les notions introduites dans la POO sont les objets, un ensemble autonome. Se sont des données manipulables grâce à une classe, c'est l'instance d'une classe (ou modèle). L'objet est une donnée possédant des caractéristiques utilisables via Swift.
Classes[modifier | modifier le wikicode]
Une classe est le modèle d'un objet. Ce modèle peut être considéré comme une description d'une chose sur une feuille. Ce modèle décrit des propriétés de l'objet : se sont ses attributs. Il y a aussi des traitements, appelés méthodes.
Avec cette description, on peut construire un vrai objet. Si on crée une moto, la moto est une instance de la classe moto.
Codes[modifier | modifier le wikicode]
Créer une classe[modifier | modifier le wikicode]
Dans la POO en Swift, on peut créer des classes grâce au mot clé "class". On définit après le nom de la classe, avec la même convention de nommage des variables, parcontre la majuscule au début n'est pas interdit. Ensuite, on met un bloc d'accolades. Dedans, vous pouvez insérez des variables contenant obligatoirement une valeur mise soit lors de l'instanciation (expliquée ci-dessous), soit directement, se sont les attributs. On peut aussi définir des constantes. On doit ensuite définir des méthodes. Les méthodes sont des fonctions, utilisées comme on avait dit dans la section fonction.
class Velo { //Propriétés
var vitesses = 12
var plateaux = 3
var marque = "Swift"
//Méthode
func accelerer(vitesse: Int, plateau: Int) {
print("Accélération à la vitesse " + vitesse + " et en plateau " + plateau)
}
}
Créer un objet[modifier | modifier le wikicode]
Une fois qu'une classe a été définie, pour qu'elle devienne fonctionnelle, on doit créer un objet. Cette création est effectuée de cette manière :
let velo = Velo()
Détaillons un peu ce code : Ici, nous créons un objet velo, instance de la classe Velo.
Bibliothèques Swift[modifier | modifier le wikicode]
Dans tous les langages de programmations, des bibliothèques sont présentes. Ces bibliothèques fournissent un grand nombre de fonctions utilisateurs. Les bibliothèques ont chacune un nom pour ce repérer plus facilement, fournissant des fonctions précises chacune. Les fonctions servent à faire plusieurs exécutions. Les fonctions ne sont pas obligées de renvoyer une valeur. Par exemple "print" est une fonction venant d'une bibliothèque. Les fonctions peuvent toutefois être crées manuellement dans le code.
Sans les bibliothèques, les langages seraient pas puissant, ou le code devra être créé manuellement.
Liens[modifier | modifier le wikicode]
Liens internes[modifier | modifier le wikicode]
Liens externes[modifier | modifier le wikicode]
|
Les langages de l’informatique
|
|
A vikifier : Vikification générale. A ajouter : POO