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 :

// Point d'entrée du programme : la fonction main() est le point de départ d'un programme Dart
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 codeDescription
voidType de retour ; void indique que la fonction ne renvoie aucune valeur
mainNom 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

// List<String> args reçoit la liste des arguments passés depuis la ligne de commande
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 &lt; 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 :

TypeSyntaxeScénarios applicables
Commentaire sur une ligne// contenu du commentaireExpliquer 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 documentationGénérer la documentation API pour les fonctions et les classes

Exemple

/// Ceci est un commentaire de documentation qui décrit la fonctionnalité du programme
/// 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

void main() {
  // 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

void main() {
  // 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 codeConventions de nommageExemple
Nom de classeUpperCamelCaseStudentInfo, HttpClient
Type énuméréUpperCamelCaseColor, Status
Noms de bibliothèques et de fichierslowercase_with_underscoresmy_utils, user_service
Nom de la variablelowerCamelCaseuserName, maxCount
Nom de la fonctionlowerCamelCasegetUserInfo(), calculateTotal()
Nom de constantelowerCamelCasepiValue, defaultPort
Membres privésPréfixe de soulignement_internalState、_privateMethod()

Exemple

Applications pratiques de divers styles de nommage :

// Nom de classe : UpperCamelCase
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.

autres extensions