Dart基本语法（一）

Dart基本语法

程序入口

main() {
  print('你好 dart');
}
//方法没有返回值
void main() {
  print('你好 dart');
}

变量数据类型

dart是一个强大的脚本语言，语法类似C，所有的代码都是由变量与方法组成，程序控制结构也包括了顺序结构，判断分支结构与循环结构。

• var
  变量定义可以通过var关键字，不预先定义变量类型，会自动进行类型判断。例如定义var num = 12;系统会自动将num判定为int类型。

main() {
  var str = 'hello';
  var num = 12;
  print(str);
  print(num);
}

• dynamic
  Dart直接支持动态类型，只需要使用dynamic来声明一个变量即可。

main() { 
dynamic str = "hello"; 
print(str); 
str = 20; 
print(str); 
} 

• 数值型：int和double

• 字符串：String
  字符串可以用单引号’’，也可以用双引号""，和其它语言一样，双引号可以内嵌表达式，表达式以$开头，而单引号的字符串不支持。

main() {
  var str1 = "this is str1";
  var str2 = "this is str2";
  print(str1);
  print(str2);
  String str3 = "this is str3";
  print(str3);
  //三个单引号或三个双引号可以打印多行
  String str4 = '''this is str4
  this is str4
  this is str4''';
  print(str4);
  //字符串拼接的两种方法
  print(str1 + str2);
  print("$str1 $str2");
}

• 逻辑值：bool，只有true和false两个取值。
• 数组类型：List
  Dart用范型List来表示数组，同时也可以当成列表来使用。
  通过[]创建的集合长度是可变的

main() {
//创建集合
  var l1 = ["张三", 20, true];
  print(l1);
  print(l1.length);
  //改变集合长度（只能变小，变大会报错）
  l1.length = 2;
  print(l1.length);

//指定集合中数据类型为String
  var l2 = <String>["张三", "李四"];
  l2.add("王五");
  print(l2);

//创建一个空集合
  var l3 = [];
  print(l3);
  print(l3.length);
  l3.add("张三");
  print(l3);

  // var l4 = new List(); //在新版本的Dart里被废弃不能使用

//通过List.filled(集合长度, 数据默认值)创建的集合长度不能修改
  var l5 = List.filled(2, "");
  var l6 = List<String>.filled(2, "");
  //修改集合中数据
  l5[0] = "张三";
  print(l5);
}

• 集合类型：Set，跟其他语言一样，其中的元素值只能有一个，不可重复。
• Map：key-value映射，使用方式跟JS中的JSON类型类型

main() {
  var person = {
    "name": "张三",
    "age": 20,
    "work": ["程序员", "外卖员"],
  };
  print(person);
  print(person["age"]);
  print(person["work"]);

  var person1 = new Map();
  person1["name"] = "李四";
  person1["age"] = 22;
  person1["work"] = ["程序员", "外卖员"];
  print(person1);
}

is关键字类型判断

main() {
  var str = '123';
  if (str is String) {
    print('是String类型');
  } else if (str is int) {
    print('是int类型');
  } else {
    print('其他类型');
  }
}

Dart常量const和final

main() {
  //const常量
  const PI = 3.14159;
  print(PI);
  //final常量
  final PI1 = 3.14159;
  print(PI1);
  final a = new DateTime.now();
  print(a);
  /*
  const a = new DateTime.now();会报错
  */
}

const和final区别：final可以开始不赋值，只能赋一次；final不仅由const编译时常量的特性，最重要的是它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化。

变量的命名规则

• 变量名称必须由数字，字母，下划线，美元符（$）组成
• 标识符开头不能是数字
• 标识符不能是保留字和关键字
• 变量名称区分大小写

运算符

• 算术运算符（+，-，*，/，%，～/（取整））
• 关系运算符（==,!=,>,<,>=,<=）
• 逻辑运算符（！，&&，||）
• 赋值运算符
  – 基础赋值运算符（=，？？=）
  在赋值运算里面，如果++写在前面，这时候先运算在赋值，++写在后面，先赋值在运算。
  – 自增自减运算符（++，–）
  – 复合运算符（+=，-=，*=，/=，%=，～/=）
  ？？= 如果变量没有赋值才进行赋值，否则不进行赋值

main() {
  int b;  //这种写法在编译运行时会报错
  b ??= 23;
  print(b);
}

main() {
  var a = 10;
  var b;
  a ??= 15;
  b ??= 23;
  print(a);
  print(b);
}

