Démarrage rapide de l'apprentissage avec Flutter (2)

Dart est un langage de programmation informatique développé par Google et utilisé pour le développement du Web, des serveurs, des applications mobiles et de l'Internet des objets. Dart est un langage à héritage unique, orienté objet, défini par classe.

Quelques concepts importants de Dart

Variables et types de données : Dart est un langage fortement typé, les variables doivent déclarer explicitement des types ou utiliser l'inférence de type. Dart prend en charge une variété de types de données, notamment des nombres, des chaînes, des valeurs booléennes, des listes, des cartes, etc.
Fonctions : les fonctions de Dart sont des citoyens de première classe et peuvent être transmises comme arguments à d'autres fonctions et comme valeurs de retour. Les fonctions peuvent avoir des paramètres nommés, des paramètres facultatifs et des paramètres par défaut.
Classes et objets : Dart est un langage orienté objet qui prend en charge les concepts de classes et d'objets. Une classe est un modèle pour un objet et définit ses propriétés et méthodes. Les objets sont des instances d'une classe et peuvent être créés via des constructeurs.
Héritage et polymorphisme : Dart prend en charge l'héritage de classe. Une classe peut hériter des propriétés et des méthodes d'une autre classe. Grâce à l'héritage, le code peut être réutilisé et étendu. Dart prend également en charge le polymorphisme, permettant de référencer les objets des sous-classes à l'aide des références des classes parentes.
Interface : Une interface dans Dart est une convention qui définit les méthodes qu'une classe doit implémenter. Les classes de Dart peuvent implémenter une ou plusieurs interfaces pour réaliser le polymorphisme et la réutilisation du code.
Programmation asynchrone : Dart prend en charge la programmation asynchrone. L'utilisation des mots-clés async et wait permet de gérer facilement les opérations asynchrones, telles que les requêtes réseau, la lecture et l'écriture de fichiers, etc. Les opérations asynchrones dans Dart peuvent être des fonctions Future, Stream ou asynchrones personnalisées.
Gestion des exceptions : la gestion des exceptions dans Dart utilise des instructions try-catch pour intercepter et gérer les exceptions. Des types spécifiques d'exceptions peuvent être interceptés et la logique de traitement correspondante exécutée selon les besoins.
Génériques : Dart prend en charge les génériques, qui peuvent être utilisés dans les classes, les fonctions et les interfaces pour augmenter la flexibilité et la réutilisabilité du code. Les génériques permettent de spécifier les paramètres de type au moment de la compilation.
Mixins : les mixins dans Dart sont un mécanisme de réutilisation de code qui permet d'injecter un ensemble de méthodes et de propriétés dans une classe pour améliorer ses fonctionnalités sans avoir besoin d'héritage.
Introduction et importation : dans Dart, vous pouvez utiliser le mot-clé import pour introduire d'autres fichiers ou bibliothèques Dart, et utiliser le mot-clé export pour exporter le contenu du fichier actuel vers d'autres fichiers à utiliser.
Tout ce qui est stocké dans une variable est un objet et tous les objets sont des instances d'une classe correspondante . Les nombres, les fonctions et nullsont des objets. Tous les objets héritent de la classe Object.
Bien que Dart soit fortement typé, Dart peut déduire des types, les annotations de type sont donc facultatives. Si vous souhaitez indiquer explicitement qu'aucun type n'est requis, [vous devez utiliser un type spécial dynamic] .
Dart prend en charge les génériques comme List <int>(liste d'entiers) ou List <dynamic>(liste d'objets de tout type).
Dart prend en charge les fonctions de niveau supérieur (ces fonctions ne sont pas encapsulées dans une classe ou un objet, toutes les applications ont au moins une fonction de niveau supérieur, par exemple), ainsi que les fonctions main（）liées à des classes ou à des objets ( fonctions statiques et fonctions d'instance respectivement ) . . Et prise en charge de la création de fonctions au sein de fonctions ( fonctions imbriquées ou locales ).
De même, Dart prend en charge les variables de niveau supérieur , ainsi que les variables liées à des classes ou à des objets (variables statiques et variables d'instance). Les variables d'instance sont parfois appelées champs ou propriétés.
Contrairement à Java, Dart ne possède pas les mots-clés « public », « protégé » et « privé ». Si un identifiant commence par un trait de soulignement (_), il est privé par rapport à la bibliothèque.
Les identifiants commencent par une lettre ou un trait de soulignement (_), suivi de toute combinaison de lettres et de chiffres.

Apprentissage de la syntaxe Dart

variable

//这里会类型推断出是String类型，（使用var定义的变量值可以被修改）
var name = "Bob";

//也可显示指定变量类型
String name = "Bob";

//使用过程中从来不会被修改的变量， 可以使用 final 或 const定义。final修饰的值只能设置一次，可以理解为final修饰的变量是不可改变的，而const修饰的表示一个常量。
final name = 'Bob';
const bar = 1000000; // 压力单位 (dynes/cm2)

//final，const区别
区别一：final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且赋值必需为编译时常量。区别二：final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。

types intégrés

Le langage Dart prend en charge les types intégrés suivants :
Nombre
Chaîne Liste
booléenne
(également appelée tableau) Ensemble
de cartes Rune (utilisée pour représenter les caractères Unicode dans les chaînes) Symbole

Nombre

Il existe deux types de nombres dans le langage Dart : la double
chaîne entière et les nombres peuvent être convertis les uns dans les autres.

// String -> int
var one = int.parse('1');
assert(one == 1);

// String -> double
var onePointOne = double.parse('1.1');
assert(onePointOne == 1.1);

// int -> String
String oneAsString = 1.toString();
assert(oneAsString == '1');

// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');

Chaîne

var s1 = 'hello';
var s2 = 'world';

//字符串可以通过 ${expression} 的方式内嵌表达式
print("${s1}");

//可以使用 + 运算符来把多个字符串连接为一个
print('${s1  + s2}');
print(s1 + s2);

Booléen

La sécurité des types de Dart signifie que vous ne pouvez pas utiliser if (nonbooleanValue) ou assert (nonbooleanValue). Au lieu de cela, vous devez vérifier explicitement la valeur comme ceci :

// 检查空字符串。
var fullName = '';
assert(fullName.isEmpty);

// 检查 0 值。
var hitPoints = 0;
assert(hitPoints <= 0);

// 检查 null 值。
var unicorn;
assert(unicorn == null);

// 检查 NaN 。
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

Liste

//定义一个List
var list = [1, 2, 3];
//获取list长度
print(list.length);
print(list.isEmpty);
print(list.isNotEmpty);
//倒序
print(list.reversed.toList());
//修改
print(list.fillRange(1,2,'hah'));//打印[1,hah,3]。
//获取指定下表的元素
list[1] = 1;

Ensemble

(Il s'agit d'une collection non ordonnée et non répétitive, la valeur ne peut donc pas être obtenue via l'index.)

// Set<String> names = {}; // 这样也是可以的。
// var names = {}; // 这样会创建一个 Map ，而不是 Set 。
var names = <String>{};
//添加元素
names.add('fluorine');
//获取Set长度
print(names.length);

Carte

var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

//或
var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

Symbole

Un objet Symbol représente un opérateur ou un identifiant déclaré dans un programme Dart. Vous n'aurez peut-être jamais besoin d'utiliser Symbol, mais cela s'avère très utile lorsque vous souhaitez faire référence à une API par son nom pour un identifiant. Car le nom de l'identifiant sera modifié après compression du code, mais le symbole de l'identifiant ne sera pas modifié. Obtenez le symbole de l'identifiant via le symbole littéral, c'est-à-dire en ajoutant un signe # devant l'identifiant.

#radix
#bar

fonction

//示例
bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}
//当函数中只有一句表达式，可以使用简写语法（也叫箭头语法）
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

Type de paramètre (paramètre facultatif, paramètre obligatoire)

//可选参数可以是命名参数或者位置参数，但一个参数只能选择其中一种方式修饰。
//命名参数
enableFlags(bold: true, hidden: false);
//位置可选参数，将参数放到 [] 中来标记参数是可选的
String say(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

fonction comme argument d'une autre fonction

void printElement(int element) {
  print(element);
}
var list = [1, 2, 3];
// 将 printElement 函数作为参数传递。
list.forEach(printElement);

fonction anonyme

La plupart des fonctions ont des noms, tels que main() et printElement(). Vous pouvez également créer des fonctions sans nom, appelées fonctions anonymes.

var list = ['apples', 'bananas', 'oranges'];
list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});

opérateur

opérateurs arithmétiques

//稍有不同的
assert(5 / 2 == 2.5); // 结果是双浮点型
assert(5 ~/ 2 == 2); // 结果是整型
assert(5 % 2 == 1); // 余数

Opérateurs relationnels

== != > < >= <=

opérateur de détermination de type

Les opérateurs as, is et is! sont utilisés pour gérer la vérification de type au moment de l'exécution.
L'opérateur is est utilisé pour déterminer si une variable est un certain type de données.
is! est pour déterminer si la variable n'est pas un certain type de données.
Utilisez l'opérateur as pour forcer l'objet à un type spécifique. Généralement, il peut être considéré comme une abréviation de la fonction appelée par l'objet déterminé après la détermination du type is.

if (emp is Person) {
  // Type check
  emp.firstName = 'Bob';
}
//使用 as 运算符进行缩写：
(emp as Person).firstName = 'Bob';

opérateur d'assignation

Utilisez = pour attribuer une valeur à une variable. Lors de l'utilisation de l'opérateur ??=, une valeur est attribuée à la variable affectée uniquement si elle est nulle.

// 将值赋值给变量a
a = value;
// 如果b为空时，将变量赋值给b，否则，b的值保持不变。
b ??= value;

Opérateurs logiques

et ou pas

Opérateurs de bits et de décalage

Dans Dart, vous pouvez manipuler indépendamment les bits individuels d’un nombre. Normalement, les types entiers sont manipulés à l’aide d’opérateurs au niveau du bit et de décalage.
& | ^ ~expr << >>

final value = 0x22;
final bitmask = 0x0f;

assert((value & bitmask) == 0x02); // AND
assert((value & ~bitmask) == 0x20); // AND NOT
assert((value | bitmask) == 0x2f); // OR
assert((value ^ bitmask) == 0x2d); // XOR
assert((value << 4) == 0x220); // Shift left
assert((value >> 4) == 0x02); // Shift right

expression conditionnelle

condition ? expr1 : expr2
Si la condition est vraie, exécute expr1 (et renvoie sa valeur) : Sinon, exécute et renvoie la valeur de expr2.
expr1 ?? expr2
Si expr1 est non nul, renvoie la valeur de expr1 ; sinon, exécute et renvoie la valeur de expr2.

Opérateur en cascade(..)

L'opérateur en cascade (..) peut effectuer une série d'opérations sur le même objet. En plus d'appeler des fonctions, vous pouvez également accéder aux propriétés de champ sur le même objet. Cela évite souvent l’étape de création de variables temporaires et aboutit à un code plus fluide.

querySelector('#confirm') // 获取对象。
  ..text = 'Confirm' // 调用成员变量。
  ..classes.add('important')
  ..onClick.listen((e) => windnow.alert('Confirmed!'));
//等价于下面的代码
var button = querySelector('#confirm');
button.text = 'Confirm';
button.classes.add('important');
button.onClick.listen((e) => window.alert('Confirmed!'));
//级联运算符还可嵌套
final addressBook = (AddressBookBuilder()
      ..name = 'jenny'
      ..email = '[email protected]'
      ..phone = (PhoneNumberBuilder()
      ..number = '415-555-0100'
      ..label = 'home')
      .build()).build();

Rappeler

Dans Flutter, vous pouvez utiliser des fonctions de rappel pour gérer la valeur de retour d'un événement ou le résultat d'une opération asynchrone. Voici un exemple simple montrant comment utiliser les fonctions de rappel dans Flutter

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Callback Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(
        title: 'Callback Demo',
      ),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _result = '';

  void _showResult(String result) {
    setState(() {
      _result = result;
    });
  }

  void _doSomething() {
    // 模拟一个耗时操作
    Future.delayed(Duration(seconds: 2), () {
      String result = '操作完成';
      _showResult(result);
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            RaisedButton(
              onPressed: _doSomething,
              child: Text('执行操作'),
            ),
            SizedBox(height: 20),
            Text(
              _result,
              style: TextStyle(fontSize: 20),
            ),
          ],
        ),
      ),
    );
  }
}

Dans cet exemple, nous avons créé une application Flutter simple contenant un bouton et une zone de texte. Lorsque l'utilisateur clique sur le bouton, une opération fastidieuse est effectuée et le résultat de l'opération est transmis à la page principale via la fonction de rappel. Ensuite, nous utilisons setStatela méthode pour mettre à jour la zone de texte sur l'interface pour afficher les résultats de l'opération.

Dans _MyHomePageStatela classe, nous définissons une _showResultméthode de mise à jour des résultats de l'opération. Ensuite, dans _doSomethingla méthode, nous utilisons Future.delayedpour simuler une opération fastidieuse et appelons _showResultla méthode pour mettre à jour l'interface une fois l'opération terminée.