Aprendizaje rápido con Flutter (2)

Dart es un lenguaje de programación informático desarrollado por Google que se utiliza para el desarrollo de web, servidores, aplicaciones móviles e Internet de las cosas. Dart es un lenguaje de herencia única, definido por clases y orientado a objetos.

Algunos conceptos importantes de Dart

Variables y tipos de datos: Dart es un lenguaje fuertemente tipado, las variables necesitan declarar tipos explícitamente o utilizar inferencia de tipos. Dart admite una variedad de tipos de datos, incluidos números, cadenas, valores booleanos, listas, mapas, etc.
Funciones: Las funciones en Dart son ciudadanas de primera clase y pueden pasarse como argumentos a otras funciones y como valores de retorno. Las funciones pueden tener parámetros con nombre, parámetros opcionales y parámetros predeterminados.
Clases y objetos: Dart es un lenguaje orientado a objetos que admite los conceptos de clases y objetos. Una clase es un modelo para un objeto y define sus propiedades y métodos. Los objetos son instancias de clases y se pueden crear mediante constructores.
Herencia y polimorfismo: Dart admite la herencia de clases: una clase puede heredar las propiedades y métodos de otra clase. Mediante la herencia, el código se puede reutilizar y ampliar. Dart también admite el polimorfismo, lo que permite hacer referencia a objetos de subclases utilizando referencias de clases principales.
Interfaz: una interfaz en Dart es una convención que define los métodos que una clase debe implementar. Las clases en Dart pueden implementar una o más interfaces para lograr polimorfismo y reutilización de código.
Programación asincrónica: Dart tiene soporte incorporado para la programación asincrónica. El uso de las palabras clave async y await puede manejar fácilmente operaciones asincrónicas, como solicitudes de red, lectura y escritura de archivos, etc. Las operaciones asincrónicas en Dart pueden ser funciones asincrónicas Future, Stream o personalizadas.
Manejo de excepciones: el manejo de excepciones en Dart utiliza declaraciones try-catch para detectar y manejar excepciones. Se pueden detectar tipos específicos de excepciones y ejecutar la lógica de procesamiento correspondiente según sea necesario.
Genéricos: Dart admite genéricos, que se pueden usar en clases, funciones e interfaces para aumentar la flexibilidad y la reutilización del código. Los genéricos permiten especificar parámetros de tipo en tiempo de compilación.
Mixins: Los mixins en Dart son un mecanismo de reutilización de código que permite inyectar un conjunto de métodos y propiedades en una clase para mejorar su funcionalidad sin necesidad de herencia.
Introducción e importación: en Dart, puede usar la palabra clave import para introducir otros archivos o bibliotecas de Dart y usar la palabra clave export para exportar el contenido del archivo actual a otros archivos para su uso.
Todo lo almacenado en una variable es un objeto , y todos los objetos son instancias de una clase correspondiente . Ambos números, funciones y nullson objetos. Todos los objetos heredan de la clase Objeto.
Aunque Dart está fuertemente tipado, Dart puede inferir tipos, por lo que las anotaciones de tipo son opcionales. Si desea indicar explícitamente que no se requiere ningún tipo, [necesita utilizar un tipo especial dynamic].
Dart admite genéricos como List <int>(lista de números enteros) o List <dynamic>(lista de objetos de cualquier tipo).
Dart admite funciones de nivel superior (estas funciones no están encapsuladas en una clase u objeto, todas las aplicaciones tienen al menos una función de nivel superior, por ejemplo), así como funciones main（）vinculadas a clases u objetos ( funciones estáticas y funciones de instancia respectivamente ) . . Y soporte para crear funciones dentro de funciones ( funciones anidadas o locales ).
De manera similar, Dart admite variables de nivel superior , así como variables vinculadas a clases u objetos (variables estáticas y variables de instancia). Las variables de instancia a veces se denominan campos o propiedades.
A diferencia de Java, Dart no tiene las palabras clave "público", "protegido" y "privado". Si un identificador comienza con un guión bajo (_), es privado en relación con la biblioteca.
Los identificadores comienzan con una letra o un guión bajo (_), seguido de cualquier combinación de letras y números.

Aprendizaje de sintaxis de dardos

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 是在编译时就确定值了。