• 条件表达式
  if else ; switch case ;
  三目运算符（b?x:y）:如果b的值为true，计算x的值，运算结果为x的值;否则，计算y的值，运算结果为y的值。
  ??运算符: 如果变量没有赋值才进行赋值，否则不进行赋值

main() {
  var a;
  var c = 15;
  var b = a ?? 10;
  var d = c ?? 20;
  print(b);
  print(d);
}

类型转换

• Number和String类型转换

String类型转换为Number类型 int.parse()

main() {
  String str = '123';
  String str1 = '123.1';
  String str2 = '';
  var myNum = int.parse(str);
  var myNum1 = double.parse(str1);
  print(myNum is int);
  print(myNum1 is double);
  //判断异常，保证不能正常转换时程序依然能够运行
  try {
    var myNum2 = int.parse(str2);
    print(myNum2);
  } catch (err) {
    print(0);
  }
}

Number类型转换为String类型 toString()

main() {
  var myNum = 12;
  var str = myNum.toString();
  print(str is String);
}

• 其他类型和Booleans类型转换
  isEmpty（）：判断字符串是否为空

main() {
  var str = '';
  if (str.isEmpty) {
    print('str空');
  } else {
    print('str不为空');
  }

  var myNum = 123;
  if (myNum == 0) {
    print('0');
  } else {
    print('非0');
  }

  var myNum1;
  if (myNum1 == null) {
    print('空');
  } else {
    print('非空');
  }

  var myNum2 = 0 / 0;
  if (myNum2.isNaN) {
    print('NaN');
  }
}

循环结构

• for循环

main() {
  List list = [
    {"title": "新闻111"},
    {"title": "新闻222"},
    {"title": "新闻333"}
  ];
  for (int i = 0; i < list.length; i++) {
    print(list[i]["title"]);
  }

  List list1 = [
    {
      "create": "国内",
      "news": [
        {"title": "国内新闻1"},
        {"title": "国内新闻2"},
        {"title": "国内新闻3"},
      ]
    },
    {
      "create": "国际",
      "news": [
        {"title": "国际新闻1"},
        {"title": "国际新闻2"},
        {"title": "国际新闻3"},
      ]
    }
  ];
  for (var i = 0; i < list1.length; i++) {
    print(list1[i]["create"]);
    print("----------------");
    for (var j = 0; j < list1[i]["news"].length; j++) {
      print(list1[i]["news"][j]["title"]);
    }
  }
}

• while(){}
• do{}while();
  do–while和while区别，第一次循环条件不成立时，不管满不满足条件，do–while都会执行一次。
• continue和break关键字
  continue跳出当前循环，继续进行下一次循环，break直接跳出循环，不再执行循环。

集合详解

list集合

集合常用属性

length 长度
isEmpty 判空
isNotEmpty 判断非空
reversed 对集合倒序排序

main() {
  List list = ['香蕉', '苹果', '西瓜'];
  print(list.length);
  print(list.isEmpty);
  print(list.isNotEmpty);
  print(list.reversed); //注意转换后得到的不是集合
  var newList = list.reversed.toList();
  print(newList);
}

集合常用方法

  List list = ['香蕉', '苹果', '西瓜'];

add 增加

 list.add('桃子'); //增加一个数据

addAll(一个集合) 拼接数组

  list.addAll(['葡萄', '哈密瓜']); //拼接数组

indexOf（value） 查找 传入具体值(返回下标位置，不存在返回-1)

list.indexOf('葡萄')

remove（索引值） 删除 传入具体值

list.remove('香蕉');

removeAt（索引下表） 删除 传入索引值

  list.removeAt(2);

fillRange（start,end） 修改下标start到end-1的值为空
fillRange（start,end，value） 修改下标start到end-1的值为value

  list.fillRange(1, 3,'aaa');

insert(index,value) 指定位置下标index前插入数据

  list.insert(1, 'bbb');

insertAll(index,list) 指定位置下标index前插入List

  list.insertAll(1, ['ccc', 'ddd']);

jion(s) List转化为字符串，集合中的元素以s连接

  var str = list.join('-');

split(s) 字符串以s分割转化为List，分割的每部分为集合的一个元素

  str = '苹果-ccc-ddd-bbb-aaa-aaa-哈密瓜';
  var list1 = str.split('-');

