1 \part{Syntaxe et éléments de bases de Nit
}
5 \section{Nit est sensible à la casse
}
6 Nit est sensible à la casse :
7 \lstinputlisting[language=Nit
]{./syntaxe/listings/var_c.nit
}
8 Ici |ma_var| et |ma_VAR| sont deux variables différentes.
10 \section{Retours chariots
}
11 Avec Nit, les retours chariots ont du sens !
13 Exemple
\og One Liner
\fg :
14 \lstinputlisting[language=Nit,linerange=
1-
1]{./syntaxe/listings/chariot_s.nit
}
15 Exemple
\og Bloc
\fg :
16 \lstinputlisting[language=Nit,linerange=
2-
4]{./syntaxe/listings/chariot_s.nit
}
18 Notez que l'indentation est ignorée du compilateur mais elle permet une meilleure compréhension du code par le programmeur, il est donc conseillé de bien indenter son code !
22 \section{Identificateurs
}
24 Chaque objet, classe, module ou variable est associé à un nom : l'
\textbf{identificateur
} qui peut se composer de tous les caractères alphanumériques et du caractère de soulignement (
\_). Le premier caractère doit être une lettre ou le caractère de soulignement.
26 Attention : Le compilateur lèvera une exception si une variable commence par une majuscule.
28 Un identificateur ne peut pas appartenir à la liste des mots clés réservé du langage Nit :
84 \section{Convention d'écriture
}
86 Quelques règles pour l'écriture d'un programme en Nit :
88 \item On préfèrera utiliser la notation basée sur le soulignement pour les variables. Par exemple : |ma_variable| ;
89 \item Les types, comme les noms des classes seront écrits en
\og CamelCase
\fg. Par exemple : |MaClasse| ;
90 \item L'indentation est faite avec le caractère de tabulation et est afficher comme
8 espaces ;
91 \item Les opérateurs sont entourés d'espaces. Par exemple : |
4 +
5| ou |x =
5| ;
92 \item Les spécificateurs de type (|:|) et les virgules (|,|) ont un espace après mais pas avant. Par exemple : |var x: X| ou |
[1,
2,
3]| ;
93 \item Les parenthèses (|()|) et les crochets (|
[]|) ne prennent pas d'espaces ;
94 \item Le |do| des méthodes se trouve sur sa propre ligne et n'est pas indenté ;
95 \item Le |do| des boucles se trouve sur la même ligne que la déclaration de la boucle ;
98 \section{Commentaires
}
99 Les commentaires ne sont pas pris en compte par le compilateur. En Nit il existe seulement des commentaires sur une seule ligne grâce au caractère |#|.
100 Il peuvent s'utiliser seulement sur une ligne ou alors en fin de ligne comme le montre l'exemple suivant :
101 \lstinputlisting[language=Nit
]{./syntaxe/listings/comment_s.nit
}
103 A l'heure actuelle, Nit ne supporte pas les commentaires multi-lignes.
105 \chapter{Éléments de bases de Nit
}
107 \section{Déclaration et utilisation des variables
}
109 Une variable possède un nom, un type et une valeur. Une variable est accessible et utilisable dans le bloc où elle est définie.
111 La déclaration d'une variable permet de réserver une zone de la mémoire pour y stocker une valeur.
113 En Nit les types peuvent être optionnels dans une déclaration. En effet, Nit est un langage statiquement typé par type adaptatif. C'est à dire qu'il est capable de
\og deviner
\fg le type de la variable déclarée en fonction de son utilisation.
115 Déclaration et affectation sur deux lignes en précisant le type :
116 \lstinputlisting[language=Nit, linerange=
1-
2]{./syntaxe/listings/declaration_s.nit
}
117 Déclaration et affectation sur une seule ligne en précisant le type :
118 \lstinputlisting[language=Nit, linerange=
3-
3]{./syntaxe/listings/declaration_s.nit
}
119 Déclaration et affectation sur une seule ligne sans préciser le type :
120 \lstinputlisting[language=Nit, linerange=
4-
4]{./syntaxe/listings/declaration_s.nit
}
122 Ces trois exemples reviennent strictement au même. Dans le dernier exemple, lorsque l'on affecte
0 à la variable x, Nit comprend que |x| est de type |Int|.
124 Rappel : Les noms de variables en Nit peuvent commencer par une lettre ou par le caractères de soulignement. Le reste du nom peut comporter des lettres ou des nombres mais jamais d'espace.
126 Nit est un langage à typage rigoureux qui ne possède pas de transtypage automatique lorsque ce transtypage risque de conduire à une perte d'information ou à une erreur d'exécution.
128 Pour les objets, il est nécessaire en plus de la déclaration de la variable, de créer un objet avant de pouvoir l'utiliser. Il faut réserver de la mémoire pour la création d'un objet avec l'instruction |new|. Si l'objet n'est plus utilisé, la libération de la mémoire se fait automatiquement grâce au ramasse miettes.
130 Exemple d'utilisation du mot clé |new| :
131 \lstinputlisting[language=Nit
]{./syntaxe/listings/new_s.nit
}
133 Vous remarquerez qu'en Nit, il n'est pas nécessaire d'utiliser les parenthèses si le constructeur ne prend pas de paramètres.
135 \section{Type nullable
}
136 Pour éviter les exceptions |nullPointerException| qui peuvent être très fréquentes sur d'autres langages, Nit impose au développeur de préciser si une variable a le droit de prendre la valeur |null|.
138 Pour préciser qu'une variable peut prendre la valeur |null|, il faut utiliser le mot clé |nullable|.
141 \lstinputlisting[language=Nit, linerange=
1]{./syntaxe/listings/nullable_c.nit
}
143 En Nit, toute variable déclarée |nullable| mais qui n'a pas été initialisé a la valeur par défaut |null|. A l'inverse, une variable qui n'est pas déclarée |nullable| et n'est pas initialisée avant d'être utilisée provoquera une erreur de compilation.
145 \section{Affectation
}
146 Le signe |=| est l'opérateur d'affectation et s'utilise avec une expression de la forme |variable = expression|.
148 Il existe des opérateurs qui permettent de simplifier l'écriture d'une opération d'affectation associée à un opérateur mathématique :
150 \begin{tabularx
}{\linewidth}{|c|c|X|
}
152 \textbf{Opérateur
} &
\textbf{Exemple
} &
\textbf{Signification
} \\
154 = & a =
10 & équivalent à : a =
10 \\
156 += & a +=
10 & équivalent à : a = a +
10 \\
158 -= & a -=
10 & équivalent à : a = a -
10 \\
164 \section{Comparaison
}
166 Nit propose les opérateurs pour toutes les comparaisons :
168 \begin{tabularx
}{\linewidth}{|c|c|X|
}
170 \textbf{Opérateur
} &
\textbf{Exemple
} &
\textbf{Signification
} \\
172 > & a >
10 & strictement supérieur \\
174 < & a <
10 & strictement inférieur \\
176 >= & a >=
10 & supérieur ou égal\\
178 <= & a <=
10 & inférieur ou égal\\
180 == & a <=
10 & égal\\
182 != & a !=
10 & différent de\\
184 and & a and b & ET logique (pour expressions booléennes) :
\newline l'évaluation de l'expression cesse dés qu'elle devient fausse\\
186 or & a or b & OU logique (pour expressions booléennes) :
\newline l'évaluation de l'expression cesse dés qu'elle devient vraie\\
188 not & not b & NON logique\\
193 \section{Priorité des opérateurs
}
195 Les opérateurs sont exécutés dans l'ordre suivant à l'intérieur d'une expression qui est analysée de gauche à droite :
197 \item multiplication, division et reste de division (modulo)
198 \item addition et soustraction
200 \item le signe |=| d'affectation d'une valeur à une variable
206 L'usage des parenthèses permet de modifier cet ordre de priorité.
208 \section{Structures de contrôles
}
210 Comme les autres langages de développement, Nit propose un ensemble d'instruction qui permettent d'organiser et de structurer les traitements. L'usage de ces instructions est similaire à celui rencontré à leur équivalent dans d'autres langages.
213 \subsubsection{While
}
214 Dans une boucle |while|, le code est exécuté tant que la condition est vraie. Si avant l'instruction |while|, le booléen est faux, alors le code de la boucle ne sera jamais exécuté.
217 \lstinputlisting[language=Nit, linerange=
1-
6]{./syntaxe/listings/while_c.nit
}
219 Le |while| peut aussi s'écrire sur une seule ligne :
220 \lstinputlisting[language=Nit, linerange=
8]{./syntaxe/listings/while_c.nit
}
223 En Nit, TOUT est objet et même les structures de contrôle. Ceci amène donc à une syntaxe un peu particulière. Ne vous en faites pas, on s'y fait !
225 Voici donc la syntaxe d'une boucle |for| :
226 \lstinputlisting[language=Nit, linerange=
1-
4]{./syntaxe/listings/for_c.nit
}
228 On peut bien sûr utiliser des variables pour créer nos boucles :
229 \lstinputlisting[language=Nit, linerange=
6-
11]{./syntaxe/listings/for_c.nit
}
231 Ou même des expressions :
232 \lstinputlisting[language=Nit, linerange=
13-
16]{./syntaxe/listings/for_c.nit
}
234 Le |for| peut lui aussi s'écrire sur une ligne :
235 \lstinputlisting[language=Nit, linerange=
18]{./syntaxe/listings/for_c.nit
}
238 Les boucles infinies sont souvent utilisés accompagnées de l'instruction |break|. Elles sont utiles pour implémenter les boucles de type
\og jusqu'à
\fg |untill| ou pour simuler le |exit when| de Ada.
240 \lstinputlisting[language=Nit
]{./syntaxe/listings/loop_c.nit
}
242 \subsection{Blocs do
}
243 Le |do| simple peut être utilisé pour déclarer des blocs de code ou jouer avec la portée des variables.
245 \lstinputlisting[language=Nit
]{./syntaxe/listings/do_c.nit
}
247 \subsection{Branchements conditionnels
}
248 Avec Nit il n'existe qu'un seul type de branchement conditionnel : le |if|. On peut l'utiliser avec ou sans clause |else|.
251 \lstinputlisting[language=Nit, linerange=
1-
7]{./syntaxe/listings/if_c.nit
}
253 On peut aussi utiliser des clauses |else if| pour chaîner plusieurs tests :
254 \lstinputlisting[language=Nit, linerange=
9-
17]{./syntaxe/listings/if_c.nit
}
256 Attention : Si on utilise un |else| ou un |else if|, l'instruction ne peut pas être écrit
\og OnLiner
\fg.
258 \subsection{Débranchements
}
259 |continue| permet de passer immédiatement à l'itération suivante dans une boucle |for|, |while| ou |loop| :
260 \lstinputlisting[language=Nit
]{./syntaxe/listings/continue_c.nit
}
262 |break| permet de quitter immédiatement une boucle |for|, |while|, |loop| ou un bloc |do| :
263 \lstinputlisting[language=Nit
]{./syntaxe/listings/break_c.nit
}
265 Des labels peuvent être utilisés pour spécifier sur quel élément |for|, |while|, |loop| ou |do| doit agir le break :
266 \lstinputlisting[language=Nit
]{./syntaxe/listings/label_c.nit
}
268 On peut aussi utiliser les labels de la même manière avec l'instruction |continue|.
270 \subsection{Arrêt du programme
}
271 L'instruction |abort| permet d'arrêter le programme en lançant une erreur fatale.
273 \subsection{Assertions
}
274 L'instruction |assert| vérifie si une expression booléenne est vrai, sinon elle arrêtera le programme comme |abort|. Elle peut être combinée à une close |else| pour exécuter du code avant d'arrêter le programme :
275 \lstinputlisting[language=Nit
]{./syntaxe/listings/assert_c.nit
}
277 Comme on peut le voir dans l'exemple précédent, une étiquette peut être précisée pour être affichée dans le message d'erreur.
280 Les tableaux permettent de stocker un ensemble de valeur du même type dans la même variable. En Nit, la classe de base pour manipuler les tableaux est la classe |Array|.
282 \subsection{Déclaration des tableaux
}
283 Pour commencer, il va falloir instancier la classe |Array|. Chaque instance de |Array| ne peut contenir qu'un seul type de variable à la fois. Il faut préciser le type lors de l'instanciation grâce aux crochets |
[]|.
285 \lstinputlisting[language=Nit, linerange=
1]{./syntaxe/listings/array_c.nit
}
287 Il est ensuite possible d'ajouter des valeurs dans le tableau en précisant dans quelle case du tableau on souhaite ajouter la valeur en utilisant l'opérateur |
[]|.
290 \lstinputlisting[language=Nit, linerange=
3-
4, firstnumber=last
]{./syntaxe/listings/array_c.nit
}
292 Ce même opérateur permet de récupérer les valeurs du tableau :
293 \lstinputlisting[language=Nit, linerange=
6-
7, firstnumber=last
]{./syntaxe/listings/array_c.nit
}
295 Attention, en Nit, la première case du tableau est la case
0 !
297 \subsection{Initialisation explicite d'un tableau
}
298 Il existe une manière plus rapide de créer les tableaux en initialisant explicitement le tableau avec les valeurs qu'il doit contenir.
300 \lstinputlisting[language=Nit, linerange=
1]{./syntaxe/listings/array2_c.nit
}
302 \subsection{Parcours d'un tableau
}
303 On peut parcourir les tableaux grâce à une boucle |for| :
304 \lstinputlisting[language=Nit, linerange=
3-
5, firstnumber=last
]{./syntaxe/listings/array2_c.nit
}
306 %
\section{Intervalles
}
307 %TODO vérifier et faire
308 %Il est possible de déclarer des intervalles |Range| basés sur des types discrets (comme |Int| par exemple). Il existe deux types d'intervalles : les intervalles ouverts |
[1.
.5[| qui excluent le dernier élément, et les intervalles fermés |
[1.
.5]| qui incluent le dernier élément.
313 \section{Conversions de types
}
314 En Nit, il n'existe pas de mot clé de transtypage. Les conversions de types se font par des méthodes. La bibliothèque standard fournit une série de classe qui contiennent des méthodes de manipulation et de conversion de types.
316 \begin{tabularx
}{\linewidth}{|c|X|
}
318 \textbf{Classe
} &
\textbf{Rôle
} \\
320 Char & pour les caractères \\
322 String & pour les chaînes de caractères \\
324 Int & pour les entiers \\
326 Float & pour les nombres à virgule flottante \\
330 Par exemple la classe Int propose les méthodes suivantes :
332 \item[Int.to
\_c:Char
] Retourne le caractère correspondant.
333 \item[Int.to
\_f:Float
] Retourne l'entier sous forme de |Float|.
334 \item[Int.to
\_s:String
] Retourne l'entier sous forme de |String|.
337 \section{Manipulation de chaînes de caractères
}
338 \subsection{Char et String
}
339 La définition d'un caractère se fait grâce au type |Char|.
341 Pour assigner explicitement un caractère à une variable de type |Char|, il faut utiliser l'apostrophe |'|.
343 \lstinputlisting[language=Nit
]{./syntaxe/listings/char1_c.nit
}
345 La définition d'une chaine de caractères se fait grâce au type |String|.
347 Pour assigner explicitement un caractère à une variable de type |String|, il faut utiliser les guillemets |"|.
349 \lstinputlisting[language=Nit, linerange=
1-
1]{./syntaxe/listings/string_c.nit
}
351 Les variables de type |Char| et |String| sont des objets. Partout où des constantes de caractères ou de chaînes figurent entre guillemets, le compilateur Nit génère l'objet correspondant avec le contenu spécifié. Il est donc possible d'écrire :
352 \lstinputlisting[language=Nit, linerange=
3-
3, firstnumber=last
]{./syntaxe/listings/string_c.nit
}
354 Bien que |Char| et |String| soient des classes, ils ne possèdent pas de constructeurs, il n'est donc pas possible de les initialiser en appelant la méthode |init|.
356 Attention, Nit ne supporte que l'encodage UTF-
8 !
358 \subsection{Caractères spéciaux
}
360 Dans un chaîne de caractères, plusieurs caractères particuliers doivent être échappés grâce au caractère |\| pour être utilisés.
362 Le tableau ci-dessous recense les principaux caractères à échapper :
365 \begin{tabular
}{|c|c|
}
367 \textbf{Caractères spéciaux
} &
\textbf{Affichage
} \\
373 \lstinline!\! & antislash \\
375 \lstinline!
\t! & tabulation \\
377 \lstinline!
\b! & retour arrière (backspace) \\
379 \lstinline!
\r! & retour chariot \\
381 \lstinline!
\f! & saut de page \\
383 \lstinline!
\n! & saut de ligne \\
388 \subsection{Concaténation de chaînes de caractères
}
390 Il est possible de concaténer des chaînes de caractères à l'aide de l'opérateur |+| et de le combiner à l'opérateur d'affectation |=|.
392 \lstinputlisting[language=Nit, linerange=
5-
5, firstnumber=last
]{./syntaxe/listings/string_c.nit
}
394 Pour concaténer un autre type avec un string, il faut faire appel à la méthode |to_s|.
396 Par exemple avec un Int :
397 \lstinputlisting[language=Nit, linerange=
7-
7]{./syntaxe/listings/string_c.nit
}
399 Une notation allégée permet de concaténer une variable ou une expression avec une chaine de caractère :
400 \lstinputlisting[language=Nit, linerange=
9-
10]{./syntaxe/listings/string_c.nit
}
402 La notation allégée appelle implicitement la méthode |to_s| sur les types autres que |String| :
403 \lstinputlisting[language=Nit, linerange=
12-
12]{./syntaxe/listings/string_c.nit
}
405 La notation allégée sera préférée puisqu'elle est plus lisible mais aussi bien plus performante car traitée différemment pas le compilateur.
407 \subsection{Comparaison de chaînes de caractères
}
409 En Nit il est possible de comparer deux chaînes de caractères directement grâce à l'opérateur |==|. Contrairement à Java par exemple, Nit va comparer la valeur des objets String est non pas les objets en eux-mêmes.
410 \lstinputlisting[language=Nit
]{./syntaxe/listings/string2_c.nit
}
412 \subsection{Autres opérations sur les chaînes de caractères
}
413 Les méthodes |to_upper| et |to_lower| permettent respectivement d'obtenir une chaîne tout en majuscule ou tout en minuscule.
415 La méthodes |length| permet d'obtenir la taille de la chaîne.
417 On peut accéder aux caractères d'une chaine en utilisant la notation en tableau :
418 \lstinputlisting[language=Nit
]{./syntaxe/listings/string3_c.nit
}
420 Enfin, il est possible de répéter une chaine de caractères grâce à l'opérateur de multiplication |*| :
421 \lstinputlisting[language=Nit
]{./syntaxe/listings/string4_c.nit
}
423 \chapter{Typage Adaptatif
}
424 \label{typage-adaptatif
}
425 Nit est le premier langage à introduire la notion de
\textbf{typage adaptatif
}. Le principe est que le type statique d'une variable peut changer en fonction de l'assignation des variables et du contrôle de flot.
428 \lstinputlisting[language=Nit
]{./syntaxe/listings/typage_c.nit
}
430 Les instructions de contrôle de flot vont eux aussi agir sur le typage de la variable :
431 \lstinputlisting[language=Nit
]{./syntaxe/listings/typage2_c.nit
}
433 Le typage adaptatif fonctionne aussi avec les types nullables :
434 \lstinputlisting[language=Nit
]{./syntaxe/listings/typage3_c.nit
}