Flutter开发之Dart的数据类型01

作者: TitanCoder | 来源:发表于2019-02-20 10:34 被阅读53次

dart-logo

原文博客地址: Flutter开发之Dart的数据类型01
这几篇文章都是在学习Dart过程中所记录的学习笔记, 都是一些基础知识, 几乎没什么技术含量, 主要是方便后期使用的时候方便查阅
我写的Flutter和Dart语法系列相关的文章, 有兴趣的可参考随便看看

Dart数据类型

Dart内置的数据类型中, 支持以下几种数据类型

numbers(数字)
strings(字符串)
booleans(布尔)
lists (也被称之为 arrays)
maps
runes (用于在字符串中表示Unicode字符)
symbols

上面的数据类型可以直接使用字面量初始化

var str = 'this is a string' ;
var isStr = true;

也可以使用构造函数初始化, 由于Dart中每个变量引用的都是一个对象 – 一个类的实例, 一些内置的类型具有自己的构造函数

// 可以使用 Map()构造函数来创建一个 map，就像这样 
var map = new Map();

Dart中Numbers支持两种类型的数字：

int: 整数值，其取值通常位于-2^53和2^53之间, 差不多9*10^16, 也就是支持16位数字
double: 64-bit (双精度) 浮点数，符合IEEE 754标准

int

其取值通常位于-2^53和2^53之间
也就是-9,007,199,254,740,992和9,007,199,254,740,992之间
实际在编译中则是超过19位则会报错
更多可参考问题 1533了解更多信息

// 如下定义则会报错, 定义的int星变量需要在9,223,372,036,854,775,807 or less than -9,223,372,036,854,775,808之间
var bil = 12345678901234567890;

一些常用的判断属性

  const m1 = 12;
  
  // 是否为负数, 大于0即为false
  print(m1.isNegative);
  print(0.isNegative);

  // 是否是有限的
  print(b32.isFinite);
  print(m1.isFinite);

  // 是否是无穷大或者无穷小
  print(m1.isInfinite);

  // 是否为偶数
  print(m1.isEven);

  // 是否为奇数
  print(m1.isOdd);

  // 是否是NaN值
  print(m1.isNaN);
  
  // 数据的符号，-1.0:值小于0、+1.0:值大于0、-0.0/0.0/NaN:值是其本身
  print(21.sign);  // 1
  print(-23.sign); // -1
  print(0.sign);   // 0
  print(-0.sign);  // 0

int数字类型中常用的函数

  const m3 = 24;
  
  // 获取绝对值
  print(m3.abs());

  // 转成字符串
  print(m3.toString());

  // 幂次求模; m3的4次幂, 在对3求模
  print(m3.modPow(4, 3)); // 1

  // 返回m3和16的最大公约数
  print(m3.gcd(16));
  
  // 返回m3除以5的余数
  print(m3.remainder(5));

  // 转成double
  print(m3.toDouble());
  
  // 比较大小, 0:相同、1:大于、-1:小于
  print(m3.compareTo(30));

double

下面是定义double的一些方式：

var y = 1.1;
var exponents = 1.42e5;

double类型相关的属性使用

  // 是否是NaN值
  print(d0.isNaN);
  // 是否是无穷大或者无穷小
  print(d0.isInfinite);
  // 是否是有限的
  print(d0.isFinite);
  // 是否为负数, 大于0即为false
  print(d0.isNegative);

  // 根据代码单元生成的哈希码
  print(d0.hashCode);
  
  // 数据的符号，-1.0:值小于0、+1.0:值大于0、-0.0/0.0/NaN:值是其本身
  print(d0.sign);
  print(-1.23.sign);
  print(0.0.sign);

  // 返回运行时的类型
  print(d0.runtimeType);  // double

