五：Flutter之Dart第二节？

1: 数据类型

1.1: 数字类型

对于数值来说、我们也不用关心它是否有符号、以及数据的宽度和精度等问题、只要急着整数用int、浮点数用double就行了。

不过要说明一下Dart中的int和double可表示的范围并不是固定的、它取决于运行Dart的平台。

1: 整数类型int
int age = 18;
int hexAge = 0x12;
print(age);
print('hexAge');

2: 浮点数类型double
double height = 1.88;
print(height);

1.1.1: 字符串和数字之间的转化:

1: 字符串转数字
var one = int.parse('111');
var two = double.parse('12.22');
print('${one} ${one.runtimeType}');
print('${two} ${two.runtimeType}');

2: 数字转字符串
var num1 = 123;
var num2 = 123.446;
var num1Str = num1.toString();
var num2Str = num2.toString();

-----> 123, String
print('int数字转字符串=${num1Str}, ${num1Str.runtimeType}');

-----> 123.446, String
print('double数字转字符串=${num2Str}, ${num2Str.runtimeType}');

var num2StrD = num2.toStringAsFixed(2);
-----> 保留两位小数, 123.45
print('double转字符串、保留2位小数点=${num2StrD},${num2StrD.runtimeType}'); 

1.2: 布尔类型

布尔类型中、Dart提供了一个bool的类型、取值为true 和 false

var flag = true;
------> 打印布尔类型=true, bool 
print('flag=${flag}, ${flag.runtimeType}');

• 注意⚠️：Dart中不能判断非0即真、或者非空即真
• Dart的类型安全性意味着您不能使用if(非booleanvalue) 或asset(非booleanvalue)之类的代码

Dart中不能判断非0即真、或者非空即真
var message = 'hello world';
 if (message.isNotEmpty) {
   print('message=${message}, length=${message.length}');
 }

错误写法❌
if (message) {
   print('hello world');
}

1.3: 字符串类型

Dart 字符串是UTF-16编码单元的序列。您可以使用单引号或者双引号创建一个字符串：

var s1 = 'hello1';
var s2 = "hello2";
var s3 = 'hello\'Flutter';
var s4 = "hello'Flutter";
--------> s1=hello1, s2=hello2, s3=hello'Flutter, s4=hello'Flutter
print('s1=${s1}, s2=${s2}, s3=${s3}, s4=${s4}');

1.3.1:可以使用三个单引号或者双引号表示多行字符串

var s5 = '''
 \n  哈哈哈
 啊啊啊
 嘿嘿嘿
 乒乒乓乓
 哦哦哦哦
 ''';
 print('s5=${s5}');
----->打印结果： s5=  
 哈哈哈
 啊啊啊
 嘿嘿嘿
 乒乒乓乓
 哦哦哦哦

1.3.2: 字符串和其他变量或表达式拼接：使用${expression}

• 如果表达式是一个标志符、那么{}可以省略

var name0 = 'lishengbing';
 var age0 = 18;
 var height0 = 1.88;
 print('my name is $name0, age is $age0, height is $height0');

 var r = 1;
 print('r=$r');
打印结果:my name is lishengbing, age is 18, height is 1.88
r=1

1.4: 集合类型

1.4.1: 集合类型的定义

对于集合类型，Dart则内置了最常用的三种：List / Set / Map

1.4.1.1: List 可以这样定义:

// List定义
1: 使用类型推导来定义
 var letters = ['a', 'b', 'c', 'd'];
// List类型推导定义=[a, b, c, d], List<String>
print('List类型推导定义=$letters, ${letters.runtimeType}');

 2: 明确指定类型来定义
 List<int> numbers = [1, 2, 3, 4];
 // list明确指定类型定义=[1, 2, 3, 4], List<int>
 print('list明确指定类型定义=${numbers}, ${numbers.runtimeType}');

1.4.1.2: Set 可以这样定义：

• 其实，也就是将 [] 换成 {}就好了
• Set 和 List最大的两个不同就是：Set是无序的、并且元素是不重复的。

// Set定义
1: 使用类型推导来定义
 var letters = {'a', 'b', 'c', 'd'};
