Dart个人学习笔记（上）

最新推荐文章于 2024-05-04 17:54:50 发布

xsepower

最新推荐文章于 2024-05-04 17:54:50 发布

阅读量255

点赞数

分类专栏： Dart 文章标签： dart 编程语言 android

本文链接：https://blog.csdn.net/xsepower/article/details/117554423

版权

Dart 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Dart教程

一、Dart简介

入口方法介绍

//这是一个简单的main方法
main(){
	
}

//表示main方法没有返回值
void main(){

}

注释方法

//ss

/*
ss
*/

///ss

变量

dart是一个强大的脚本类型语言，可以不预先定义变量类型，自动会类型推导
可以通过var关键字声明变量

也可以用类型关键词声明，如：

var str = 'this is a var';
Srting str2 = 'this is a var';
int num3 = 123;

常量

用const或final关键字声明

const值不变，一开始就得赋值
final可以开始不赋值，只能赋一次
两者区别：final比const更强大，final不仅有const编译时常量的特性，更重要的是它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化。
常量在定义后不可以改变值

const num1 = 1234;
final num2 = 2345;

//另外final可以这样用，const不可以
final a = new DateTime.now();
print(a);
//结果：2021-05-13 10:15:17.378402

//final可以开始不赋值
final a;
a = new DateTime.now();
print(a);

命名规则

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

二、数据类型

Dart中支持以下数据类型：

常用数据类型：
- Numbers（数值）：int，double
- Strings（字符串）：String
- Booleans（布尔）：bool
- List（数组）：在Dart中，数组是列表对象，所以大多数人只是称他们为列表
- Maps（字典）：Map是一个键值对相关的对象，
项目中用不到的数据类型：
- Rune：UTF-32编码的字符串，可以通过文字转换成符号表情或者代表特定的文字
- Symbol：表示在程序中声明的运算符或标识符

1. 字符串类型

字符串的定义

//单、双引号命名
String str1 = 'this is str1';
String str2 = "this is str2";

//三个引号（单/双都可以）命名，其中可以放多行字符串
String str3 = '''this is str1
this is str2
this is str3
''';

字符串拼接

String str1 = 'hello';
String str2 = 'Dart';

//print("$str1 $str2");
  
//print(str1 + str2);

2. 数值类型

int是整型，double可以加整型，也可以加浮点型
运算符：加减乘除

3. 布尔类型

只有true、false两个值

bool flag = true;
print(flag);

条件判断语句

bool flag = true;
  if (flag) {
    print('真');
  } else {
    print('假');
  }

4. List（数组/集合）类型

List初始化

直接创建

var l1 = [123, 'two', true];

print(l1);
print(l1.length);
print(l1[1]);

指定类型：在List前加一个尖括号里加上字符类型，元素就只能是这种类型
```
var l1 = <String>['123', 'two', 'true'];
```

固定长度：length参数是长度，fill参数是填充内容

//利用List.filled方法
var l6 = List.filled(length,fill);

//示例
var testList = List.filled(2, 'test');
print(testList);

//修改数据内容
testList[1] = '1234';

//固定长度的List没法修改长度
testList.length = 0;//会报错

//固定长度的指定类型
var testList = List<String>.filled(2,"")

注意：在新版本中，这种定义List的方法被废弃，但是在flutter2.x可以使用
```
var l6 = new List();//会报错
```

增加数据

var l2 = [];

print(l2);
print(l2.length);//此时是空集合，所以length理所应当也是0
l2.add('张三');
l2.add('李四');

print(l2);//数据添加到末尾，所以内容为[张三,李四]

//同样非空集合也可以增加数据
var l5 = [20, true, 262];
l5.add("value");
print(l5);

修改长度

//对于没有固定长度的List，可以通过这种方式修改长度
var testList = [123, 456];

testList.length = 0;

print(testList);//[]
print(testList.length);//0

常用属性及方法

/*
常用属性：
length 长度
reversed 翻转
isEmpty 是否为空
isNotEmpty 是否不为空

常用方法：
add 增加（增加一个数据）
addAll 拼接数组（增加多个数据）
indexOf 查找 传入具体值（查找不到返回-1，查到到返回索引值）
remove 删除 传入具体值（直接指定某个数据）
removeAt 删除 传入索引值（指定数据在List里的位置）
fillRange 修改
insert(index,value) 指定位置插入（插入单个数据）
insertAll(index,list) 指定位置插入List（插入多个数据）
toList 其他类型转换成List
join List转换成字符串
split 字符串转换成List
*/

