Dart语言基础（二）之数据类型

Dart语言之数据类型

数据类型

• dart语言数据类型包含一下类型：
  1. 变量-Var
  2. 常量-Const
  3. 数值型-Number
  4. 字符串-String
  5. 布尔型-Boolean
  6. 列表-List
  7. 键值对-Map
  8. 动态类型-dynamic
  9. Runes、Symbols(很少用)

变量Var

• 使用var声明变量，可赋予不同类型的值

• 未初始化时，默认值为null。此时的类型dynamic类型

    var a;  //初始化并没有声明类型，是dynamic类型
    print(a); //null
    
    a = 10;
    print(a); //10
    
    a = 'hello world';
    print(a); //hello world
    
    //声明变量并初始化,确实变量类型
    var b = 20;
    print(b); //20
  

• 使用final声明一个只能赋值一次的变量

    //final变量   
    final c = 20; //类型已经确定并且不能再进行赋值
    c = 'hello';//报错
    c = 10； //报错
  

常量Const

• 使用const声明常量

• 使用const声明的必须是编译器常量

    const d = 20;
    d = 50;//报错，常量不能再赋值了。
  

数值型num

• Dart语言是面向对象语言，num也是object，int和double继承于num。

• 如果直接用int和double来声明的话，int无法变成double，double无法变成int

• num包含两种子类型：1、整型-int 2、浮点型-double

    num = 10;//整型
    num = 10.5;//这个时候就变成浮点型了
    
    int b = 20;
    b = 20.5;//报错int不能转double
    
    double d = 20.5;
    d = 20; //报错double不能转int
  

• 运算符：+、-、*、/、~/、%

    int a = 10;
    int b = 2;
    print(a + b); //12
    print(a - b); //8   
    print(a * b); //20
    print(a / b); //5.0 这个不是整除，值是浮点型的
    print(a ~/ b);//整除，余数部分舍弃取整 5
    print(a % b);//去余数 0
  

• 常用属性：isNaN、isEven、isOdd等

    //isNaN 非数字
    print(0.0/0.0);//NaN,只有这个情况是
    int a = 3;
    int b = 4;
    //是否是偶数
    print(a.isEven);//false
    print(b.isEven);//true
    //是否是奇数
    print(a.isOdd);//true
    print(b.isOdd);//false
  

• 常用的方法：abs()、round()、floor()、ceil()、toInt()、toDouble()

    int a = -100；
    //取绝对值
    print(a.abs()); //100
    double f = 10.5;
    //四舍五入
    print(f.round()); //11
    //不大于f的最大整数     
    print(f.floor()); //10
    //不小于f的最小整数
    print(f.ceil()); //11
    //转整型
    print(f.toInt()); //10
    //转浮点型
    int d = 100;
    print(d.toDouble()); //100.0
  

字符串

• 使用单引号、双引号创建的字符串

    String str1 ='hello'; //使用双引号也可以字符串赋值
  

• 使用三个单引号、三个双引号创建的多行字符串

    String str = '''hello
                        dart''';//使用三个双引号赋值多行字符串
  

• 使用r创建原始的raw字符串

    String *str = 'hello \n Dart ';
    print(str);//打印换行字符串
    
    //打印带\n
    String *str1 = r'hello \n Dart ';
    print(str1);//hello \n Dart 
  

• 可以使用+号来拼接字符串

    String *str1 = 'hello';
    print(str1 + 'dart');//hellodart
  

• 可以使用*号来表示循环这个字符串几次

    String *str1 = 'hello';
    print(str1*3);//hellohellohello
  

• 可以使用==比较两个字符串是否相等（比较的是内容）

    String *str1 = 'hello';
    String *str2 = 'hello';
    String *str3 = 'dart';
    print(str1 == str2); //true
    print(str1 == str3); //false
  

• 可以使用[]来获取字符串的某个字节

    String *str1 = 'hello';
    print(str1[0]); // h        
  

• 可以使用${表达式}来表示插值表达式

    int a = 1;
    int b = 2;
    print("a + b = $(a + b)");//a + b = 3
    print("a = $a");//a = 1
  

• 可以使用.length获取字符串长度(空格也算一个字节)

    String str = 'hello';
    print(str.length);//5
    
    String str = 'hello dart';
    print(str.length);//10
  

• 可以使用.isEmpty、.isNotEmpty来判断是空、是非空

    String str = 'hello';
    print(str.isEmpty); //false
    print(str.isNotEmpty); //true
  

