Dart语言基础

文章目录

• 前言：dart语言简介
• 一、变量
• • 1.1.类型推导
  • 1.2.默认值
  • 1.3.Final 和 const修饰符
• 二、内建类型
• • 2.1.数据类型
  • 2.2.集合的相关操作
• 三、函数
• • 3.1.函数的定义
  • 3.2.箭头函数
  • 3.3.可选函数
  • 3.4.参数默认值
  • 3.5.匿名函数
  • 3.6.词法作用域
  • 3.7.词法闭包
  • 3.7.返回值问题
• 四、运算符
• • 4.1.除法、整除、取模运算
  • 4.2.条件运算符
  • 4.3.级联语法
• 五、循环语句
• 六、类和对象
• • 6.1.类型的定义
  • 6.2.不支持重载
  • 6.3.抽象类
  • 6.4.继承
  • 6.5.隐式接口
  • 6.6.Mixin混入
• 七、泛型
• • 7.1.List泛型
  • 7.2.Map泛型
  • 7.3.泛型方法
• 八、异步
• 九、元数据

---

前言：dart语言简介

Dart是谷歌开发的计算机编程语言，后来被Ecma认定为标准 。它被用于web、服务器、移动应用 和物联网等领域的开发。它是宽松开源许可证下的开源软件。
Dart是面向对象的、类定义的、单继承的语言。它的语法类似C语言，可以转译为JavaScript，支持接口、混入、抽象类、具体化泛型、可选类型和sound type system 。

---

一、变量

1.1.类型推导

创建一个变量并初始化

var name = ‘Bob’;

