Flutter learning (deux) entrée d'exécution | variable | constante | type de données | opérateur | contrôle de processus | mot-clé

Ce chapitre apprend principalement: les méthodes d'entrée de Dart, les variables, les commentaires, les constantes, les types de données

• Configuration de l'outil de construction et de développement d'environnement Flutter Learning
• Flutter learning (deux) entrée d'exécution | variable | constante | type de données | opérateur | contrôle de processus | mot-clé

1. Saisie d'exécution

// 无返回值入口方法
void main() {
  // 打印
   print('helloWorld');
}

main() {
  // 打印
  print('helloWorld');
}

2. Variables

2.1 Chaîne

  // 未初始化，默认值null
  String str;
  print(str);

  // 字符串定义
  String s1 = 'helloWorld';
  print(s1);

  String s2 = '222';
  // 字符串拼接
  print(s1 + s2);

  //
  String s3 = '''你好，
  我们一起学习Dart ''';
  print(s3);

2,2 entier (entier)

  // 未初始化，默认值null
  int n1;
  print(n1);
  
  int n2 = 100;
  print(n2);

2,3 double (décimal)

  // 未初始化，默认值null
  double d1;
  print(d1);

  double d2 = 1.0;
  print(d2);

2.4 booléen (booléen)

  // 未初始化，默认值null
  bool b1;
  print(b1);

  bool b2 = false;
  print(b2);

2.5 Liste (collection)

  // 未初始化，默认值null
  List list;
  print(list);
  
  //创建一个int类型的list
  List list1 = [1, 2, 3];
  // 输出[1, 2, 3]
  print(list1);

  // 使用List的构造函数
  List list2 = new List();
  //添加单个元素
  list2.add(1);
  //添加多个元素
  list2.addAll([2, 3, 4, 5]);
  print(list2);
  // 获取集合长度
  print(list2.length);
  // / 获取第一个元素
  print(list2.first);
  // 获取元素最后一个元素
  print(list2.last);
  // 利用索引获取元素
  print(list2[0]);
  // 查找某个元素的索引号
  print(list2.indexOf(2));
  // 删除指定位置的元素，返回删除的元素
  print(list2.removeAt(0));
  // 删除指定元素,成功返回true，失败返回false
  // 如果集合里面有多个2, 只会删除集合中第一个改元素
  list2.remove(2);
  // 删除最后一个元素，返回删除的元素
  list2.removeLast();
  // 删除指定范围(索引)元素，含头不含尾
  list2.removeRange(0, 1);
  // 删除指定条件的元素(这里是数字大于2)
  list2.removeWhere((item) => item > 2);
  // 删除所有的元素
  list2.clear();
  print(list2);

  // 限定list的长度添加int参数，表示List固定长度，不能进行添加 删除操作
  List list3 = new List(1);
  // null
  print(list3[0]);
  // [null]
  print(list3);

2.6 Carte (dictionnaire)

  // 未初始化，默认值null
  Map map;
  print(map);

  //创建一个map
  Map map1 = {'key': '0', 'value': '1'};
  // {key: 0, value: 1}
  print(map1);

  //先声明一个map，再赋值
  Map map2 = new Map();
  map2['key'] = '0';
  map2['value'] = '1';
  // {key: 0, value: 1}
  print(map2);

  // 指定键值对参数类型
  var map3 = new Map<int, String>();
  // Map的赋值，中括号中是Key，这里可不是数组
  map3[1] = '123';
  //Map中的键值对是唯一的Key如果存在，Value会覆盖之前的数据
  map3[1] = '321';
  // map里面的value可以相同
  map3[2] = '123';
  // map里面value可以为空字符串
  map3[3] = '';
  // map里面的value可以为null
  map3[4] = null;
  print(map3);
  // 查看Map是否含有某Key
  print(map3.containsKey(1));
  //删除某个键值对
  map3.remove(1);
  print(map3);

