dart入口函数

第一种写法

1
2
3
main(){
      print('hello dart!')
}

第二种写法
void 代表此函数没有返回值

1
2
3
void main(){
      print('hello dart!')
}

变量

dart是一个强大的脚本类语言，可以不预先定义变量类型 ，自动会类型推倒。定义变量可以通过var关键字，也可以通过类型来申明变量，比如：

1
2
3
4
5
var str='this is var';
 
String str='this is var';
 
int str=123;

注意：var后就不要写类型 ，写了类型就不要var，两者都写var a int = 5; 则会报错

常量

final and const

const值不变 一开始就得赋值 final 可以开始不赋值 只能赋一次 ; 而final不仅有const的编译时常量的特性，最重要的它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化。

1
2
3
4
5
final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';
 
const bar = 1000000; // Unit of pressure (dynes/cm2)
const double atm = 1.01325 * bar; // Standard atmosphere

数据类型

常用的数据类型

Keyword描述
int整数类型
double浮点数类型
bool布尔类型
String字符串类型
List数组
Map键值对(字典类型)

String

单引号 和 双引号 都可以使用!

注意: String 还可以使用三个引号来表示多行!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var str = '一串字符';

var str1 = "一串字符";

String str = '一串字符';

String str1 = "一串字符";

String moreLine = '''一串字符;
一串字符

      一串字符

'''
// 字符串拼接
print('$str $str1');

print(str + str1);

int

整数类型

1
2
3
4
5
6
int a = 1;
var b = 3;

print(a)
print(b)
// 1 and 3

double

浮点类型

1
2
3
4
5
6
double a = 1.2;
var b = 3.3;

print(a)
print(b)
// 1.2 and 3.3

bool

布尔类型

1
2
3
4
5
6
bool a = true;
var b = false;

print(a)
print(b)
// true and false

List

数组集合

注意: []中括号声明集合的方式内容长度是可以动态变化的!

混合类型数组

数组元素可包含 String int bool等混合元素!

1
2
var arr = ['张三', 15, '男', '未婚', true]

通过arr.length获取数组的长度,以及可以通过指定下标获取对应的值arr[0]

指定类型数组

数据单方面指定类型存值

1
2
3
4
5
6
var age = <int>[15,17,18]

var name = <String>['张三','李四','王五']

name.add('狗蛋儿!') // 为数组添加元素

创建固定长度集合

固定长度，创建后，就无法在进行元素添加，长度也无法修改!

1
2
3
4
5
6
7
8
// param1: 数组的长度
// param2: 数组填充值
var fixedArr = List.filled(3, 'val')

// or
// 此时后边必须为String type
var fixedArr = List<String>.filled(3, 'val')

Map

键值对集合

对象式定义
1
2
3
4
5
6
7
8
9
10
11
var person = {
      "name": '张三',
      "age": 18,
      "hobbies": ['打游戏','看小说','看动漫']
}

// 访问对象中的属性
print(person['name']) // 张三

print(person['hobbies']) // ['打游戏','看小说','看动漫']

使用Map实例来定义
1
2
3
4
5
6
7
8
9
10
11
var person = new Map();

person['name'] = '张三';
person['age'] = 20;
person['hobbies'] = ['打游戏','看小说','看动漫']

// 访问对象中的属性
print(person['name']); // 张三

print(person['hobbies']); // ['打游戏','看小说','看动漫']

类型判断

通过使用is属性来判断类型

1
2
3
4
5
6
7
8
9
10
main(){
      var str = '1412321';
      if( str is String ){
            print('String');
      }

      if( str is int ){
            print('Number');
      }
}

运算符

逻辑或(||) 字符 需要特殊处理，不然会被当作表达式显示出来!

类型运算符
算数运算符+、 -、 *、 /、 ~/(取整)、 %(取余)
关系运算符==、 !=、 >、 <、 >=、 <=
逻辑运算符!(取反)、 &&(并且)、 ||(或)
赋值运算符= 、??=、 +=、-=、*=、/=、%=、 ~/=(取整)

条件表达式

if else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if( 条件 ) {

}

//or

if( 条件 ) {
      // 如果
} else {
      // 否则
}

// or
if( 条件 ) {
      // 如果
} else if( 条件2) {
      // 否则
} else {
      // 最终
}

switch

1
2
3
4
5
6
7
8
9
10
11
var sex = '男';
switch(sex){
      case '男':
            print('男');
            break;      
      case '女':
            print('女');
            break; 
      default:
            print('性别');       
}           break;

三目运算符

表达式: 条件 ? 成立 : 不成立;