• 可以使用.contains(字符串)判断是字符穿否包含另一个字符串

    String str = 'hello dart';
    print(str.contains('dart')); //true
  

• 可以使用.substring(int startIndex, endIndex)来截取字符串

   String str = 'hello dart';
   print(str.substring(0,4)); // hello
  

• 可以使用.startsWith(字符串)、.endsWith(字符串)来判断是否以括号里字符串开头、结尾的

    String str = 'hello dart';
    print(str.startsWith('he')); //true
    
    print(str.endsWith('a')); // false
  

• 可以使用.split()分割字符串,返回的是List

    String str = 'hello dart';
    //以空格分割
    var list = str.split(' ');
    print(list); //[hello,dart]
  

• 可以使用.replaceAll()来替换字符串

    String str = 'hello dart';
    print(str.replaceAll('dart','java')); //hello java
  

• 可以使用.toLowerCase()、toUpperCase()转成小写、大写

    String str = 'Hello';
    print(str.toLowerCase()); //hello
    print(str.toUpperCase()); //HELLO
  

• 字符串还有很多的方法，自己可以摸索。我只列出比较常用的方法

布尔型

• 使用bool表示布尔类型
• 布尔值只有true和false

列表List

• 创建可变List

    var list = [1,2,3];
  

• 创建一个不可变的List

    //不可变，内容元素和长度都不可变
    var list = const [1,2,3];   
  

• 构造创建

    var list = new List();
  

• 列表里面的元素可以是不同类型的

    var list = [1,2,'dart',true];
    print(list); //[1,2.dart,true]
  

• 可以通过.[imdex]获取某个元素或者改变某个元素的值

    var list = [1,2,'dart',true];
    print(list[]); //dart
    
    list[1] = 8;
    print(list);//[1,8,dart,true]
  

• 可以通过.length获取list的长度

    var list = [1,2,'dart',true];
    print(list.length); //4

• 可以同过add(element)、insert(index,element)添加元素,添加的元素类型List要包含

    var list = ['dart','java'];
    
    list.add('iOS');
    list.add(3); //报错，List都是字符串，没有int类型,要想添加成功List里面必须要int，还有一种dynamic方式创建就可以，后面会讲
    
    print(list);//[dart,java,iOS]
    
    list.insert(0,'data');
    list.insert(0, 3); //报错，List都是字符串，没有int类型
    print(list); [data,dart,java,iOS]
  

• 可以通过remove(element)移除元素、removeLast()移除最后一个元素、removeAt(idnex)按index移除元素、clear()清空元素

    var list = [1,2,'dart',true];
    list.remove(true)
    print(list); //[1,2,dart]
    
    list.removeLast();
    print(list); //[1,2]
    
    list.removeAt(0);
    print(list); //[2]
    
    list.clear();
    print(list); //[]
  

• 可以通过indexOf(element)获取元素所在的位置、lastIndexOf()最后元素所在的位置

    var list = [1,2,'dart',true];
    print(list.indexOf('dart')); //2
    print(list.lastIndexOf());//3
  

• 可以通过sort()排序,排序的元素必须是同类型的

• sublist()获取子list

    var list = [1,2,'a'];
    list.sort();
    print(list);//报错，排序需要list的元素是同类型的
  
    var list1 = [2,4,1];
    list.sort();
    print(list); //[1,2,4]
  
    var list2 = ['hello','dart','java'];
    list2.sort();
    print(list2); //[dart, hello, java]
  

• 可以通过asMap()把list转成Map（键值对）key是用元素的index补全

    var list2 = ['hello','dart'];
    print(list2.asMap()); //{0: dart, 1: hello}
  

• 可以通过forEach(f)遍历list的元素,括号里f是方法

    var list2 = ['hello','dart','java'];
    //遍历每个元素都都调用print
    list2.forEach(print);
    //hello
    //dart
    //java
  

可能有些人不太明白元素的值怎么传递的，可以看看forEach实现源码

    void forEach(void f(E element)) {
        for (E element in this) f(element);
    }

看到这大概知道了，就是遍历this就是自己也就是list，把list里面的元素，遍历的时候把元素当成f这个方法的参数。

• List里面的方法太多，我只列举比较常用的方法，大家有时间可以多了解其他的方法

Map 键值对

• 创建可变的Map

    var map = {'first':'dart','second':'java'};
  

• 创建不可变的Map,map里的键值对都不能更改

    var map = const {1:'dart',2:'java'};
  

• 构造创建

    var map = new Map();
  