2.7 var | Object | dynamic (type dynamique)

  // 定义变量，没有明确类型，编译的时候根据值明确类型  
  var str1 = 'helloWorld';
  Object str2 = '张三';
  dynamic str3 = '李四';
  print(str1);
  print(str2);
  print(str3);

3. Constante

  // 使用final 或者 const 定义时就必须初始化,并且值只能设置一次
  final String str = '1';
  const String str2 = '2';

  //无法再次赋值 The final variable 'str' can only be set once
  // str = '3';
  // str2 = '3';

  //flnal 或者 const 不能和 var 同时使用
  // final var str3= '3';
  // const var str3= '3';

4. Opérateurs

la description	Opérateur
Opérateur de poste unaire	expr++ expr-- () [] . ?.
Pré-opérateur unaire	expr !expr ~expr ++expr --expr
Multipliez et divisez	* / % ~/
Addition et soustraction	+ -
Déplacement	<< >>
Bitwise et	&
Bitwise ou
XOR au niveau du bit	^
Logique et	&&
OU logique
Relation et jugement de type	>= > <= < as is is!
Attendre	== !=
Si vide	??
Expression conditionnelle	expr1 ? expr2 : expr3
Affectation	= *= /= ~/= %= += -= <<= >>= &= ^= = ??=
Cascade	..

5. Contrôle de processus

• sinon
• pour
• tandis que faire-whild
• pause continue
• interrupteur ...
• assert (uniquement valide en mode vérifié)

int i = 0;
  // 单独一个条件
  if (i == 0) {
    print('i==0');
  }
  // 对立条件
  if (i != 0) {
    print('i!=0');
  } else {
    print('i==0');
  }
  // 多条件
  if (i > 0) {
    print('i>0');
  } else if (i < 0) {
    print('i<0');
  } else {
    print('i==0');
  }

  // 循环
  for (int j = 0; j < i; j++) {
    print(j);
  }

  for (int j = 1; j <= 100; j++) {
    if (j == 100) {
      // 退出循环
      break;
    }
    if (j % 2 != 0) {
      // 跳过接下来的操作
      continue;
    }
    print(j);
  }

  // 循环
  while (i == 0) {
    i += 1;
  }

  // 不管while里的条件是否满足，都会先执行一次方法体
  do {
    i += 1;
    print('i==0');
  } while (i == 0);

  //
  switch (i) {
    case 1:
      print('我是1');
      break;
    case 2:
      print('我是2');
      break;
    default:
      print('我是默认');
  }

Remarque:

Pause

1. Utilisez le flux de l'instruction switch pour sortir de la structure du switch.
2. Dans l'instruction de boucle, le processus saute hors de la boucle actuelle. Lorsque la boucle d'interruption est terminée, le code suivant ne sera pas exécuté.
3. Si l'instruction breck a été exécutée dans la boucle, l'instruction après le breck dans le corps de la boucle ne sera pas exécutée.
4. Dans une boucle à plusieurs niveaux, une instruction break ne peut sauter qu'un niveau à l'extérieur.
5. Break peut être utilisé dans le cas de commutateur, peut également être utilisé dans la boucle for et while loop

continuer

1. Il ne peut être utilisé que dans une instruction de boucle pour terminer la boucle, c'est-à-dire ignorer l'instruction non exécutée sous le corps de la boucle.
2. continue peut être utilisé dans les boucles for et while, mais il n'est pas recommandé d'utiliser les boucles while, car il est facile de boucler.

6. Mots clés

Mot-clé	-	-	-
abstrait	faire	importer	super
comme	dynamique	dans	commutateur
affirmer	autre	interface	synchronisation *
énumération	met en oeuvre	est	cette
asynchrone *	exportation	bibliothèque	jeter
attendre	externe	mixin	vrai
Pause	étend	Nouveau	essayer
Cas	usine	nul	typedef
capture	faux	opérateur	où
classe	final	partie	néant
const	enfin	repousser	tandis que
continuer	pour	revenir	avec
covariant	avoir	ensemble	rendement*
défaut	si	statique	différé