Dart常用数据类型

Dart常用的数据类型有：

Numbers(数值)

• int (整形)
• double (浮点型)

Strings(字符串)

• String (字符串类型)

Booleans(布尔)

• bool (布尔类型)

List(数组)

• 在Dart中，数组是列表对象，所以大多数人只是成它们为列表

Maps(字典 。)

• 通常来讲，Map是一个键值对相对的对象。键和值可以是任何类型的对象

一. Numbers （int、double）

运算符： +、 - 、* 、/ 、~/（取整）、%（取余）

直接使用 / 获得的结果是长除法的结果 ,
而使用 ~/ 获得的结果是短除法中的商,
而是用 % 就是取余数的操作了

常用的属性：

isEven  表示这个数是不是偶数
isOdd  判断是否是奇数
isNaN  是否是数值类型
sign  返回该整数的符号(对于0返回0，对于小于0的值返回 -1，对于大于0的值返回 1。)

void main()
{
    int i = 5;
    print(i.isEven);			// false
    print(i.isOdd);				// true
    print(i.isNaN);				// false
    print(i.sign);				// 1
}

常用的方法：

toInt() : 转成int类型 (舍去小数)
toDouble()  转成double类型
abs()  表示绝对值
round()  四舍五入
ceil()  返回此不小于的最小整数  比如5.2, 返回的是6
truncate()  返回去掉小数点后面的整数

void main()
{
    double i = 2.2;
    print(i.abs());					// 2.2
    print(i.round());				// 2
    print(i.ceil());				// 3
    print(i.toInt().toDouble());	// 2.0
}

常用转换：

// String -> int
var one = int.parse('1');

// String -> double
var onePointOne = double.parse('1.1');

// int -> String
String oneAsString = 1.toString();

// double -> String 注意括号中要有小数点位数，否则报错
String piAsString = 3.14159.toStringAsFixed(2);

二. String

字符串声明

普通字符串使用单引号或者双引号都可以,多行的可以使用'''、"""来包裹.

void main()
{
    String str1 = '单引号声明字符串';
    String str2 = "双引号声明字符串";
    String str3 = '''
					第一行
					第二行 ''';
	String str4 = """
					第一行
					第二行 """;
}

在 String 中单、双引号互相嵌套的情况

void main()
{
    String str = '单引号中的"双引号"';
	String str1 = "双引号中的'单引号'";
	print(str);			// 输出：单引号中的"双引号"
	print(str1);		// 输出：双引号中的'单引号'

	String str2 = '单引号中的 \'单引号\' ';
	String str3 = "双引号中的 \"双引号\" ";
	print(str2);		// 输出：单引号中的 '单引号' 
	print(str3);		// 输出：双引号中的 "双引号" 
}

字符串拼接

字符串拼接可以使用+和空格来拼接

void main()
{
	// 使用“+”号来拼接字符串
	String str = '单引号字符串' + "双引号字符串";
  
	// 单引号、空格拼接，多个空格也可以
	String str1 = '单引号空格字符串' '拼接'		'!';

	// 单双引号换行符以及空格
	String str2 = '单引号符串'
	'换行了' '再加空格' '拼接';

	// 单双引号、空格拼接，多个空格也可以
	String str3 = "单双引号空格字符串" "拼接" 	"!";

	// 单双引号、换行符以及空格
	String str4 = "单双引号符串"
	'换行了' '再加空格' '拼接';

	// 单双引号混合使用
	String str5 = '单""""引号';
  	String str6 = "双''''引号";

	print(str);			// 单引号字符串双引号字符串
	print(str1);		// 单引号空格字符串拼接!
	print(str2);		// 单引号符串换行了再加空格拼接
	print(str3);		// 单双引号空格字符串拼接!
	print(str4);		// 单双引号符串换行了再加空格拼接
	print(str5);		// 单""""引号
	print(str6);		// 双''''引号单引号空格
}

${表达式}的使用

可以在字符串中使用${}中包裹来实现拼接, 如果{}内是一个对象可以省略{}.

void main()
{
	String str = '字符串1' + '字符串2';
	String str1 = 'adc' 'def';

	String str2 = '123${str.toString()}';
	String str3 = '123${str}';
	String str4 = '123$str';

	print(str);         // 字符串1字符串2
    print(str1);        // adcdef
    print(str2);        // 123字符串1字符串2
    print(str3);        // 123字符串1字符串2
    print(str4);        // 123字符串1字符串2
}

三. Boolean

void main()
{
	bool flag = true;
	if (flag)
	{
		print('真');
	}
	else
	{
		print('假');
	}
}

assert 是语言内置的断言函数，仅在检查模式下有效，如果断言失败则程序立刻终止