double类型相关方法的使用

  // 转成字符串
  print(d0.toString());

  // 取整数, 小数点舍去
  print(d0.toInt());

  // 比较大小, 0:相同、1:大于、-1:小于
  print(d0.compareTo(30));

  // 获取绝对值
  print(d0.abs());

  // 四舍五入
  print(d0.round()); // 13
  // 向上取整
  print(d0.ceil());  // 14
  // 向下取整
  print(d0.floor()); // 13

  // 输出的double类型, 相当于d0.round().toDouble()
  print(d0.roundToDouble()); // 13.0
  print(d0.ceilToDouble());  // 14.0
  print(d0.floorToDouble()); // 13.0

  // 保留指定的小数位数(四舍五入), 不足补0, 字符串返回
  print(d0.toStringAsFixed(2)); // 13.10

  // 保留变量的位数(小数点前后的总位数), 不足补0, 多余的四舍五入
  print(d0.toStringAsPrecision(10));  // 13.09870000

  /**  toStringAsExponential
   *     1.toStringAsExponential();       // 1e+0
   *     1.toStringAsExponential(3);      // 1.000e+0
   *     123456.toStringAsExponential();  // 1.23456e+5
   *     123456.toStringAsExponential(3); // 1.235e+5
   *     123.toStringAsExponential(0);    // 1e+2
   */


  /** toStringAsPrecision
   *     1.toStringAsPrecision(2);       // 1.0
   *     1e15.toStringAsPrecision(3);    // 1.00e+15
   *     1234567.toStringAsPrecision(3); // 1.23e+6
   *     1234567.toStringAsPrecision(9); // 1234567.00
   *     12345678901234567890.toStringAsPrecision(20); // 12345678901234567168
   *     12345678901234567890.toStringAsPrecision(14); // 1.2345678901235e+19
   *     0.00000012345.toStringAsPrecision(15); // 1.23450000000000e-7
   *     0.0000012345.toStringAsPrecision(15);  // 0.00000123450000000000
   */

Booleans

为了代表布尔值，Dart有一个名字为bool的类型。
只有两个对象是布尔类型的：true和 false 所创建的对象，这两个对象也都是编译时常量
当Dart需要一个布尔值的时候，只有true对象才被认为是true, 所有其他的值都是flase; 像 1、 "aString"、以及someObject等值都被认为是false

  const m = 1;
  if (m) {
    print('是一个布尔值');
  } else {
    print('不是一个布尔值');
  }

在Dart中上面判断语句是合法的代码
但是在Dart检查模式运行，上面的代码将会抛出一个异常，表示m变量不是一个布尔值
所以不建议这么使用上述方法进行判断

Strings

Dart字符串是UTF-16编码的字符序列, 可以使用单引号或者双引号来创建字符串：

var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";
// 单引号里面有单引号(双引号里面有双引号)时, 必须使用反斜\杠转义
var s3 = 'It\'s easy to escape the string delimiter.';
var s4 = "It's even easier to use the other delimiter.";

字符串的拼接

直接把相邻字符串写在一起，就可以连接字符串了

var string = 'name''+''age'

用+把相邻字符串连接起来

var string1 = 'name' + '+' + 'age';

引用变量

在Dart中使用$符号引用变量或者表达式
表达式引用方式: ${表达式}, 如果表达式是一个变量则{}可以省略

  const num1 = 12;
  // 引用表达式
  const ageStr0 = 'age = $num1';
  const ageStr1 = 'age = ${num1} is my age';
  // 引用表达式
  const ageStr2 = 'age = ${num1 * num1}';

多行字符串

使用单引号或双引号的三引号

  const line1 = '''
      道路千万条，安全第一条，
      行车不规范，亲人两行泪
    ''';
  const line2 = """
      道路千万条，安全第一条，
      行车不规范，亲人两行泪
    """;

转义符号

声明raw字符串(前缀为r)，在字符串前加字符r，或者在\前面再加一个\，可以避免\的转义作用，在正则表达式里特别有用

  // 转义字符
  print(r'转义字符, \n');
  print('转义字符, \\n');
  print('转义字符, \n');

