文章目录
前言：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');
}
