Dart介绍

Dart是由谷歌开发的计算机编程语言,它可以被用于web、服务器、移动应用和物联网等领域的开发。
Dart诞生于2011年，号称要取代JavaScript
要学Flutter的话我们必须首先得会Dart。
官网：dart.dev/

Dart环境搭建

要在我们本地开发Dart程序的话首先需要安装Dart Sdk

官方文档：dart.dev/get-dart

windows(推荐):

www.gekorm.com/dart-window…

mac：如果mac电脑没有安装brew这个工具首先第一步需要安装它： brew.sh/

brew tap dart-lang/dart

brew install dart

Dart的命名规则

1.变量名称必须由数字、字母、下划线和美元符($)组成。

2.注意：标识符开头不能是数字

3.标识符不能是保留字和关键字。

4.变量的名字是区分大小写的如: age和Age是不同的变量。在实际的运用中,也建议,不要用一个单词大小写区分两个变量。

5.标识符(变量名称)一定要见名思意：变量名称建议用名词，方法名称建议用动词

Dart 变量

dart是一个强大的脚本类语言，可以不预先定义变量类型，自动会类型推倒

dart中定义变量可以通过var关键字可以通过类型来申明变量

dart内置类型校验

    var str='this is var';

    String str='this is var';

    int str=123;

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

String(字符串)

定义几种方式

 var str1='string'; 
 String str2='string'; 

 var str3 ='''fdssfsdf
 sfsfsdf'''; //三个单引号和双引号可以换行

字符拼接

变量可以直接使用 $str 运算符可以使用$ {str1*2}

  int a = 2;
  print("$str1 $str2"); 
  print(str1+str2); 
  print("${a*2}");

属性介绍

根据索引获得字符

const str = '123456';
print(str[1]); //2
str.length // 6

isEmpty字符串是否是空的

const str = '123456';
print(str.isEmpty);//false
print(''.isEmpty); // true

isNotEmpty字符串是否不是空的

const str = '123456';
print(str.isNotEmpty); //true
print(''.isNotEmpty);  // false

runes字符串Unicode代码的可迭代对象

const str = '123456';
print(str.runes); //(49, 50, 51, 52, 53, 54)

codeUnits字符串的UTF-16代码单元列表

const str = '123456';
print(str.codeUnits); //[49, 50, 51, 52, 53, 54]

hashCode根据代码单元生成的哈希码

const str = '123456';
print(str.hashCode); // 788018113

runtimeType对象运行时的类型

const str = '123456';
print(str.runtimeType);  // String

方法介绍

字符串比较

相同返回0 不同返回-1

const str = 'abc';
print(str.compareTo('abc')); //0 相同
print(str.compareTo('abcd'));// -1 不同

大小写转换

const str = 'abc';
const str1 ='ABC';
print(str.toUpperCase()); //大写 abc>ABC
print(str1.toLowerCase()); //小写 ABC>abc

截取字符串(开头索引和结尾索引)

String str = 'abcdef';
print(str.substring(0, 3)); // abc 从下标0开始到下标3结束截取不包括下标3

// 只有开头索引, 默认截取到最后
print(str.substring(2)); // cdef

拆分字符串

String str = 'ab,cd,ef';
print(str.split(',')); //[ab, cd, ef]
print(str.split(new RegExp(r"c"))); //[ab,, d,ef]

去\t\t tab空格和换行符

String str = '\t\tab  ce\n';
print(str.trim()); //ab ce
//去掉字符串开头的tab空格和换行符

str.trimLeft() 

// 去掉字符串结尾的tab空格和换行符
str.trimRight()

Number int和double

int 必须是整型不支持小数

double 既可以是整型也可是浮点型

int常用的判断属性

是否为负数

大于0即为false

int num = 12;
print(num.isNegative);//false
print(0.isNegative);//false

是否是有限的

int num = 12;
print(num.isFinite); //true

是否是无穷大或者无穷小

int num = 12;
print(num.isInfinite); //false

是否为偶数

int num = 12;
print(num.isEven); //true

是否为奇数

int num = 12;
print(num.isOdd); //false

是否是NaN值

int num = 12;
print(num.isNaN); //false

int数字类型中常用的函数

获取绝对值

int num = -12;
print(num.abs()); //12

转成字符串

int num = -12;
print(num.toString()); //-12

幂次求模

// num的4次幂, 在对num的四次幂求模
int num = 2;
print(num.modPow(4, 2)); //0

比较大小

// 比较大小, 0:相同、1:大于、-1:小于
int num = 2;
print(num.compareTo(30)); // -1

转成double

int num = 2;
print(num.toDouble());//2.0

返回余数

// num/5的余数
int num = 10;
print(num.remainder(5)); //0

最大公约数

// num和16的最大公约数
int num = 10;
print(num.gcd(16)); //2

double类型属性

是否是NaN值

double num = 12.23;
print(num.isNaN); //false

根据代码单元生成的哈希码

double num = 12.23;
print(num.hashCode); //11388478633041204

double类型相关方法的使用

四舍五入

round() 取整

ceil() 向上取整

floor() 向下取整

toStringAsFixed(2) 保留指定的小数位数(四舍五入), 不足补0, 字符串返回

toStringAsPrecision(10) 保留变量的位数(小数点前后的总位数), 不足补0, 多余的四舍五入

类型转换

int -> double

 double b = a.toDouble();

double ->int

 int d = c.toInt();

String -> int

 int one = int.parse('1'); // 1