属性介绍

  const string0 = 'https://www.titanjun.top/';
  
  // 可根据索引获取字符串的每一个字符
  print(string0[1]);

  // 字符串是否是空的
  print(string0.isEmpty);
  print(''.isEmpty); // true
  // 字符串是否不是空的
  print(string0.isNotEmpty);
  print(''.isNotEmpty);  // false

  // 返回字符串Unicode代码的可迭代对象
  print(string0.runes);
  // 返回字符串的UTF-16代码单元列表
  print(string0.codeUnits);
  // 返回根据代码单元生成的哈希码
  print(string0.hashCode);
  // 字符串的长度
  print(string0.length); 
  // 返回对象运行时的类型
  print(string0.runtimeType);  // String

方法介绍

  const string0 = 'https://www.titanjun.top/';
  
  // 字符串比较
  print('titan'.compareTo('jun'));
  
  // 大小写转换
  print(string0.toUpperCase());
  print(string0.toLowerCase());

  // 截取字符串(开头索引和结尾索引)
  print(string0.substring(0, 5)); // https
  // 只有开头索引, 默认截取到最后
  print(string0.substring(12));  // titanjun.top/

  // 拆分字符串
  print(string0.split('.'));  // [https://www, titanjun, top/]
  print(string0.split(new RegExp(r"t")));  // [h, , ps://www., i, anjun., op/]

  // 去掉字符串里面的tab空格和换行符
  const string1 = '\t\ttitanjun top\n';
  print(string1.trim());
  // 去掉字符串开头的tab空格和换行符
  print(string1.trimLeft());
  // 去掉字符串结尾的tab空格和换行符
  print(string1.trimRight());

endsWith

判断字符串是否以某字符(字符串)结尾, 参数不接受正则表达式

  const str1 = 'titanjun.top';
  print(str1.endsWith('p'));  //true
  print(str1.endsWith('/'));  //false
  print(str1.endsWith('top'));  //true

startsWith

bool startsWith(Pattern pattern, [int index = 0]);

判断字符串是否以某字符(字符串)开头, 参数接受正则表达式

  const str1 = 'titanjun.top';
  print(str1.startsWith('h'));  //false
  print(str1.startsWith('tit')); //true
  print(str1.startsWith('it', 1)); //true
  print(str1.startsWith(new RegExp(r'[A-Z][a-z]'), 1)); //false

indexOf

int indexOf(Pattern pattern, [int start]);

根据指定的字符(字符串)获取其在原字符串中第一次出现的索引值, 顺序是从左到右
可以从指定的索引初开始, 默认从0开始
如果原字符串中没有需要查找的字符(字符串), 则返回值为: -1

  const str2 = 'https://www.titanjun.top/';
  print(str2.indexOf('titan')); // 12
  print(str2.indexOf('t', 5));  // 12
  print(str2.indexOf(new RegExp(r'[a-z]'))); //0
  // 如果没有改字符, 则会输出-1
  print(str2.indexOf('ppp'));  // -1

lastIndexOf

int lastIndexOf(Pattern pattern, [int start]);

效果和indexOf一样, 不同点则是: indexOf的顺序是从左到右, lastIndexOf是从右到左

  const str2 = 'https://www.titanjun.top/';
  print(str2.lastIndexOf('t', 20));  //14
  print(str2.indexOf(new RegExp(r'[a-z]'))); //0
  // 如果没有改字符, 则会输出-1
  print(str2.indexOf('ppp'));  // -1

补占位符

String padLeft(int width, [String padding = ' ']);
String padRight(int width, [String padding = ' ']);

在字符串前后补占位符
参数一: 想要得到的字符串的位数
参数二: 位数不足时, 补充的字符

  const str3 = '12';
  print(str3.padLeft(2, '0')); //12
  print(str3.padRight(3, '0')); // 120

contains

bool contains(Pattern other, [int startIndex = 0]);

判断字符串中是否包含某字符
判断指定索引处的字符是否是某字符

bool contains(Pattern other, [int startIndex = 0]);