动态类型(会关闭类型检查）

dynamic name = ’ Bob’;

void main() {
  dynamic name = 'Ronin';
  print(name.runtimeType);
  var name2 = 'Ronin';
  print(name2.runtimeType);
  name = 12;
  print(name.runtimeType);
}

1.2.默认值

var s; //默认为null
print(s);

1.3.Final 和 const修饰符

如果你从未打算改变一个变量，那么可以使用final和const修饰它

final name = 'zsh';
name = 'zms'; // 错误做法

const age = 20;
age = 19; // 错误做法

final和const的区别?

const在赋值时, 赋值的内容必须是在编译期间就确定下来的
final在赋值时, 可以动态获取, 比如赋值一个函数

  String getName() {
    return "zsh";
  }
  main() {
    final name1 = getName(); //正确
    const name2 = getName();  //错误->需要执行函数才能取到值
  }

---

二、内建类型

2.1.数据类型

整数类型 int a = 1；
浮点类型 double = 1.23；
字符串类型 String s = ‘abc’；
布尔类型 bool flag = true；
List集合类型 List list = [‘a’,‘b’,‘c’,‘d’]；
字典(Map)类型 Map<String,String> map2 = {‘name’:‘zsh’,‘age’:‘20’};

main() {
  int a = 1;  //整数类型
  print(a);

  double b = 1.23; //浮点类型
  print(b);

  String s = 'abc'; //字符串类型
  print('$s');

  bool flag = true;   //布尔类型
  print(flag);

  var str1 = ['a','b','c','d'];   //List集合类型，使用类型推导定义
  print('$str1 ${str1.runtimeType}');

  List<String> list = ['a','b','c','d'];  //List定义
  print('$list ${list.runtimeType}');

  var map1 = {'name':'zsh','age':'20'};   //字典类型，使用类型推导定义
  print('$map1 ${map1.runtimeType}');

  Map<String,String> map2 = {'name':'zsh','age':'20'};
  print('$map2 ${map2.runtimeType}');
}

2.2.集合的相关操作

2.2.1、所以集合都支持length属性

main() {
  //1.length属性
  List<String> list = ['a','b','c','d'];
  Map<String,String> map = {'name':'zsh','age':'20'};
  print('${list.length}');
  print('${map.length}');
}

2.2.2、添加，删除，包含操作

main() {
  //1.length属性
  List<String> list = ['a','b','c','d'];
  Map<String,String> map = {'name':'zsh','age':'20'};

  //list
  list.add('e');		//添加
  print('$list');

  list.remove('a');		//删除
  print('$list');

  bool s = list.contains('b');	//是否包含
  print('$s');
  /**
   * ------------------------------------------------
   */
  //map
  Map<String,String> map2 = {'height':'10','weight':'20'};
  map.addAll(map2);			//添加一个map集合
  print('$map');

  map.remove('name');		//删除
  print('$map');

  print('${map.containsKey('age')}');	//包含
}

---

三、函数

3.1.函数的定义

返回值 函数的名称(参数列表) {
函数体
return 返回值
}

String getString() {
  return "zsh";
}
void main() {
  String s = getString();
  print('$s');
}

3.2.箭头函数

void main() {
  List<String> list = ['a','b','c','d'];
  list.forEach((value)=> print('$value'));
}

3.3.可选函数

void copy(String name,{int age,int num }) {
  print('$name $age $num');
}
main() {
  copy('zsh');
  copy('zsh',age:20);
  copy('zsh',age: 20,num: 10);
}

3.4.参数默认值

参数可以有默认值, 在不传入的情况下, 使用默认值
只有可选参数才可以有默认值

copy(String name, {int age = 20, double height=1.3}) {
  print('name=$name age=$age height=$height');
}

3.5.匿名函数

(functio(){
	```
})()

3.6.词法作用域

dart中的词法有自己明确的作用域范围，它是根据代码的结构({})来决定作用域范围的
优先使用自己作用域中的变量，如果没有找到，则一层层向外查找。

var s = 'zsh';
main() {
  font() {
    print('$s');
  }
  font();
}

3.7.词法闭包

闭包可以访问其词法范围内的变量，即使函数在其他地方被使用，也可以正常的访问。

main() {
 makeAdder(num addBy) {
   return (num i) {
     return i + addBy;
   };
 }

 var adder2 = makeAdder(2);
 print(adder2(10)); // 12
 print(adder2(6)); // 8

 var adder5 = makeAdder(5);
 print(adder5(10)); // 15
 print(adder5(6)); // 11
}

3.7.返回值问题

所有函数都返回一个值。如果没有指定返回值，则语句返回null;隐式附加到函数体。

main(List<String> args) {
  print(foo()); // null
}

foo() {
}

---

四、运算符

4.1.除法、整除、取模运算

var num = 7;
print(num / 3); // 除法操作, 结果2.3333..
print(num ~/ 3); // 整除操作, 结果2;
print(num % 3); // 取模操作, 结果1;

4.2.条件运算符

Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2

如果expr1是null，则返回expr2的结果;
如果expr1不是null，直接使用expr1的结果。

var str = 'zsh';
var str= null;
var str= str ?? 'kobe';
print(str);

4.3.级联语法

对一个对象进行连续的操作，这个时候可以使用级联语法

class Shop{
  String name;

  void add() {
    print("${name} is add");
  }

  void update() {
    print("${name} is update");
  }

}

main(List<String> args) {
  final p1 = Shop();
  p1.name = 'zsh';
  p1.add();
  p1.update();

  final p2 = Shop()
              ..name = "zsh"
              ..add()
              ..update()
}

五、循环语句

if 和 else
for循环
while和do-while循环
break和continue
switch和case

六、类和对象

6.1.类型的定义

class 类名 {
类型 成员名;
返回值类型 方法名(参数列表) {
方法体
}
}

class Csrf{
  String name;

  test() {
    print('${name}');
  }
}

6.2.不支持重载

Dart本身不支持函数的重载

class Csrf{
  String name;
  int age;

  Csrf(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

6.3.抽象类

抽象方法，必须存在于抽象类中。
抽象类是使用abstract声明的类。

abstract class AbstractContainer {
  void updateChildren();

6.4.继承

Dart中的继承使用extends关键字，子类中使用super来访问父类。
父类中的所有成员变量和方法都会被继承,，但是构造方法除外。

class Animal {
  String name;
}
class Cat extends Animal {

}

6.5.隐式接口

默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)

abstract class Dog{
  method1();
}

abstract class Cat{
  method2();
}

class Person implements Dog, Cat{
  @override
  method1() {

  }

  @override
  method2() {

  }
}

6.6.Mixin混入

Mixin混入的方式实现多继承

mixin Cat{
  method1() {

  }
}
mixin Dog{
  method2() {

  }
}
class Person implements Cat, Dog{
}

---

七、泛型

7.1.List泛型

List list = [‘zsh’, ‘zms’, ‘user’];
var list = [‘zsh’, ‘zms’, ‘user’];

7.2.Map泛型

Map<String, String> map= {‘name’: ‘zsh’, ‘age’: ‘20’};
var map2 = <String, String>{‘name’: ‘zsh’, ‘age’: ‘20’};

7.3.泛型方法

T first(List ts) {
T tmp = ts[0];
return tmp;
}

main() {
  var names = ['zsh', 'ss'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}');//zsh	String
}

T getFirst<T>(List<T> ts) {
  return ts[0];
}

---

八、异步

Dart是单线程模型

Dart是一个单线程语言.我们在处理耗时操作的时候使用stream或者future来实现
async和await关键字支持异步编程，允许您编写类似于同步代码的异步代码。

九、元数据

使用元数据提供关于代码的附加信息。元数据注释以字符@开头

class Todo {
  final String who;
  final String what;

  Todo(this.who, this.what);
}

import 'todo.dart';

@Todo('seth', 'make this do something')
void doSomething() {
  print('do something');
}