Syntaxe de base de Dart
Chaque langage de programmation a son propre ensemble de règles de base, et Dart ne fait pas exception.
Ce chapitre présente la structure de base des programmes Dart, la syntaxe des commentaires, la différence entre instructions et expressions, ainsi que les conventions de nommage des identifiants.
Structure du programme et fonction main()
Le suffixe du nom de fichier Dart est.dart..., chaque programme Dart doit avoir un point d'entrée — la fonction main().
Le programme commence son exécution à la première ligne de la fonction main() et se termine à l'accolade fermante de la dernière ligne.
Exemple
La structure du programme Dart le plus simple :
void main() {
// Écrivez votre code ici
print('Bienvenue dans le tutoriel Dart EXAMPLE !');
}
欢迎来到 EXAMPLE Dart 教程!
Décomposons chaque partie de ce code :
| Éléments de code | Description |
|---|---|
| void | Type de retour ; void indique que la fonction ne renvoie aucune valeur |
| main | Nom de la fonction ; il s'agit du nom de la fonction d'entrée spécifié par Dart et qui ne peut pas être modifié |
| () | Liste de paramètres ; main() peut n'accepter aucun paramètre, ou accepter des arguments de ligne de commande |
| { } | Corps de la fonction ; le code à l'intérieur des accolades est ce que la fonction exécute |
| print() | Fonction intégrée, utilisée pour afficher du texte dans la console |
| ; | Terminateur d'instruction ; chaque instruction en Dart doit se terminer par un point-virgule |
Dart exige strictement que chaque instruction se termine par un point-virgule (;). Oublier le point-virgule est l'erreur de syntaxe la plus courante chez les débutants. Heureusement, l'extension Dart dans VS Code indique automatiquement où les points-virgules manquent.
La fonction main() avec arguments de ligne de commande
La fonction main() peut accepter une liste de chaînes de caractères comme arguments de ligne de commande :
Exemple
void main(List<String> args) {
// Afficher le nombre d'arguments
print('Nombre d'arguments : ${args.length}');
// Parcourir et afficher chaque argument
for (var i = 0; i < args.length; i++) {
print('Argument $i : ${args[i]}');
}
}
$ dart run hello.dart example dart 教程 参数个数:3 参数 0: example 参数 1: dart 参数 2: 教程
Ceci utilise le type List et une boucle for, que nous aborderons en détail dans les chapitres suivants.
Syntaxe des commentaires
Les commentaires sont des explications du code ; le compilateur ignore le contenu des commentaires.
De bons commentaires aident les autres (y compris vous-même quelques mois plus tard) à comprendre plus rapidement l'intention du code.
Dart prend en charge trois styles de commentaires :
| Type | Syntaxe | Scénarios applicables |
|---|---|---|
| Commentaire sur une ligne | // contenu du commentaire | Expliquer brièvement le but d'une ligne de code |
| Commentaire multiligne | /* Contenu du commentaire */ | Explication détaillée sur plusieurs lignes |
| Commentaire de documentation | /// Commentaires de documentation | Générer la documentation API pour les fonctions et les classes |
Exemple
/// Les commentaires de documentation peuvent être utilisés pour générer une documentation HTML avec la commande [dart doc]
void main() {
// Commentaire sur une ligne : affiche un message de bienvenue
print('Bienvenue pour apprendre Dart !'); // Commentaire en ligne : ceci est également valide
/*
* Commentaire multiligne: convient aux explications plus longues
* Commentaire de la deuxième ligne
* Commentaire de la troisième ligne
*/
print('EXEMPLE Tutoriel - Syntaxe de base Dart');
}
欢迎学习 Dart! EXAMPLE 教程 - Dart 基础语法
Le principe des commentaires est d'"expliquer pourquoi, pas quoi." Le code lui-même montre déjà ce qu'il fait ; les commentaires doivent expliquer pourquoi il est écrit ainsi, ou fournir des informations contextuelles que le code ne peut pas exprimer.
Instructions et expressions
En Dart, le code est composé d'instructions et d'expressions.
Comprendre la différence entre les deux vous aide à mieux organiser la logique de votre code.
Expression
Une expression est un morceau de code qui peut être évalué et qui produit une valeur.
Exemple
// Chacune des lignes suivantes est une expression ; elles produisent toutes une valeur.
42; // Expression littérale, la valeur est 42
3 + 5; // Expression arithmétique, la valeur est 8
'Hello'.length; // Expression d'accès à une propriété, la valeur est 5
(10 > 5); // Expression relationnelle, la valeur est true
}
Instruction
Une instruction est une directive qui effectue une action, et elle ne produit pas de valeur.
Exemple
// Instruction de déclaration de variable : déclare une variable et lui attribue une valeur
var name = 'EXAMPLE';
// Instruction d'appel de fonction : appelle print() pour effectuer une action de sortie
print(name);
// Instruction de contrôle de flux : décide quel code exécuter en fonction des conditions
if (name.length > 3) {
print('La longueur du nom est supérieure à 3');
}
}
EXAMPLE 名称长度大于 3
En bref :Les expressions produisent des valeurs, les instructions effectuent des actions.
Vous pouvez utiliser des expressions là où une valeur est nécessaire, mais vous ne pouvez pas utiliser d'instructions.
Une idée fausse courante consiste à considérer tout le code comme des « instructions ». En réalité, de nombreuses constructions en Dart (comme les appels de fonctions et les affectations de variables) sont elles-mêmes des expressions, ce qui signifie qu'elles peuvent être imbriquées. C'est une caractéristique commune à Dart et aux autres langages de la famille C.
Conventions de nommage des identifiants
Un identifiant est le nom que vous donnez à des éléments de code tels que des variables, des fonctions et des classes.
Dart a quelques règles et conventions pour les identifiants :
Règles de nommage (à respecter)
Les identifiants ne peuvent être composés que de lettres, de chiffres, de traits de soulignement (_) et de signes dollar ($).
Les identifiants ne peuvent pas commencer par un chiffre.
Les identifiants ne peuvent pas être des mots-clés réservés de Dart (tels que class, if, var, etc.).
Conventions de nommage (recommandées)
| Éléments de code | Conventions de nommage | Exemple |
|---|---|---|
| Nom de classe | UpperCamelCase | StudentInfo, HttpClient |
| Type énuméré | UpperCamelCase | Color, Status |
| Noms de bibliothèques et de fichiers | lowercase_with_underscores | my_utils, user_service |
| Nom de la variable | lowerCamelCase | userName, maxCount |
| Nom de la fonction | lowerCamelCase | getUserInfo(), calculateTotal() |
| Nom de constante | lowerCamelCase | piValue, defaultPort |
| Membres privés | Préfixe de soulignement | _internalState、_privateMethod() |
Exemple
Applications pratiques de divers styles de nommage :
class UserAccount {
// Membres publics : lowerCamelCase
String userName;
// Membres privés : préfixe underscore (accessibles uniquement dans ce fichier)
String _password;
// constructeur
UserAccount(this.userName, this._password);
// Méthodes publiques : lower camelCase
bool verifyPassword(String input) {
return input == _password;
}
// Méthodes privées : préfixe underscore
void _encryptPassword() {
// Logique de chiffrement...
}
}
// Fonction d'entrée : minuscules
void main() {
// Noms de variables : lower camelCase
var userAccount = UserAccount('example', '123456');
// Constantes : lower camelCase (style Dart)
const maxLoginAttempts = 3;
print('Nom d’utilisateur : ${userAccount.userName}');
print('Nombre maximal de tentatives de connexion : $maxLoginAttempts');
}
用户名: example 最大登录尝试次数: 3
Dans les conventions de nommage de Dart, les constantes utilisent lowerCamelCase, plutôt que le style en majuscules avec traits de soulignement (UPPER_CASE) courant dans d'autres langages. C'est un style unique de la communauté Dart, alors assurez-vous de bien le garder à l'esprit.