const str = 'Dart strings';
print(str.contains('D'));
print(str.contains(new RegExp(r'[A-Z]')));
print(str.contains('D', 0));
print(str.contains(new RegExp(r'[A-Z]'), 0));

替换字符

// 只能替换一次, 参数三为开始的索引值, 默认0
String replaceFirst(Pattern from, String to, [int startIndex = 0]);

// 替换所有符合条件的字符(字符串)
String replaceAll(Pattern from, String replace);

// 替换某一区间的字符
String replaceRange(int start, int end, String replacement);

// 示例如下:
// 替换字符串
  const str4 = 'titanjun12--0123';
  print(str4.replaceFirst('t', 'T'));  // Titanjun12--0123
  print(str4.replaceFirst('12', '21', 10));   //titanjun12--0213

  // 全部替换
  print(str4.replaceAll('12', '21'));  //titanjun21--0213
  print(str4.replaceAll('t', 'T'));  //TiTanjun12--0123

  // 区间替换
  print(str4.replaceRange(0, 5, 'top'));  //topjun12--0123

List

在Dart中List对象就是其他语言中的数组

创建数组

// 创建一个指定长度的List, 不能添加/删除元素
List([int length]);

//通过指定长度创建一个固定长度的List，并使用fill初始化每个位置的值, 不能添加/删除元素
List.filled(int length, E fill, {bool growable: false});

//创建一个包含所有elements的List, 
//当growable为true（默认）时，构造函数返回一个可增长的List。 否则，它返回一个固定长度的List
List.from(Iterable elements, {bool growable: true})

//生成一个包含所有值的List
//除非growable为true(默认)，否则创建的List是固定长度的
List.generate(int length, E generator(int index), {bool growable: true})

//创建一个包含所有elements的，不能改变它的长度或元素
List.unmodifiable(Iterable elements)

List

如果设置了参数length(length不能为负数或null)，那么创建的List是固定长度的
元素可修改, 元素个数不可修改, 不能删除和增加元素

var l1 = new List(3);  //[null, null, null]
print(l1.length);  //3

// 下面这种写法会报错
l1.length = 1;

如果未设置参数length，那么List的长度是0，并且是可增长的

// 这两种方式一样
var l10 = new List();
var l11 = [];

// 都是可行的
l10.length = 3;
l10.add(1);

当使用指定长度创建一个可增长的List时，仅仅在刚创建后分配长度

List growableList = new List()..length = 500;

filled

通过指定长度创建一个固定长度的List，并初始化每个位置的值
所有的元素都是相同的fill值。如果指定的值是一个可变对象，那么List中所有的元素都是相同的对象，并且是可修改的

  var l2 = new List.filled(3, 'l');  //[l, l, l]
  var l3 = new List.filled(2, []);   // [[], []]
  l3[0].add(12);   
  print(l3);      // [[12], [12]]

from

创建一个包含所有elements的List
elements的Iterator规定了元素的顺序。
当growable为true（默认）时，构造函数返回一个可增长的List。否则，它返回一个固定长度的List

var l5 = new List.from([1, 2, 3, 4]);
l5.add(5);
print(l5);   // [1, 2, 3, 4, 5]

// 下面的add方法会报错
var l5 = new List.from([1, 2, 3, 4], growable: false);
l5.add(5);

generate

生成一个包含所有值的List, 根据索引值创建元素
growable为false时，创建的List是固定长度的

var l4 = new List.generate(3, (int i) => i * i);
l4.add(14);
print(l4);
// [0, 1, 4, 14]

unmodifiable

创建一个包含所有elements的，不可修改的List
不可修改的List不能改变它的长度或元素
如果元素本身是不可改变的，那么由此产生的List也是不可改变的

var l6 = new List.unmodifiable([1, 2, 3, 4]);