//length属性---------------------- 
List myList = [1, 2, 3];
  print(myList.length);//3

//indexOf方法---------------------- 
List myList = [1, 2, 3];
print(myList.indexOf(4));//-1
print(myList.indexOf(3));//2

//remove方法---------------------- 
List myList = [1, 2, 3];
myList.remove(2);
print(myList);//[1,3]

//removeAt方法----------------------
List myList = [1, 2, 3];
myList.removeAt(2);
print(myList);//[1,2]

//fillRange方法---------------------- 
List myList = [1, 2, 3];
myList.fillRange(1, 2, 'aaa');//在1,2位置之间替换成'aaa'
print(myList);//[1, aaa, 3]

//join方法---------------------- 
List myList = [1, 2, 3];
var str = myList.join('-');//转换成字符串，并用-连接
print(str);//1-2-3
print(str is String);//ture 判断结果是字符串

5.Map类型

有点类似JavaScript中的Json对象
这里的key值必须加引号

定义Map的方法

//定义方法1
var person = {"name": "John Wick", "age": 18};

//定义方法2
var person = new Map();

person["name"] = "John Wick";
person["age"] = "40";
person["work"] = ["assassin", "killer"];

访问Map中的值

//访问Map中的值
print(person["name"]);

//dart中不能用person.name这种形式访问

Map的常用属性及方法

/*
常用属性
keys 获取所有的key值
values 获取所有的value值
isEmpty 是否为空
isNotEmpty 是否不为空

常用方法
remove(key) 删除指定key的数据
addAll({...}) 合并映射 给映射内添加属性
containsValue 查看是否有这个value值 返回true/false
*/

//---------------------- 
Map person = {'name': 'johnwick', 'age': 50, 'job': 'killer'};
print(person.keys); //(name, age, job)
print(person.values.last); //killer，也可以在后面加属性使用

//containsValue---------------------- 
Map person = {'name': 'johnwick', 'age': 50, 'job': 'killer'};
print(person.containsValue('killer')); //true

几种通用类型的方法

forEach  map  where  any  every

遍历内容–forEach

//方法1
List l1 = [1, 2, 3];
for (var i = 0; i < l1.length; i++) {
    print(l1[i]);
}

//方法2
for (var item in l1) {
    print(item);
}

//---------------------- 
//forEach
//在List中使用，参数只能写value一个内容
List l1 = [1, 2, 3];

l1.forEach((value) {
    print("$value");
});/*
1
2
3
*/

//在Map中使用，参数需要写(key,value)
Map m1 = {'name': 'john', 'age': '50', 'work': 'worker'};

m1.forEach((key, value) {
    print(('$key:$value'));
});/*
name:john
age:50
work:worker
*/

遍历并修改内容–map（将数字加倍）

//一般方法
List l1 = [1, 2, 3];
List l2 = [];
for (int i = 0; i < l1.length; i++) {
    l2.add(l1[i] * 2);
}
print(l2);//[2, 4, 6]

//---------------------- 
List l1 = [1, 2, 3];
var newList = l1.map((value) {
    return value * 2;
});
print(newList);//(2, 4, 6)

满足条件的返回新的集合

List l1 = [1, 2, 3, 5, 7, 8, 9, 11];
var l2 = l1.where((value) {
    return value >= 5;
});
print(l2);//(5, 7, 8, 9, 11)

是否有满足条件的内容

//any 只要有一个满足就true
List l1 = [1, 2, 3, 5, 7, 8, 9, 11];
  var f = l1.any((element) {
    return element >= 5;
  });
  print(f);//true

//----------
List l1 = ['name', 'age', 'work'];
var f = l1.any((element) {
	return element == 'age';
	});
print(f);//true

//---------------------- 
//every 每一个都满足才是true
List l1 = ['name', 'age', 'work'];
var f = l1.every((element) {
    return element is String;
});
print(f);//true

6. Set类型

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

新建一个Set