tipos incorporados

El lenguaje Dart admite los siguientes tipos integrados: Cadena numérica
Lista booleana (también conocida como matriz) Conjunto de mapas Runa (utilizada para representar caracteres Unicode en cadenas) Símbolo

Número

Hay dos tipos de números en el lenguaje Dart:
cadena doble int y los números se pueden convertir entre sí.

// 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');

Cadena

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

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

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

Booleano

La seguridad de tipos de Dart significa que no puedes usar if (nonbooleanValue) o afirmar (nonbooleanValue). En su lugar, deberías comprobar explícitamente el valor de esta manera:

// 检查空字符串。
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);

Lista

//定义一个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;

Colocar

(Es una colección desordenada y que no se repite, por lo que el valor no se puede obtener a través del índice).

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

Mapa

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

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

Símbolo

Un objeto Símbolo representa un operador o identificador declarado en un programa Dart. Es posible que nunca necesites usar Symbol, pero es muy útil cuando deseas hacer referencia a una API por su nombre para obtener un identificador. Porque el nombre del identificador se cambiará después de la compresión del código, pero el símbolo del identificador no se cambiará. Obtenga el símbolo del identificador a través del símbolo literal, es decir, agregando un signo # delante del identificador.

#radix
#bar

función

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

Tipo de parámetro (parámetro opcional, parámetro requerido)

//可选参数可以是命名参数或者位置参数，但一个参数只能选择其中一种方式修饰。
//命名参数
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;
}

funcionar como argumento de otra función

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

función anónima

La mayoría de las funciones tienen nombres, como main() y printElement(). También puedes crear funciones sin nombre, que se denominan funciones anónimas.

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

operador

operadores aritméticos

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

Operadores relacionales

== != > < >= <=

operador de determinación de tipo

Los operadores as, is y is! se utilizan para manejar la verificación de tipos en tiempo de ejecución.
El operador is se utiliza para determinar si una variable es un determinado tipo de datos.
is! es para determinar si la variable no es un determinado tipo de datos.
Utilice el operador as para forzar el objeto a un tipo específico. Generalmente, puede considerarse como una abreviatura de la función llamada por el objeto determinado después de la determinación de su tipo.

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

operador de asignación

Utilice = para asignar un valor a una variable. Cuando se utiliza el operador ??=, se asigna un valor a la variable que se asigna solo si es nula.

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

Operadores logicos

y o no

Operadores bit a bit y de turno

En Dart, puedes manipular bits individuales de un número de forma independiente. Normalmente, los tipos de números enteros se manipulan mediante operadores bit a bit y de desplazamiento.
& | ^ ~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

expresión condicional

condición ?expr1 : expr2
Si la condición es verdadera, ejecute expr1 (y devuelva su valor): De lo contrario, ejecute y devuelva el valor de expr2.
expr1 ?? expr2
Si expr1 no es nulo, devuelve el valor de expr1; en caso contrario, ejecuta y devuelve el valor de expr2.

Operador en cascada(..)

El operador en cascada (..) puede realizar una serie de operaciones sobre el mismo objeto. Además de llamar a funciones, también puede acceder a las propiedades de los campos en el mismo objeto. Esto a menudo ahorra el paso de crear variables temporales y da como resultado un código más fluido.

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();

Llamar de vuelta

En Flutter, puedes usar funciones de devolución de llamada para manejar el valor de retorno de un evento o el resultado de una operación asincrónica. Aquí hay un ejemplo simple que muestra cómo usar funciones de devolución de llamada en 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),
            ),
          ],
        ),
      ),
    );
  }
}

En este ejemplo, creamos una aplicación Flutter simple que contiene un botón y un cuadro de texto. Cuando el usuario hace clic en el botón, se realiza una operación que requiere mucho tiempo y el resultado de la operación se pasa a la página principal a través de la función de devolución de llamada. Luego, usamos setStateel método para actualizar el cuadro de texto en la interfaz para mostrar los resultados de la operación.

En _MyHomePageStatela clase, definimos un _showResultmétodo para actualizar los resultados de la operación. Luego, en _doSomethingel método, utilizamos Future.delayedpara simular una operación que requiere mucho tiempo y llamamos _showResultal método para actualizar la interfaz una vez completada la operación.