List属性

  var arr1 = [1, 2, 3, 4];
  // 数组的第一个和最后一个元素
  print(arr1.first);  // 1
  print(arr1.last);   // 4

  // 判断数组是否为空
  print(arr1.isNotEmpty);  // true
  print(arr1.isEmpty);     // false

  // 数组长度, 元素个数
  print(arr1.length);  // 4

  // 倒序返回List
  print(arr1.reversed);  // [4, 3, 2, 1]

  // 返回Iterator，被允许迭代Iterable的所有元素
  print(arr1.iterator);

  // 对象的运行时类型
  print(arr1.runtimeType);   // List<int>

  // 获取对象的哈希值
  print(arr1.hashCode);
  
  // 根据索引获取元素
  print(arr1[2]);

  // 根据索引修改元素
  arr1[1] = 11;
  print(arr1);

List方法

增加

  // 添加元素
  arr1.add(5);

  // 添加一个数组
  arr1.addAll([10, 12]);

查找

  var arr2 = ['one', 'two', 'three', 'one', 'four'];

  // 是否包含某元素
  print(arr2.contains('one'));  // true
  // 判断数组是否有满足条件的元素
  print(arr2.any((item) => item.length > 4));  // true
  // 判断数组是否所有元素都满足条件
  print(arr2.every((item) => item.length > 4));  // false
  
  // 转化为Map类型, 索引作为Key值，对应的元素作为Value
  print(arr2.asMap());  // {0: one, 1: two, 2: three, 3: one, 4: four}
  
  //随机打乱List中的元素
  arr2.shuffle();

  // 通过索引获取元素, 等价于arr2[3]
  print(arr2.elementAt(3));

  // 获取元素对应的索引值, 默认从索引0开始
  print(arr2.indexOf('one'));  // 0
  // 从第2个索引开始查找
  print(arr2.indexOf('one', 2));  // 3
  // 如果找不到, 返回-1
  print(arr2.indexOf('five'));  // -1

  // 获取元素对应的索引值, 从后往前找
  print(arr2.lastIndexOf('one'));
  print(arr2.lastIndexOf('one', 3));
  print(arr2.lastIndexOf('five'));
  
  // 返回满足条件的第一个元素
  print(arr3.firstWhere((item) => item == 'one'));
  
  // 查找符合条件的元素, 如果有且仅有一个符合条件的元素, 则返回该元素
  // 如果没有匹配到元素，或匹配到多个元素, 则会抛出异常
  print(arr2.singleWhere((item) => item.length == 5));  //three
  
  // 返回除了最初的count个元素外的所有元素
  arr2 = ['one', 'two', 'three', 'four'];
  print(arr2.skip(2)); // (three, four)

  // 返回所有不符合该条件的元素
  print(arr2.skipWhile((item) => item.length == 3));  //(three, four)

  // 返回一个新的List，包含从start（包括）到end（不包括）的对象, 原数组不变
  print(arr2.sublist(1, 3));
  // 不指定end, 默认到数组结尾
  print(arr2.sublist(2));
  
  // 获取某一区间的元素, 返回一个数组
  print(arr2.getRange(1, 3));    // ['two', 'three']
  
  // 数组拼接成字符串
  print(arr2.join());  //onetwothreefour
  print(arr2.join('-'));  //one-two-three-four

  // 返回数组最初的count个元素
  print(arr2.take(2));
  // 返回数组符合条件的元素, 直到条件值为false停止过滤
  arr2 = ['one', 'two', 'three', 'four', 'ten'];
  print(arr2.takeWhile((item) => item.length == 3));  //(one, two)

