Dart入门宝典第一章——变量常量声明和数据类型介绍

前言

  其实在2019年初的时候已经看过Dart的入门教学视频，那时候刚开始学flutter，需要先学Datr语言，由于在公司一直做的都是原生开发，并没有真正使用flutter开发，最近打算走混合开发的路线，所以现在重拾Dart基础，很感谢雷宇老师的视频教程，这里将看视频后的笔记整理和归纳，以便日后的复习，也希望可以帮助到想要入门Dart语言的小伙伴。

变量

• Dart中使用 var 声明变量， 可赋予不同类型的值
• 未初始化时，默认值为null
• 使用final声明一个只能赋值一次的变量

void main() {
   var a;
   print(a);

   a = 1;
   print(a);

   a = "Hello Dart!";
   print(a);
}

此时打印结果为：

null
1
Hello Dart!

void main() {
   final b = 1;
   b = "Hello Dart!"; //此处编辑器会提示有错误
}

b声明为final时，只能赋值一次，再次赋值编辑器会报错

The final variable 'b' can only be set once.

常量

• Dart中使用const声明常量
• 使用const声明的必须是编译期常量

void main() {
   const c = 2;
   c = 3; //此处编辑器会提示有错误 同上
}

final 和 const的区别

1. 用final修饰的变量，必须在定义时将其初始化，其值在初始化后不可改变；
   const用来定义常量。

2. const比final更加严格。final只是要求变量在初始化后值不变，但通过final，我们无法在编译时（运行之前）知道这个变量的值；而const所修饰的是编译时常量，我们在编译时就已经知道了它的值，显然，它的值也是不可改变的。

数据类型

• 数值型-Number
• 字符串-String
• 布尔型-Boolean
• 列表-List
• 键值对-Map
• Runes、Symbols //比较少用

数值型

Dart中num为以下两种类型：

1. int 整数型
2. double 浮点型

声明为num类型的变量，可以赋值为整数或者浮点数

void main() {
   num a = 10;
   a = 10.5;
}

指定为int型的变量，不能赋值为浮点数：

void main() {
   int b = 20;
   b = 20.5; //此处编辑器会报错
}

int 和 double 都是num类的子类，各自的实现有所不同，int类型的值无法赋值为浮点数，而浮点数类型的值可以赋值为整数。

数值型操作

• 运算符：

1. + 加
2. - 减
3. * 乘
4. / 处
5. ~/ 取整
6. % 取余

void main() {
    int a = 10;
    int b = 20;

    print(a+b);
    print(a-b);
    print(a*b);
    print(a/b);
    print(a~/b);
    print(a%b);
}

打印结果为：

30
-10
200
0.5
0  
10

• 常用属性：isNaN(是否为非数字)、isEven（是否为偶数）、isOdd（是否为奇数）等

void main() {
    int a = 10;
    
    print(0.0 / 0.0);
    print((0.0 / 0.0).isNaN);
    print(a.isEven); 
    print(a.isOdd);
}

打印结果为：

NaN
true
true
false

由于double类内定义了0.0 / 0.0为非数字，所以 (0.0 / 0.0).isNaN 的结果为true

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

void main() {
    int a = -10;
    print(a.abs()); //取绝对值

    double b = 10.5;
    print(b.round()); //四舍五入
    print(b.floor()); //不大于本身的最大整数
    print(b.ceil()); //不小于本身的最小整数
    print(b.toInt()); //转换为整数
    print(a.toDouble()); //转换为浮点数
}

打印结果为：

10
11
10
11
-10.0
10

字符串

字符串的创建

• 使用单引号、双引号创建字符串
• 使用三个引号或双引号创建多行字符串
• 使用r创建原始raw字符串

void main() {
    String str1 = 'Hello';  //也可用""
    print(str1);
    
    String str2 = '''Hello  
                      Dart'''; //也可用"""
    print(str2);

    String str3 = "Hello \n Dart";
    print(str3);

    String str4 = r"Hello \n Dart";
    print(str4);
}

打印结果为：

Hello
Hello  
                      Dart
Hello 
 Dart
Hello \n Dart

其中str3使用\n转义换行符，打印的结果带有换行，而str4在字符串前多了一个r，表明使用原始的字符串，即\n不会被解析为换行符，故str4打印结果为原字符串 Hello \n Dart

字符串操作

• 运算符：

1. + 拼接
2. * 重复几次
3. == 两个字符串是否相同
4. [] 取字符串中的字符

void main() {
    String str1 = "I";
    String str2 = "Love";
    String str3 = "Beyond";

    print(str1 + str2 + str3);
    print(str3 * 3);
    print(str1 == str2);
    print(str3[3]);
}

打印结果为：

ILoveBeyond
BeyondBeyondBeyond
false
o

• 插值表达式：${expression}

void main() {
    int a = 1;
    int b = 2;
    print("a + b = ${a + b}");
    print("a = $a,b=$b");
}

打印为结果：

a + b = 3
a = 1,b=2

• 常用属性：length（字符串长度）、isEmpty（是否为空字符串）、isNotEmpty（是否为非空字符串）

void main() {
    String str = "beyond";
    print(str.length);
    print(str.isEmpty);
    print(str.isNotEmpty);
}

打印为结果：

6
false
true

• 常用方法

1. contains() 是否包含
2. subString() 截取字符串
3. toLowerCase() 转换为小写字母
4. toUpperCase() 转换为大写字母
5. startsWith() 是否以某个字符串开头
6. endsWith() 是否以某个字符串结尾
7. trim()、trimLeft()、trimRight() 修剪，去除左右空格
8. indexOf()、lastIndexOf() 某个字符串出现的初始下标、结束下标
9. split() 根据某个规则将字符串分割成一个字符数组
10. replaceAll() 将字符串中对应字符串替换成某个字符串