void main()
{
	// 检查是否为空
	var value = '';
	assert(value.isEmpty);

	// 为0检查
	var value1 = 0;
	assert(value1 <= 0);

	// 检查是否为 null.
	var value2;
	assert(value2 == null);

	// 检查是否为 NaN.
	var value3 = 0 / 0;
	assert(value3.isNaN);
}

四. List

称作集合(数组). 是有序且可重复的.

实例化 List 的方法如下

void main()
{
	// 使用构造创建
	var list = new List();

	// 创建一个int类型的list
	List intlist = [1, 2, 3];

	// 创建一个常量List， 不可以改变的List
	List constList = const[4, 5, 6];
}

List常用方法

void main()
{
	// 在数组中可以存放多个不同类型的对象
	var list = [1, 2, 3, 'Flutter', true];
	print(list);					// 输出的结果：[1, 2, 3, Flutter, true]

	// 修改数组下标为2的值
	list[2] = 'Dart';
	print(list);					// 输出的结果：[1, 2, Dart, Flutter, true]

	// 获取数组的长度
	print(list.length);				// 输出的结果：5

	// 向数组中添加元素
	list.add("value");
	print(list);					// 输出的结果：[1, 2, Dart, Flutter, true, value]

	// 向数组中的指定位置添加元素
	list.insert(1, 'element');  
	print(list);					// 输出的结果：[1, element, 2, Dart, Flutter, true, value]

	// 移除数组中的元素
	list.remove("value");
	print(list);					// 输出的结果：[1, element, 2, Dart, Flutter, true]

	// 移除数组中指定的元素
	list.removeAt(1);
	print(list);					// 输出的结果：[1, 2, Dart, Flutter, true]

	// 判断数组中是否有某个元素
	print(list.indexOf("element"));	// 输出结果：-1

	// 可以使用 sort() 函数来排序, 但是由于我们使用定义的数组类型不一样，就不能使用
	var intlist = [1, 2, 5, 6 ,3];

	// 根据语法提示： List.sort([(int, int) → int compare]) → void
	intlist.sort( (a, b) =>  a.compareTo(b) );
	print(intlist);					// 输出结果：[1, 2, 3, 5, 6]
}

五. Map

是键值对的集合,一般来说，map是将键和值相关联的对象。键和值都可以是任何类型的对象。每个键只出现一次，但你可以多次使用相同的值。Dart支持map由map文字和map类型提供。

创建 Map 集合

void main()
{
	// 通过构造器创建
	var initLanguage = new Map();
	
	// 创建Map 
	var language = {'fisrt': 'dart', 'second': 'java'};

	// 创建不可变的 Map
	var constLanguage = const {'fisrt': 'dart', 'second': 'java'};
}

Map 中常用的方法

void main()
{
	// 创建Map 
	var map = {'fisrt': 'dart', 'second': 'java'};

	// 获取长度
	print(map.length);					// 输出：2

	// 判断是否为空
	print(map.isEmpty);					// 输出：false
	print(map.isNotEmpty);				// 输出：true

	// 获取到所有的 key
	print(map.keys);					// 输出：(fisrt, second)

	// 获取到所有的 values
	print(map.values);					// 输出：(dart, java)

	// 判断是否包含某个key
	print(map.containsKey("key"));		// 输出：false

	// 判断是否包含某个value
	print(map.containsValue("key"));	// 输出：false

	// 添加一个新的元素进去
	map['third'] = 'key';
	print(map);							// 输出：{fisrt: dart, second: java, third: key}

	// 循环打印 代码提示：Map.forEach((String, String) → void f) → void
	map.forEach( (key, value) =>  getMap(key, value) );
}


void getMap(key, value)
{
	print("key:${key}, value:${value}");
	/*
		输出：
		key:fisrt, value:dart
		key:second, value:java
		key:third, value:key
	*/
}

六. const final var

在声明变量的时候，除了var，还可以使用const和final

同时，在使用const和final的时候，可以省略var或者其他类型

void main()
{
	var i = 10;
	const i = 10;
	final i = 10;

	int i = 10;
	const int i = 10;
	final int i = 10;
}

const和final定义的都是常量，值不能改变，并且在声明的时候就必须初始化

但是也有细微差别，简单来说

const定义的是编译时常量，只能用编译时常量来初始化，final定义的常量可以用变量来初始化

void main()
{
	final time = new DateTime.now(); // Ok
	const time = new DateTime.now(); // Error，new DateTime.now()不是const常量
}

var、final等在左边定义变量的时候，并不关心右边是不是常量

但是如果右边用了const，那么不管左边如何，右边都必须是常量

void main()
{
	const list = const[1,2,3];					// Ok
	const list = [1,2,3];						// Error

	final list = [1,2,3];						// Ok
	final list = const[1,2,3];					// Ok
	final list = const[new DateTime.now(),2,3];	// Error,const右边必须是常量
}