删除

  var arr2 = ['one', 'two', 'three', 'one', 'four'];
  
  // 删除指定的元素
  // 如果有该元素, 返回true
  print(arr2.remove('two'));  // true
  print(arr2);   // [one, three, one, four]
  // 如果没有该元素, 返回false
  print(arr2.remove('five'));  // false

  // 根据索引删除, 返回被删除的元素值
  print(arr2.removeAt(1));  // three
  print(arr2);   // [one, one, four]

  // 删除最后一个元素, 返回该元素值
  print(arr2.removeLast());  // four
  print(arr2); // [one, one]

  // 删除一个区间的元素, 含左不含右[start, end)
  arr2.addAll(['six', 'seven', 'eight']);
  arr2.removeRange(1, 3);
  print(arr2);  // [one, seven, eight]

  // 删除所有符合条件的元素
  arr2.removeWhere((item) => item.length == 3);
  print(arr2);  // [seven, eight]
  
  //删除List中所有不满足条件的元素
  arr2.retainWhere((item) => item.length > 3);
  print(arr2);
  
  // 删除所有的元素
  arr1.clear();
  print(arr1);  // []

插入

  var arr3 = [1, 3, 4];
  // 在某处插入元素
  arr3.insert(1, 10);
  print(arr3); //[1, 10, 3, 4]

  // 插入一个数组
  arr3.insertAll(2, [12, 32]);
  print(arr3);

重要方法

//过滤
Iterable<E> where(bool test(E element)) => new WhereIterable<E>(this, test);

// 映射
Iterable<T> map<T>(T f(E e)) => new MappedIterable<E, T>(this, f);

// 排序
void sort([int compare(E a, E b)]);

// 迭代计算, initialValue: 初始值, combine: 计算函数
T fold<T>(T initialValue, T combine(T previousValue, E element))

// 迭代计算, 初始值即为第一个元素的值, combine: 计算函数
E reduce(E combine(E value, E element))

// 对集合的每个元素，按迭代顺序执行函数操作
void forEach(void f(E element))

// 将Iterable的每个元素扩展为0个或多个元素
Iterable expand(Iterable f(E element))

下面看一下每一个函数的具体使用和介绍

  var arr2 = ['one', 'two', 'three', 'four'];
  
  // 过滤操作, 返回所有符合条件的元素
  print(arr2.where((item) => item.length == 3));  //(one, two, ten)
  
  // 映射一个新的数组, 参数是一个函数
  var array = arr2.map((item) {
    return item + '-';
  });
  print(array.toList());  // [one-, ten-, two-, four-, three-]
  
  // 排序, 默认从小到大
  arr2.sort();
  print(arr2);  //[four, one, ten, three, two]
  // 设置条件进行排序
  arr2.sort((item1, item2) {
    // 如果两个比较的结果为0, 那么排序后返回的结果可能不同
    return item1.length.compareTo(item2.length);
  });
  print(arr2);  //[one, ten, two, four, three]

  // 迭代计算, initialValue: 初始值, combine: 计算函数
  var arr4 = [1, 2, 3, 4];
  // 设置初始值
  var result1 = arr4.fold(10, (prev, value) => prev + value);  //20
  var result2 = arr4.fold(2, (prev, value) => prev * value);  //48
  // 初始值即为第一个元素的值, 可迭代对象至少要有一个元素。 如果它只有一个元素，则元素直接返回
  var result3 = arr4.reduce((value, element) => value * element);  // 24

  // 对每一个元素进行操作
  arr2.forEach((item) {
    print(item);
  });
  
  // expand, 以对每个元素调用f函数后生成的元素，按迭代的顺序，返回新的Iterable
  var pairs = [[1, 2], [3, 4]];
  var flattened = pairs.expand((pair) => pair).toList();
  print(flattened); // => [1, 2, 3, 4];

  var input = [1, 2, 3];
  var duplicated = input.expand((i) => [i, i]).toList();
  print(duplicated); // => [1, 1, 2, 2, 3, 3]

由于篇幅太长了, 剩下的一些数据类型下篇文章在继续研究记录吧

Flutter开发之Dart的数据类型01

Dart数据类型

int

double

Booleans

Strings

字符串的拼接

引用变量

多行字符串

转义符号

属性介绍

方法介绍

endsWith

startsWith

indexOf

lastIndexOf

补占位符

contains

替换字符

List

创建数组

List

filled

from

generate

unmodifiable

List属性

List方法

增加

查找

删除

插入

重要方法

参考文献

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Flutter