String -> double

 double onePointOne = double.parse('1.1'); // 1.1

String -> double

 double onePointOne = double.parse('1.1'); // 1.1

int -> String

  String oneAsString = 1.toString(); //'1'

double -> String

 String piAsString = 3.14159.toStringAsFixed(2); //3.14

常量 final 和 const修饰符

const值不变一开始就得赋值

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

 const PI=3.14159;
 PI=123.1243; //错误的写法 常量不可以修改
 print(PI);
 final PI=3.14159;
 PI=124214.214124;   //错误写法
 print(PI);


 const str3=new DateTime.now(); 报错
 final str3=new DateTime.now();

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

bool类型

Dart 使用 bool 类型表示布尔值。 Dart 只有字面量 true and false 是布尔类型，这两个对象都是编译时常量

List 数组/集合

List定义方式

设置了参数length(length不能为负数或null)，创建的List是固定长度的元素可修改, 元素个数不可修改, 不能删除和增加元素

var l1 = new List(3);  //[null, null, null]
print(l1.length);  //3

未设置参数length，那么List的长度是0，并且是可增长的

// 这两种方式一样
var l10 = new List();
var l11 = [];

l10.length = 3;
l10.add(1);

使用指定长度创建一个可增长的List时，仅仅在刚创建后分配长度

List growableList = new List()..length = 500;

3、定义List指定类型

  var l3 = new List<String>();

  l3.add('张三');

  l3.add('123');

  print(l3);

方法

添加元素

arr1.add(5);
// 添加一个数组
arr1.addAll([10, 12]);

查找

是否包含某元素

List arr2 = ['1', '2', '3', '4', '5'];
print(arr2.contains('1'));  // true

判断数组是否有满足条件的元素

List arr2 = ['one', 'two', 'three', 'one', 'four'];
print(arr2.any((item) => item.length > 4));  // true

判断数组是否所有元素都满足条件

List arr2 = ['one', 'two'];
print(arr2.every((item) => item.length ==3));  // true

List转化为Map类型

索引作为Key值，对应的元素作为Value

List arr2 = ['one', 'two'];
print(arr2.asMap());  // {0: one, 1: two}

随机打乱List中的元素

List arr2 = ['one', 'two', 'three', 'one', 'four'];
arr2.shuffle();
print(arr2);   // [three, one, two, four, one]

获取元素对应的索引值, 默认从索引0开始

List arr2 = ['one', 'two', 'three', 'one', 'four'];
print(arr2.indexOf('one'));  // 0

// 从第2个索引开始查找

print(arr2.indexOf('one', 2));  // 3


// 如果找不到, 返回-1

print(arr2.indexOf('five'));  // -1

// 获取元素对应的索引值, 从后往前找

print(arr2.lastIndexOf('one'));
print(arr2.lastIndexOf('one', 3));
print(arr2.lastIndexOf('five'));

返回满足条件的第一个元素

List arr2 = ['one', 'two', 'three', 'one', 'four'];

print(arr2.firstWhere((item) => item == 'one'));

截取新的List

包含从start（包括）到end（不包括）的对象, 原数组不变

List arr2 = ['one', 'two', 'three', 'one', 'four'];
print(arr2.sublist(1, 3)); // [two, three]
// 不指定end, 默认到数组结尾
print(arr2.sublist(2)); // [three, one, four]

数组拼接成字符串

List arr2 = ['one', 'two', 'three', 'one', 'four'];
print(arr2.join());      //onetwothreefour
print(arr2.join('-'));   //one-two-three-four

截取count之后的元素

arr2 = ['one', 'two', 'three', 'four'];
print(arr2.skip(2)); // (three, four)

截取最初的count元素

List arr2 = ['one', 'two', 'three', 'one', 'four'];
print(arr2.take(2)); // (one, two)

返回所有不符合该条件的元素

arr2 = ['one', 'two', 'three', 'four'];
print(arr2.skipWhile((item) => item.length == 3));  //(three, four)

获取某一区间的元素, 返回一个数组

arr2 = ['one', 'two', 'three', 'four'];
print(arr2.getRange(1, 3));    // ['two', 'three']

删除

var arr2 = ['one', 'two', 'three', 'one', 'four'];

// 删除指定的元素
// 如果有该元素, 返回true
print(arr2.remove('two'));  // true
print(arr2);   // [one, three, one, four]
// 如果没有该元素, 返回false
print(arr2.remove('five'));  // false

// 根据索引删除, 返回被删除的元素值
print(arr2.removeAt(1));  // three
print(arr2);   // [one, one, four]

// 删除最后一个元素, 返回该元素值
print(arr2.removeLast());  // four
print(arr2); // [one, one]

// 删除一个区间的元素, 含左不含右[start, end)
arr2.addAll(['six', 'seven', 'eight']);
arr2.removeRange(1, 3);
print(arr2);  // [one, seven, eight]

// 删除所有符合条件的元素
arr2.removeWhere((item) => item.length == 3);
print(arr2);  // [seven, eight]

//删除List中所有不满足条件的元素
arr2.retainWhere((item) => item.length > 3);
print(arr2);

// 删除所有的元素
arr1.clear();
print(arr1);  // []

插入

var arr3 = [1, 3, 4];
// 在某处插入元素
arr3.insert(1, 10);
print(arr3); //[1, 10, 3, 4]

// 插入一个数组
arr3.insertAll(2, [12, 32]);
print(arr3);

学习flutter入门Dart语言