Flutter learning (dos) entrada de ejecución | variable | constante | tipo de datos | operador | control de proceso | palabra clave

Este capítulo aprende principalmente: métodos de entrada de dardos, variables, comentarios, constantes, tipos de datos

• Configuración de herramientas de desarrollo y construcción de entornos de Flutter Learning (1)
• Flutter learning (dos) entrada de ejecución | variable | constante | tipo de datos | operador | control de proceso | palabra clave

1. Entrada de ejecución

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

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

2. Variables

2.1 Cuerda

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

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

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

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

2.2 int (entero)

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

2.3 doble (decimal)

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

  double d2 = 1.0;
  print(d2);

2.4 bool (booleano)

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

  bool b2 = false;
  print(b2);

2.5 Lista (colección)

  // 未初始化，默认值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 Mapa (Diccionario)

  // 未初始化，默认值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 | Objeto | dinámico (tipo dinámico)

  // 定义变量，没有明确类型，编译的时候根据值明确类型  
  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. Operadores

descripción	Operador
Operador de poste unario	expr++ expr-- () [] . ?.
Preoperador unario	expr !expr ~expr ++expr --expr
Multiplica y divide	* / % ~/
Adición y sustracción	+ -
Desplazamiento	<< >>
Bitwise y	Y
Bit a bit o
XOR bit a bit	^
Lógico y	&&
OR lógico
Relación y juicio de tipo	>= > <= < as is is!
Espere	== !=
Si esta vacio	??
Expresión condicional	expr1 ? expr2 : expr3
Asignación	= *= /= ~/= %= += -= <<= >>= &= ^= = ??=
cascada	..

5. Control de procesos

• si ... si no
• para
• mientras do-whild
• romper continuar
• interruptor ... caso
• afirmar (solo válido en modo marcado)

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('我是默认');
  }

Nota:

rotura

1. Utilice el flujo en la declaración del interruptor para saltar fuera de la estructura del interruptor.
2. En la instrucción de bucle, el proceso salta del bucle actual. Cuando el bucle de interrupción finaliza, el siguiente código no se ejecutará.
3. Si la sentencia breck se ha ejecutado en el bucle, no se ejecutará la sentencia posterior a la breck en el cuerpo del bucle.
4. En un bucle de varios niveles, una declaración de interrupción solo puede saltar un nivel fuera.
5. Break se puede usar en la caja del interruptor, también se puede usar en for loop y while loop

Seguir

1. Solo se puede usar en una instrucción de bucle para finalizar el bucle, es decir, omitir la instrucción no ejecutada debajo del cuerpo del bucle.
2. continue se puede usar en bucles for y while, pero no se recomienda usar en bucles while, porque es fácil de realizar.

6. Palabras clave

Palabra clave	-	-	-
abstracto	hacer	importar	súper
como	dinámica	en	cambiar
afirmar	más	interfaz	sincronizar *
enumeración	implementos	es	esta
asincrónico *	exportar	biblioteca	lanzar
esperar	externo	mezclando	cierto
rotura	extiende	nuevo	tratar
caso	fábrica	nulo	typedef
captura	falso	operador	dónde
clase	final	parte	vacío
constante	finalmente	volver a lanzar	mientras
Seguir	para	regreso	con
covariante	obtener	conjunto	rendimiento*
defecto	Si	estático	diferido