main() {
  List list = ['香蕉', '苹果', '西瓜'];
  list.add('桃子'); //增加一个数据
  print(list);
  list.addAll(['葡萄', '哈密瓜']); //拼接数组
  print(list);
  print(list.indexOf('葡萄'));
  list.remove('香蕉');
  list.removeAt(2);
  print(list);
  list.fillRange(1, 3, 'aaa');
  print(list);
  list.insert(1, 'bbb');
  print(list);
  list.insertAll(1, ['ccc', 'ddd']);
  print(list);
  var str = list.join('-');
  print(str);
  var list1 = str.split('-');
  print(list1); 
}

toList() 其他类型转换为List

main() {
  List list = ['香蕉', '苹果', '西瓜', '香蕉', '苹果', '香蕉', '西瓜'];
  var s = new Set();
  s.addAll(list);
  print(s);
  print(s.toList());
}

Set集合

Set是没有顺序且不能重复的集合，所以不能通过索引去获取值，它的主要功能是去除数组重复内容

//验证Set集合不存在重复数据
main() {
  var s = new Set();
  s.add('香蕉');
  s.add('苹果');
  s.add('苹果');
  print(s);
}

list集合去重

main() {
  List list = ['香蕉', '苹果', '西瓜', '香蕉', '苹果', '香蕉', '西瓜'];
  var s = new Set();
  s.addAll(list);
  print(s);
  print(s.toList());
}

Map类型详解

创建Map两种方法

main() {
  var person = {
    "name": "张三",
    "age": 20,
  };
  print(person);
  var m = new Map();
  m["name"] = "李四";
  print(m);
}

常用属性

  var person = {
    "name": "张三",
    "age": 20,
  };

keys 获取所有的key值

person.keys
//还可以转换为集合
person.keys.toList()

values 获取所有的value值

person.values
//还可以转换为集合
person.values.toList()

isEmpty 是否为空
isNotEmpty 是否不为空

main() {
  var person = {
    "name": "张三",
    "age": 20,
  };
  print(person.keys);
  print(person.keys.toList());
  print(person.values);
  print(person.isEmpty);
  print(person.isNotEmpty);
}

常用方法

addAll({…}) 合并映射 给映射内增加属性

  person.addAll({
    "sex": "男",
    "work": ['敲代码', '送外卖'],
  });

remove(key) 删除指定key的数据

  person.remove("sex");

containsKey 查看映射内的键 返回true/false

person.containsKey("sex")

containsValue 查看映射内的值 返回true/false

person.containsValue("张三")

main() {
  var person = {
    "name": "张三",
    "age": 20,
  };
  person.addAll({
    "sex": "男",
    "work": ['敲代码', '送外卖'],
  });
  print(person);
  person.remove("sex");
  print(person);
  print(person.containsKey("sex"));
  print(person.containsValue("张三"));
}

循环遍历的方法

List循环遍历(Set用法和List相同)

List list = ['香蕉', '苹果', '西瓜'];

for循环

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

  for (var item in list) {
    print(item);
  }

for each

  list.forEach((value) {
    print("$value");
  });

map方法修改集合数据

   //第一种写法
  var newList = list.map((e) => e * 2);
  //第二种写法
  var newList1 = list.map((value) {
    return value * 3;
  });
  //注意返回的不是集合，需要转为集合
  newList.toList();

where返回满足条件的元素组成的集合

//返回大于三的元素组成的集合
  var newList2 = list.where((element) => element > 3);
  var newList1 = list.where((value) {
    return value > 3;
  });
  newList1.toList();

any 集合中存在满足条件的元素就返回true

  var newList2 = list.any((element) => element > 3);
  var newList1 = list.any((value) {
    return value > 3;
  });

every 集合中所有元素都满足条件返回true

  var newList2 = list.every((element) => element > 3);
  var newList1 = list.every((value) {
    return value > 3;
  });

main() {
  List list = [2, 3, 4];
  for (var i = 0; i < list.length; i++) {
    print(list[i]);
  }
  for (var item in list) {
    print(item);
  }
  list.forEach((value) {
    print("$value");
  });
  var newList = list.map((e) => e * 2);
  var newList1 = list.map((value) {
    return value * 3;
  });
  print(newList);
  print(newList1);
  var newList2 = list.where((element) => element > 3);
  print(newList2.toList());
  var f = list.any((element) => element > 3);
  print(f);
  var f2 = list.every((element) => element > 3);
  print(f2);
}

Map循环遍历

Map的foreach方法比List多一个参数

main() {
  Map person = {"name": "张三", "age": 20};
  person.forEach((key, value) {
    print("$key---$value");
  });
}