• 可以通过[key]来获取value，key尽量使用字符串或者数字,不要使用布尔值当key。

    var map = {'first':'dart',2:'java'};
    print(map['first']); //dart
    print(map[2]); //java
  

• 可以通过.addAll(Map<K, V> other)来添加键值对

• 可以通过.length获取map的键值对个数

    var map = {'first':'dart',2:'java'};
    map.addAll({'third':'iOS'});
    print(map); //{'first':'dart',2:'java','third':'iOS'} 
  

• 可以通过.isEmpty()是否是空不 .isNotEmpty()是否是非空

    var map = {'first':'dart',2:'java'};
    print(map.isEmpty()); //false
    print(map.isNotEmpty()); //true
  

• 可以通过.keys、.values获取Map所有的键、值

    var map = {'first':'dart',2:'java'};
    print(map.keys); //(first,2)
    print(map.values); //(dart,java)
  

• 可以通过containsKey()、containsValue()来判断是否包含某个key、value

    var map = {'first':'dart',2:'java'};
  
    print(map.containsKey('first')); //true
    print(map.containsValue('iOS')); //false    
  

• 可以通过remove()移除某个key的键值对

     var map = {'first':'dart',2:'java'};
     map.remove('first');
     print(map);// {2:'java'}
  

• 通过forEach(f)遍历所有的键值对

    //forEach(f) f这个方法接受两个参数key、value
    void forEach(void f(K key, V value)); 
    
    var map = {'first':'dart',2:'java'};
    map.forEach(f); 
    /*
        key=first,value=dart
        key=2,value=java
    */
    
    //下面是定义一个方法接受两个参数的处理
    void f(key, value) { 
        print('key=$key,value=$value');
    }
  

• Map里面的方法太多，我只列举比较常用的方法，大家有时间可以多了解其他的方法

dynamic

• Dart提供了可选的类型系统，在声明变量、定义函数的时候，可以指定类型，也可以不指定，不指定的话就是dynamic

• Dart的类型系统比较独特的地方在于，类型仅仅是给编辑器看的，它不应也不会对代码的行为产生任何影响。在production模式下，类型会被忽略，以获得更好的性能。我们在执行dart代码时，可以指定–checked参数，打开或关闭运行时的类型检查（默认未开启）。

    var a = 10; //指定类型并且赋值
    a = 'aa'; //报错，不是int类型
    
    var a; //a没有指定类型是dynamic，可以赋值任何类型
    a = 10; //dynamic
    a = 'dart; //dynamic
  

• 可以通过dynamic 声明一个变量

    dynamic b = 10;
    b = 'dart'; //因为是动态类型可以赋值字符串
  

• 可以创建dynamic的List

    //通过dynamic创建的list可以添加任何类型
    var list = new List<dynamic>();
    list.add(1);
    list.add("value");
    list.add(true);
    print(list); //[1,value,true]
  

Runes

• 在DART中，runes表示字符串的UTF-32编码

• Unicode为所有世界上的书写系统中使用的每个字母、数字和符号定义一个唯一的数字值。由于DART字符串是由UTF-16代码单元组成的序列，因此在字符串中表示32位Unicode值需要特殊的语法。

• 通常表示Unicode代码点的方法是uXXXX，其中XXXX是一个4位的十六进制值。例如，爱心字符(♥)是u2665。

• String类具有几个可用于提取符文信息的属性，codeUnitAt和codeUnit属性返回16位代码单元。使用runes属性获取字符串的符文。

    var clapping = '\u{1f44f}'; 
    print(clapping);
    print(clapping.codeUnits);
    print(clapping.runes.toList());
    Runes input = new Runes(
    '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
    print(new String.fromCharCodes(input));
  

打印的结果如下:

runes打印.png

Symbol

• Symbol对象表示在Dart程序中声明的运算符或标识符。您可能永远不需要使用符号，但它们对于按名称引用标识符的API非常有用，因为缩小会更改标识符名称而不会更改标识符符号。要获取标识符的符号，请使用符号文字，它只是＃后跟标识符：

    // 通过new Symbol()声明
    var a = new Symbol('radix');
    print(a); //Symbol("radix")
  
    //可以通过#radix来表示
    print(#radix); //Symbol("radix")
    print(#bar); //Symbol("bar")
  
    print（#radix == new Symbol('radix'));  //true
  

这个很不常用，大家知道这个类型就可以。

结尾

这里的很多内容都只是大概介绍个基础点，里面的每个部分都还有很多知识点细节需要学习，在之后的系列会慢慢展开来说。

下一章节讲解Dart语言基础（三）之运算符