数据类型¶

变量常量¶

使用var声明变量，可以赋值不同的类型 var声明的变量如果没有初始化，那么他的值为nil

var a;
print(a); //null
a = 'hello haha';
print(a); //hello haha
a = 10;
print(a + 10); //20

const¶

const常量声明的时候，必须有初始值。

  const d = 20;
  // d = 20;

数值型Number：int & double¶

  num a = 10;
  print(a); //10
  a = 10.5;
  print(a); //10.5

  int b = 8;
  print(b.isEven); //偶数 true
  print(b.isOdd); //奇数  false

  //算术运算符 + - * / % ～/（取整）

  //转换类型
  print(a.toInt().isEven);
  print(b.toDouble());

字符串¶

使用单引号和双引号创建三个引号或双引号创建多行字符串

  var str1 = 'hank';
  var str2 = "cooci"
      "hah\n"
      "kody";
  print(str1[1]); //a
  print(str1 * 2); //hankhank

  ///hankcoocihah
  /// kody
  print(str1 + str2);

  var c = '''LG
  miao
  lll
  kkk''';
  print(c);

  int a = 10;
  int b = 20;
  print('a + b = ${a + b}'); //a + b = 30

  String str3 = "jjjjjj\nkkkkk";
  String str4 = r"jjjjjj \nkkkkk";
  print(str3);
  print(str4); //jjjjjj \nkkkkk

List¶

  var list1 = [1, 2, 3]; //可变
  var list2 = const [1, 2, 3, 'hak']; //不可变
  list2.add('kody');
  list2.insert(1, 'cat');
  list2.removeAt(1);

  //排序
  var list4 = [1, 3, 4, 6, 2, 7];
  list4.sort();
  print(list4.sublist(2, 4));

generate生成构造函数创建List¶

final List months = ['01','02','03','04','05','06','07','08','09','10','11','12'];

以下是一个简化的版本：

final List<String> months = List.generate(12, (index) => index < 9 ? '0${index + 1}' : '${index + 1}');

List.generate构造函数来生成一个长度为12的列表。它接受两个参数：第一个是列表的长度，第二个是一个函数，该函数根据当前的索引来返回列表中的每个元素。这里，我们检查索引值（从0开始），如果索引小于9（对应月份1到9），我们在数字前面添加一个0，否则直接转换数字为字符串。由于索引从0开始，我们通过index + 1来得到正确的月份数字。

数组遍历¶

for-in 循环：

List<int> list = [1, 2, 3, 4, 5];
for (var item in list) {
  print(item);
}

标准的 for 循环：

List<int> list = [1, 2, 3, 4, 5];
for (var i = 0; i < list.length; i++) {
  print(list[i]);
}

forEach 方法：

List<int> list = [1, 2, 3, 4, 5];
list.forEach((item) {
  print(item);
});

map 方法（对数组的每个元素进行操作并返回一个新的数组）：

List<int> list = [1, 2, 3, 4, 5];
List<int> newList = list.map((item) {
  return item * 2;  // 对每个元素进行操作
}).toList();  // 转换回 List
print(newList);  // 输出 [2, 4, 6, 8, 10]

Map¶

键值对，字典。

在Dart（和Flutter）中，Map<dynamic, dynamic>是一种数据类型，表示一个map，其键（key）和值（value）可以是任何类型的对象。

在这个类型中，Map是一种数据结构，用于存储键值对，类似于其他编程语言中的字典（Python）或对象（JavaScript）。

dynamic是Dart的一个特殊类型，表示“任何类型”。因此，Map<dynamic, dynamic>可以存储任何类型的键值对。

Map<dynamic, dynamic> myMap = {
  'key1': 'value1',
  2: 3.14,
  true: ['a', 'b', 'c'],
};

在这个示例中，第一对键值是字符串，第二对是整数和浮点数，第三对是布尔值和字符串列表。这就是Map<dynamic, dynamic>的灵活性。

尽管Map<dynamic, dynamic>非常灵活，但在实际编程中，我们通常会指定更具体的类型，例如Map<String, int>或Map<String, List<String>>。这样可以提供更好的类型安全性，帮助我们避免类型错误，并让我们的代码更易于理解和维护。

//初始化
Map<dynamic, dynamic> options = {};

///可变 
var map1 = {'one':'kank','two':'colos'};
///不可变 
var map1 = const {'one':'kank','two':'colos'};

print(json1['one']);
json1['one'] = 'newKk';
//数组转map
var list = ['hank', 'cooci', 'cat'];
print(list.asMap()); //{0: hank, 1: cooci, 2: cat}

Map不保证键和值的顺序。如果需要保证顺序，可以使用LinkedHashMap，它按照插入的顺序保存键和值，可以按顺序迭代键和值。

高阶函数map¶

map.entries返回一个包含Map中所有键值对的Iterable对象，每个键值对都是一个MapEntry对象。

map((entry) {})是一个高阶函数。它对Iterable中的每个元素执行一个函数并返回一个新的Iterable。这个函数接受一个参数（在此例中是entry），它是Iterable中的一个元素，然后返回一个新的值。

map.entries.map((entry) {})对Map中的每个键值对执行一个函数。这个函数接受一个MapEntry（在此例中是entry）。map.entries.map((entry) {}).toList()遍历Map中每一个键值对，返回一个List。

这是一个简单的例子来解释map函数的工作原理：

List<int> numbers = [1, 2, 3, 4, 5];
List<int> squares = numbers.map((number) => number * number).toList();

print(squares);  // Prints: [1, 4, 9, 16, 25]

在这个例子中，numbers.map((number) => number * number).toList()对numbers列表中的每个元素执行一个函数（这个函数返回元素的平方），然后返回一个新的列表。

Set¶

//创建集合
var name1 = Set<String>();
var name1 = <String>{};
Set<String> types = {};

判断类型¶

使用is关键字来检查一个变量是否为特定的数据类型。

var myVariable = 10.0;

if (myVariable is double) {
  print('变量是double类型');
} else {
  print('变量不是double类型');
}

任意类型¶

使用 dynamic 类型或者 Object? 类型。dynamic 类型是 Dart 中所有类型的基础，可以在运行时代表任何类型的值。而 Object? 类型是所有非空类型的基类，并且加上问号（?）表示它可以是 null。

使用 dynamic 和 Object? 时要小心，因为它们会绕过静态类型检查。这意味着编译器不会在编译时期报告类型错误，而是会在运行时出现类型错误，这可能导致运行时异常。

建议只在确实需要处理不确定类型时才使用这些类型，并尽可能地使用明确的类型来提高代码的安全性和可维护性。