1
2
3
var score = 60
var result = score > 60 ? '大于60' : '不大于60';
print(result)

?? 运算符

?? 标识 左侧表达式成立 则将左侧结果 赋值于变量，否则就是将右侧的值赋值与变量!

1
2
var age = 20
var result = age ?? 18 // 如果年龄存在就是22 否则默认18

类型转换

String to int or to double

注意：如果 `String`类型的值为 或者 null，解析就会报错! 解析前做一判断控制，若无法解析，则默认为0!

1
2
3
4
5
6
7
8
9
// to int
var str = '12314';
var toInt = int.parse(str);
print(toInt is int)

// to double
var str = '12.12'
var toDouble = double.parse(str);
print(toDouble is double)

Int or double to String

1
2
3
4
5
6
7
8
9
var intVal = 1241
var doubleVal = 12.1

// to String
var result1 = intVal.toString();
var result2 = doubleVal.toString();

print(result1 is String)
print(result2 is String)

to bool 布尔类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 判断是否为空
var str = 'aaa'
if (str.isEmpty){
      print('为空!')     
} else {
      print('不为空!')
}
// 数字为零
var num = 0
if (num == 0){
      print('为零!')     
} else {
      print('不为零!')
}
// 值为null
var value;
if (value == null){
      print('为null!')     
} else {
      print('不为null!')
}
// 值为 isNaN
var result = 0/0;
if (result.isNaN){
      print('为isNaN!')     
} else {
      print('不为isNaN!')
}

循环

for 循环

普通数组

1
2
3
4
5
List arr = ['张三','李四', '王五'];

for( var i = 0; i < arr.length; i++) {
      print(arr[i]);
}

复杂数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
List arr = [{
      "cate": '分类1',
      "news": [{
            "title": '标题1',
            "content": '内容1'
      },{
            "title": '标题2',
            "content": '内容2'
      }],
      "cate": '分类2',
      "news": [{
            "title": '标题1',
            "content": '内容1'
      },{
            "title": '标题2',
            "content": '内容2'
      }]
}];