------> 打印结果:Set类型推导定义={a, b, c, d}, Set<String>
print('Set类型推导定义=$letters, ${letters.runtimeType}');

 2: 明确指定类型来定义
 Set<int> numbers = {1, 2, 3, 4};
 ------> 打印结果: Set明确指定类型定义={1, 2, 3, 4}, Set<int>
 print('Set明确指定类型定义=${numbers}, ${numbers.runtimeType}');

1.4.1.3: Map 可以这样定义：

• Map 是我们常说的字典类型、它的定义是这样哦！

Map定义，Map也就是我们常说的字典
1: 使用类型推导定义
 var infoMap = {'name': 'lishengbinbg', 'age': 18};
 ----> 打印结果=Map使用类型推导定义={name: lishengbinbg, age: 18}, infoMap.runtimeType=_InternalLinkedHashMap<String, Object>
 print('Map使用类型推导定义=${infoMap}, infoMap.runtimeType=${infoMap.runtimeType}');

2: 明确指定类型定义
  Map<String, Object> info2 = {'height': 1.88, 'address': '上海市浦东新区陆家嘴中心大厦501'};
----> 打印结果=Map明确指定类型定义={height: 1.88, address: 上海市浦东新区陆家嘴中心大厦501}, info2.runtimeType=_InternalLinkedHashMap<String, Object>
 print('Map明确指定类型定义=${info2}, info2.runtimeType=${info2.runtimeType}');

1.4.2: 集合的常见操作

了解了这三个集合的定义方式之后、我们来看一下最基础的公共操作。

第一类：是所有集合都支持获取长度的属性length:

1: 是所有集合都支持获取长度的属性length:
----> 打印结果= letters=4, infoMap=2
 print('letters=${letters.length}, infoMap=${infoMap.length}');

第二类：是添加/删除/包含操作：

• 并且对于List来说、因为它的元素是有序的、它还提供了一个删除指定索引位置上的元素方法

// 集合的常见操作
 // 1: 是所有集合都支持获取长度的属性length:
 // letters=4, infoMap=2
 print('letters=${letters.length}, infoMap=${infoMap.length}');


 // 2: 添加、删除、包含操作
 // 1、2、3、4 -> 1、2、3、4、5
 numbers.add(5);
 print('List-添加操作=${numbers}');

// 1、2、3、4、5 -> 2、3、4、5
numbers.remove(1);
 print('List-删除第一个元素=${numbers}');

 // true
 var result = numbers.contains(3);
 print('List-contains=${result}');

 // 2、3、4、5 -> 2、3、4
 // List 根据index 删除元素，下表也是从0开始
 numbers.removeAt(3);
 print('List-根据index删除指定元素=${numbers}');

 /*
 List-添加操作=[1, 2, 3, 4, 5]
 List-删除第一个元素=[2, 3, 4, 5]
 List-contains=true
 List-根据index删除指定元素=[2, 3, 4]
 */

第三类，是Map的操作

• 由于它有key和value、因此无论是读取值、还是操作，都要明确是基于key的、还是基于value的、或者是基于key/value对的。

 1: 根据key获取value, 
 // 有值：value=lishengbing; 无值：value=null
 var value = infoMap['name'];
 print('value=${value}');

 2: entries=(MapEntry(name: lishengbinbg), MapEntry(age: 18)), type=MappedIterable<String, MapEntry<String, Object>>
 var entries = infoMap.entries;
 print('entries=${entries}, type=${entries.runtimeType}');

 3: 获取所有的keys
 // keys=(name, age), type=_CompactIterable<String>
 var keys = infoMap.keys;
print('keys=${keys}, type=${keys.runtimeType}');

 4: 获取所有的values
 // values=(lishengbinbg, 18), type=_CompactIterable<Object>
 var values = infoMap.values;
 print('values=${values}, type=${values.runtimeType}');

 5: 判断是否包含某个key或者value
 // iskey=true, type=bool
 // isvalue=false, type=bool
 var isKey = infoMap.containsKey('name');
 var isValue = infoMap.containsValue('lishengbing');
 print('iskey=${isKey}, type=${isKey.runtimeType}');
 print('isvalue=${isValue}, type=${isValue.runtimeType}');

 6:根据key删除元素
 // infoMap={age: 18}, dvalue=lishengbinbg, tyep=String
 var dvalue = infoMap.remove('name');
 print('infoMap=${infoMap}, dvalue=${dvalue}, tyep=${dvalue.runtimeType}');