var s = new Set();
s.add('a');
s.add('b');
s.add('c');
s.add('a');
print(s);//{a,b,c}，即重复的数据没有被添加进去
print(s is List);//false
print(s is Map);//false
print(s is Set);//true

Set的去重

//将一个List通过变为Set类型的方式去重
List l1 = [1, 2, 3, 4, 2, 1];
var s1 = l1.toSet();
print(s1);//{1, 2, 3, 4}
print(s1 is Set);//true

7. 类型判断

is关键字来判断类型

var str = true;
if (str is String) {
    print('this is a string');
    } else {
        print('this is other type');
    }

8.运算符

算术运算符

+ - * / //加减乘除
% //其余
~/ //取整
    
//----------------------    
print(10 % 3); // 1
print(20 ~/ 3);// 6

关系运算符

主要用在条件判断里

> < //大于，小于
>= <= //大于等于，小于等于
== ！= //相等，不等   

//---------------------- 
print(3 == 5); //false
print(4 == 4); //true

//---------------------- 
int a = 3;
int b = 5;
if (a > b) {
    print('a大于b');
} else if (a == b) {
    print('a等于b');
} else {
    print('a小于b');	//a小于b

逻辑运算符

! //取反
&& //且：全为true，结果为true，其他为false
|| //或：全为false，结果为false，其他为true
    
//---------------------- 
bool str1 = true;
bool str2 = false;

print(!str1); //false
print(str1 && str2); //false
print(str1 || str2); //true

赋值运算符

= ??=//基础赋值运算符
// ??=的意思是如果这个变量没有值的话，则赋值给他

int a = 10; //a=10
int b = 

+= -= *= /= %= ~/= //复合赋值运算符

条件表达式

if…else…

switch…case…

if...else 
switch...case...(default...)
    
//------if...else--------    
bool flag = true;
if (flag) {
  print('is true');
} else {
  print('is false');
} //true

//-----switch...case------ 
var sex = '男';

switch (sex) {
	case '男':
        print('男生');
        break;
    case '女':
        print('女生');
        break;
    default:
        print('输入错误');
        break;//男生

//----------------------

三目运算符（又称条件运算符）

可以简化只有两种选择的运算，结果是正确的，就会选择

/*语句结构：
(条件) ? (判断正确的结果) : (判断错误的结果);
*/
//----以下两种表达式等效----- 
var x = 10;
  if (x > 0) {
    x = 20;
  } else {
    x = -20;
  }

//----------
var x = 10;
  (x > 0) ? (x = 20) : (x = -20);
  print(x);

var x = 34;
  (x > 0) ? (print('x是大于0的')) : (print('x是小于0的'));
//x是大于0的

??运算符

也是判断一个变量是否为空

 var a;
  var b = a ?? 10;//判断a是否为null，是则赋值10，否则不赋值。
  print(b); //10
  print(a); //null

9.类型转换

Number与String之间转换

Number→String: toString()
String→Number: parse()

//----------String→Number------------ 
String str = '123';
var myNum = int.parse(str);
print(myNum);//123

String str = '123.23';
var myNum = double.parse(str);
print(myNum);//123.23
//---------------------- 
//如果遇到数据可能为空的情况下，可以用try...catch
try {
    String str = ' ';
    var myNum = double.parse(str);
    print(myNum);
  } catch (error) {
    var myNum = 0;
    print(myNum);
  }
//----------Number→String------------ 
int num1 = 123;
var str = num1.toString();
print(str is String);//true

其他类型和boolean类型的转换

isEmpty&isNotEmpty：判断字符串是否为空

var str = '';
  if (str.isEmpty) {
    print('str is empty');
  } else {
    print('str is not empty'); //str is empty
//数字可以用==null来代替
var myNum;
  if (myNum == null) {
    print('myNum is null');
  } else {
    print('myNum is not null');
  } //myNum is null
//----------------------
//其他的判断语句起到的也是同样的作用，主要是用 is、==、?=等判断

三、循环语句

首先先复习一下自增/自减运算符

++ –
在赋值运算中，运算符放在前面后面有区别
- 运算符在后面表示先运算，后赋值
- 运算符在前面表示先赋值，后运算
但是在其他地方，就没有区别


var a = 10;
var b = a++;
print('$a $b'); //11 10
//---------------------- 
var a = 10;
var b = ++a;
print('$a $b'); //11 11
//---------------------- 
var a = 10;
++a; //11

for循环

//输出1-10的数字
for (int i = 1; i <= 10; i++) {
    print(i);
  }

//---------------------- 
//输出1-20的偶数
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
      print(i);
    }
  }

//---------------------- 
//输出1到100的和
var sum = 0;
  for (int i = 1; i <= 100; i++) {
    sum += i;
  }
print(sum);//5050

//---------------------- 
//遍历一个List
Li//----------------------  0; i < l1.length; i++) {
    print(l1[i]);
  } 