for( var i = 0; i < arr.length; i++) {
      print(arr[i]['cate'])

      for( var j = 0; j < (arr[i]['news'].length; j++) {
            print(arr[i]['news'][j]['title'])
            if ( arr[i]['news'][j]['title'] == '标题2' ) {
            // 跳出循环
                  break;
            }
      }
       
}

while 循环

满足条件下执行循环

1
2
3
4
5
6
7
8
9
int i = 10;
while(i < 10){
      print(i);
      i++;
      if ( i == 5 ) {
            // 跳出循环
            break;
      }
}

do while 循环

先循环后 在做条件

1
2
3
4
5
int i = 10;
do{
      print(i);
      i++;
}while((i < 10)

`while`循环第一次判断不成立则不做循环操作; `do while`第一条件不关满不满足 都要循环一遍后在做判断条件!

break 和 continue

break 跳出循环后不在进行下一次循环; continue 跳出本次循环进入下一次循环;

集合

List

创建List集合

可包含多类型的一组集合

1
var arr1 = ['张三', '李四', true, age]

可指定类型的一组集合

1
var arr1<String> = ['张三', '李四']

使用 List 创建一个集合

1
2
3
4
List arr1 = ['张三', '李四', true, age]

List arr1<String> = ['张三', '李四']

创建一个固定长度的集合

1
2
3
4
List arr1 = List.filled(2, '')

// 指定类型
List arr1 = List<String>.filled(2, '')

固定长度的集合，不允许添加新的元素! 修改内容的话可以通过下标的方式来修改 `arr1[0] = 张三`

List 常用属性
属性描述
length属性
reversed翻转
isEmpty是否为空
isNotEmpty是否不为空
List 常用方法
方法描述
add增加
addAll拼接数组
indexOf查找
remove删除 具体值
removeAt删除 具体索引值
fillRange修改
insert指定位置(索引)插入
insertAll指定位置(索引)插入 List
toList其他类型转换为 List
joinList 转换为字符串
split字符串转换为 List
forEach迭代器
mapmap 迭代器
where迭代器
any迭代器
every迭代器
add 方法
1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.add('油桃')
addAll 方法

数组合并

1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.addAll(['猕猴桃', '油桃'])
indexOf 方法

传入要查找的具体值，若有返回该值的索引位置，若无则返回-1

1
2
3
4
5
List arr = ['香蕉', '西瓜', '苹果']

arr.indexOf('西瓜') // 1

arr.indexOf('樱桃') // -1
remove 方法

具体值

1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.remove('西瓜') // 删除西瓜
removeAt 方法

具体索引值

1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.remove(2) // 删除苹果
fillRange 方法

修改数组中的元素 fillRange(start, end, [required value])
start 对应的索引值 [‘0-香蕉’,’1-西瓜’,’2-苹果’]
end 对应的具体位置 [‘1-香蕉’,’2-西瓜’,’3-苹果’]

1
2
3
4
5
6
7
8
List arr = ['香蕉', '西瓜', '苹果']

// ['香蕉', '西瓜', '苹果'] -> 索引值 [0, 1, 2]
// start 从索引值 1 开始 -> 到 -> 数组个数截至
// 1 是 ([start 0] = 香蕉) -> ([3 end] = 苹果)
arr.fillRange(1, 3, 'aaa') // ['香蕉', 'aaa', 'aaa']

arr.fillRange(1, 2, 'aaa') // ['香蕉', 'aaa', '苹果']

注意: `start` 为数组索引值

insert 方法

具体索引值 位置下插入新的value! 插入一个值

1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.insert(1,'insert') // ['香蕉', 'insert', '西瓜', '苹果']
insertAll 方法

具体索引值 位置下插入新的[value]! 插入多个值!

1
2
3
List arr = ['香蕉', '西瓜', '苹果']

arr.insertAll(1,['insert1','insert2']) // ['香蕉', 'insert1','insert2', '西瓜', '苹果']
join 方法

参数以字符串,具体将数组以字符串进行分割，最终以字符串格式返回!

1
2
3
4
5
List arr = ['香蕉', '西瓜', '苹果']

arr.join(',') // '香蕉,西瓜,苹果'

arr.join('-') // '香蕉-西瓜-苹果'
split 方法

指定字符将字符串转换为数组!

1
2
3
4
5
6
7
String str = '香蕉,西瓜,苹果';

String str2 = '香蕉-西瓜-苹果';

str.split(',') // ['香蕉', '西瓜', '苹果']

str.split('-') // ['香蕉', '西瓜', '苹果']

Set

创建 Set 集合

Set 集合中的元素可以去重!

1
2
3
4
5
6
7
8
var mySet = new Set();

mySet.add('张三');
mySet.add('李四');
mySet.add('王五');
mySet.add('王五');

print(mySet) // {'张三','李四','王五'}
Set 集合 转 List
1
2
3
4
5
6
7
8
var mySet = new Set();

mySet.add('张三');
mySet.add('李四');
mySet.add('王五');
mySet.add('王五');

print(mySet.toList()) // ['张三','李四','王五']
使用Set来去重List
1
2
3
4
5
6
7
8
9
var arr = ['张三', '李四', '李四', '王五']

var mySet = new Set();

mySet.addAll(arr) // {'张三', '李四', '王五'}

// 转换为 List
mySet.toList() // ['张三', '李四', '王五']

Map

创建一个Map映射
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var person = {
      "name": "张三",
      "age": 18
}

// or

Map person = {
      "name": "张三",
      "age": 18
}
// 修改一个属性值
person["name"] = "李四"

常用的属性
属性名描述
keys获取所有的key值
values获取所有的value值
isEmtpy是否为空
isNotEmpty是否不为空
常用的方法
方法名描述
remove(key)删除指定的key
addAll({…})合并映射 给映射内增加属性
containsValue(value)查看映射的值 返回 true / false

迭代器

for…in

1
2
3
4
5
var arr = ['张三','李四','王五'];

for( item in arr ) {
      print(item)
}

forEach

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var arr = ['张三','李四','王五'];

arr.forEach((value) => {
      print(item)
})

var person = {
      "name": "张三"
}

person.forEach((key, value) => {
      print("$key --- $value")
})

map

1
2
3
4
5
6
7
var arr = ['张三','李四','王五'];

var newArr = arr.map((value) => {
      return "I am $value"
}) // ('I am 张三','I am 李四','I am 王五')

newArr.toList() // ['I am 张三','I am 李四','I am 王五']

where

返回满足条件的数据,相当于JS中的 filter方法!

1
2
3
4
5
6
7
var arr = ['张三','李四','王五'];

var newArr = arr.where((value) => {
      return item === '李四'
}) // ('李四')

newArr.toList()

every

数组每一项都满足条件返回 true 否则 false!

1
2
3
4
5
var arr = ['张三','李四','王五'];

var newArr = arr.every((value) => {
      return item === '李四'
}) // false

any

数组中有一项满足条件返回true 否则false!

1
2
3
4
5
var arr = ['张三','李四','王五'];

var newArr = arr.any((value) => {
      return item === '李四'
}) // true