void main() {
    String str = " I love beyond ";
    print(str.contains("love")); //是否包含love字符串
    print(str.substring(1,2)); // [1,2) 左闭右开 即取第2个字符I
    print(str.toLowerCase()); //转换为小写
    print(str.toUpperCase()); //转换为大写
    print(str.startsWith("I")); //是否以I开头
    print(str.endsWith("beyond")); //是否以beyond结尾
    print(str.trim()); //去除两边的空格
    print(str.indexOf("o")); //首次出现o的下标
    print(str.lastIndexOf("o")); //最后出现o的下标
    print(str.split(" ")); //以空格分割
    print(str.replaceAll("I", "We")); //替换I为We
}

打印结果为:

true
I
 i love beyond 
 I LOVE BEYOND 
false
false
I love beyond
4
11
[, I, love, beyond, ]
 We love beyond 

布尔型

• 使用bool声明
• 布尔值只有true和false

void main() {
   bool isTrue = true;
   bool isFalse = false; 
}

List(数组)

List(数组)的创建

• 创建可变List：var list = [1,2,3];
• 创建不可变的List: const list = [1,2,3];
• 构造方法创建：var list = new List();

void main() {
  var list1 = [1, 2.0, "Dart", true];
  list1[0] = "Hello";
  list1[1] = "World";
  print(list1);

  var list2 = const [1,2,3];
  //list2[0] = 4; 运行时会报错 Unsupported operation: Cannot modify an unmodifiable list

  var list3 = new List();
  list3.add("Hello");
  list3.add("World");
  print(list3);
}

打印结果为：

[Hello, World, Dart, true]
[Hello, World]

常用操作

• [] 取出某个下标的元素
• length 数组的长度
• add(), insert() 插入元素
• remove() 移除指定位置元素或指定元素
• clear() 清空数组
• indexOf(), lastIndexOf() 某个元素首次出现和最后一次出现的下标
• sort() 排序
• sublist() 截取
• shuffle() 随机打乱
• asMap() 转成map
• forEach()遍历

void main() {
   var list = ["Java","Kotlin","Python"];

   print(list[0]); //取第一个元素
   print(list.length); //数组长度

   //往数组末尾添加元素
   list.add("Js");
   print(list);

   //往指定位置添加元素
   list.insert(0, "PHP");
   print(list);

   //移除指定位置元素
   list.remove(0);
   print(list);

   //移除数据中某个元素
   list.remove("Kotlin");
   print(list);

   //元素"PHP"首次出现的下标
   print(list.indexOf("PHP"));
   //元素"Js"最后一次出现的下标
   print(list.lastIndexOf("Js"));

   //排序  
   list.sort();
   print("sort result: $list");

   print("subList result: ${list.sublist(0,2)}");

   print("asMap result: ${list.asMap()}");
   list.forEach(print);

   //清空数组
   list.clear();
   print("clear result: $list");
}

打印结果：

Java
3
[Java, Kotlin, Python, Js]
[PHP, Java, Kotlin, Python, Js]
[PHP, Java, Kotlin, Python, Js]
[PHP, Java, Python, Js]
0
3
sort result: [Java, Js, PHP, Python]
subList result: [Java, Js]
asMap result: {0: Java, 1: Js, 2: PHP, 3: Python}
Java
Js
PHP
Python
clear result: []

Map

Map创建

• 创建可变Map: var language = {“first”: “Java”, “second”: “Dart”};
• 创建不可变Map: var language = const {“first”: “Java”, “second”: “Dart”};
• 构造创建: var language = new Map();

void main() {
  var map1 = {"first": "Dart", 1: true, true: "2"};
  print(map1);
  print(map1["first"]);
  print(map1[true]);
  map1[1] = "1";
  print(map1);

  var map2 = const {1: "Dart", 2: "Java"};
  //map2[1] = "Js"; 运行时会报错 Cannot set value in unmodifiable Map

  var map3 = new Map();
  map3["first"] = 1;
  map3["second"] = 2;
  print(map3);
}

打印结果：

{first: Dart, 1: true, true: 2}
Dart
2
{first: Dart, 1: 1, true: 2}
{first: 1, second: 2}

常用操作

• []
• length
• isEmpty()
• isNotEmpty()
• containsKey() 是否包含某个键
• containsValue() 是否包含某个值
• keys 键的集合
• values 值的集合
• forEach() 遍历
• remove() 移除指定键的元素

void main() {
  var map = {"first": "Dart", 1: true, true: "2"};
  print(map["first"]);
  print(map.length);
  print(map.isEmpty);
  print(map.isNotEmpty);
  print(map.containsKey(1));
  print(map.containsValue("2"));
  print(map.keys);
  print(map.values);
  map.forEach(f);
  map.remove(true);
  print(map);
}

void f(key, value){
  print("key = $key, value = $value");
}

打印结果：

Dart
3
false
true
true
true
(first, 1, true)
(Dart, true, 2)
key = first, value = Dart
key = 1, value = true
key = true, value = 2
{first: Dart, 1: true}

dynamic

使用 dynamic 声明的变量可以赋值为不同类型的值，List泛型指定为 dynamic 表明数组的元素可以是不同类型的，如下：

void main() {
   dynamic a = 1;
   a = 2.0;
   a = "3";
   a = true;
   
   var list = new List<dynamic>();
   list.add(0);
   list.add(1.0);
   list.add("2");
   list.add(true);
}

本章已介绍完毕，感兴趣的小伙伴可以继续查看第二章：

Dart入门宝典第二章——赋值运算符、控制语句、方法和闭包的相关介绍