//---------------------- 
//访问List中，Map中的元素
List l1 = [
    {'name': 'a', 'age': 18},
    {'name': 'bb', 'age': 14},
    {'name': 'ccc', 'age': 12}
  ];
  for (int i = 0; i < l1.length; i++) {
    print(l1[i]['name']);
  }


//---------------------- 
//访问一个二维数组里的内容
/*
需要打印出的内容：
国内
	国内新闻1
	国内新闻2
	国内新闻3
国际
	国际新闻1
	国际新闻2
	国际新闻3
*/
//思路：需要循环体嵌套，首先是“国内”和“国外”，需要用循环体打印出来。然后在每个循环下面，分别打印出来新闻1，2，3。
List l1 = [
  {
    'cate': '国内',
    'news': [
      {'title': 'news1'},
      {'title': 'news2'},
      {'title': 'news3'}
    ]
  },
  {
    'cate': '国外',
    'news': [
      {'title': 'internews1'},
      {'title': 'internews2'},
      {'title': 'internews3'}
    ]
  }
];

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

  for (int j = 0; j < l1[i]['news'].length; j++) {
    print(l1[i]['news'][j]['title']);
  }
}

while，do…while循环

语法格式如下：

while(表达式/循环条件){
	语句/循环体
}

do{
	语句/循环体
}while(表达式/循环体);
//显而易见，while是先通过条件，再循环；do...while是先进行循环体，在条件判断

注意：

最后的分号不要忘记
循环条件中使用的变量需要初始化
循环体汇总，应有结束循环的条件，否则会造成死循环。
区别：
- while是先进行一次判断，满足条件进行循环；
- do…while是先进行一次循环体，再判断，如果不满足，停止循环。

//打印1-10
int i = 1;
while (i <= 10) {
  print(i);
  i++;
}

//---------------------- 
//打印1-100的和
int i = 1;
int sum = 0;
while (i <= 100) {
  sum += i;
  i++;
}
print(sum);
//----------------------

swicth…case

case表达式是必须的
case语句只能包含常量，不能是变量或表达式
default 是可选的

var grade = 'C';
  switch (grade) {
    case 'A':
      {
        print('A级');
      }
      break;

    case 'B':
      {
        print('B级');
      }
      break;

    default:
      {
        print('没有结果');
      }
  }

break、continue

break语句的作用
- 在switch语句中使流程跳出switch结构
- 在循环语句中使流程跳出当前循环，遇到break循环终止，后面代码也不会执行。
- 如果在循环中已经执行了break语句，那就不会执行循环体中的位于break后的语句
- 在多层循环中，一个break语句只能向外跳出一层
- break可以用在switch…case中，也可以用在for循环和while循环中
continue语句的功能
- 跳过本次循环
- 【注】：只能在循环语句中使用，使本次循环结束，即跳过循环体从下面尚未执行的语句，接着进行

//打印1-10的值，如果i=4就跳过
for (int i = 1; i <= 10; i++) {
    if (i == 4) {
      continue; //跳过本次循环
    }
    print(i);
  }


//---------------------- 
//打印1-10的值，遇到4就停止打印
for (int i = 1; i <= 10; i++) {
    if (i == 4) {
      break;
    }
    print(i);
  }


//---------------------- 
//演示break只能跳出一层
for (int i = 1; i <= 5; i++) {
    print('外层---$i');

    for (int j = 1; j <= 3; j++) {
      if (j == 2) {
        break;
      }
      print('里层$j');
    }
  }
/*
外层---1
里层1
外层---2
里层1
外层---3
里层1
外层---4
里层1
外层---5
里层1
*/