Dart语法学习数据类型

Numbers (int, double)
Strings (String)
Booleans (bool)
Lists (List, also known as arrays)
Sets (Set)
Maps (Map)
Runes (Runes; often replaced by the characters API)
Symbols (Symbol)
The value null (Null)

Dart 要求以 main 函数作为执行的入口。

1.Numbers

Dart 应用程序通常针对多个平台。 例如&＃xff0c;Flutter 应用程序可能针对 iOS、Android 和 Web。 代码可以相同&＃xff0c;只要应用程序不依赖特定于平台的库或以平台相关的方式使用数字。

Dart 的数值类型 num&＃xff0c;只有两种子类&＃xff1a;即 64 位 int 和符合 IEEE 754 标准的 64 位 double。前者代表整数类型&＃xff0c;而后者则是浮点数的抽象。

除了常见的基本运算符&＃xff0c;比如 &＃43;、-、*、/&＃xff0c;以及位运算符外&＃xff0c;你还能使用继承自 num 的 abs()、round() 等方法&＃xff0c;来实现求绝对值、取整的功能。

常见的运算符也是继承自 num。

Dart numbers 有两种形式:

int

不大于 64 位的整数值&＃xff0c;具体取决于平台。 在本机平台上&＃xff0c;值可以从 -2^63到 2^63 - 1。在 Web 上&＃xff0c;整数值表示为 Javascript 数字&＃xff08;没有小数部分的 64 位浮点值&＃xff09;并且可以从 -2^53 到 2^53 - 1。

double

64 位&＃xff08;双精度&＃xff09;浮点数&＃xff0c;由 IEEE 754 标准指定。 int 和 double 都是 num 的子类型。 num 类型包括基本运算符&＃xff0c;例如 &＃43;、-、/ 和 *&＃xff0c;您还可以在其中找到 abs()、ceil() 和 floor() 以及其他方法。 &＃xff08;按位运算符&＃xff0c;例如 >>&＃xff0c;在 int 类中定义。&＃xff09;如果 num 及其子类型没有您要查找的内容&＃xff0c;dart:math 库可能有。 整数是没有小数点的数字。 以下是定义整数文字的一些示例&＃xff1a;

var x &＃61; 1;
var hex &＃61; 0xDEADBEEF;

 如果数字包含小数&＃xff0c;则为双精度数。 以下是定义双字面量的一些示例&＃xff1a;

var y &＃61; 1.1;
var exponents &＃61; 1.42e5;

您还可以将变量声明为 num。 如果这样做&＃xff0c;变量可以同时具有整数和双精度值。

num x &＃61; 1; // x can have both int and double values
x &＃43;&＃61; 2.5;

 必要时整数文字会自动转换为双精度数&＃xff1a;

double z &＃61; 1; // Equivalent to double z &＃61; 1.0.

将字符串与数字相互转换的方法

void main() {
var one &＃61; int.parse(&＃39;1&＃39;);
print(one);
var two &＃61; double.parse(&＃39;2&＃39;);
print(two);
var str &＃61; 1.toString();
print(str);
var str2 &＃61; 3.14159.toStringAsFixed(2);
print(str2);
}
Log
1
2.0
1
3.14

int 类型指定传统的移位&＃xff08;<<、>>、>>>&＃xff09;、补码&＃xff08;~&＃xff09;、与&＃xff08;&&＃xff09;、或&＃xff08;|&＃xff09;和异或&＃xff08;^&＃xff09;运算符&＃xff0c;这些运算符在位运算中对于操作和屏蔽标志很有用。

void main() {
print((3 <<1) &＃61;&＃61; 6);
print((3 | 4) &＃61;&＃61; 7);
print((3 & 4) &＃61;&＃61; 0);
}
Log
true
true
true

文字数字是编译时常量。 许多算术表达式也是编译时常量&＃xff0c;只要它们的操作数是计算结果为数字的编译时常量。

const msPerSecond &＃61; 1000;
const secondsUntilRetry &＃61; 5;
const msUntilRetry &＃61; secondsUntilRetry * msPerSecond;

2.Strings

Dart 的 String 由 UTF-16 的字符串组成。和 Javascript 一样&＃xff0c;构造字符串字面量时既能使用单引号也能使用双引号&＃xff0c;还能在字符串中嵌入变量或表达式&＃xff1a;你可以使用 ${express} 把一个表达式的值放进字符串。而如果是一个标识符&＃xff0c;你可以省略{}。

Dart 字符串&＃xff08;字符串对象&＃xff09;包含一系列 UTF-16 代码单元。 可以使用单引号或双引号来创建字符串&＃xff1a;

var s1 &＃61; &＃39;Single quotes work well for string literals.&＃39;;
var s2 &＃61; "Double quotes work just as well.";
var s3 &＃61; &＃39;It\&＃39;s easy to escape the string delimiter.&＃39;;
var s4 &＃61; "It&＃39;s even easier to use the other delimiter.";

 可以使用 ${expression} 将表达式的值放入字符串中。如果表达式是标识符(Strings)&＃xff0c;则可以跳过 {}。 为了获取对象对应的字符串&＃xff0c;Dart 调用对象的 toString() 方法。

var s &＃61; &＃39;string interpolation&＃39;;
assert(&＃39;Dart has $s, which is very handy.&＃39; &＃61;&＃61;
&＃39;Dart has string interpolation, &＃39;
&＃39;which is very handy.&＃39;);
assert(&＃39;That deserves all caps. &＃39;
&＃39;${s.toUpperCase()} is very handy!&＃39; &＃61;&＃61;
&＃39;That deserves all caps. &＃39;
&＃39;STRING INTERPOLATION is very handy!&＃39;);

&＃61;&＃61; 运算符测试两个对象是否等价。 如果两个字符串包含相同的代码单元序列&＃xff0c;则它们是等价的。

可以使用相邻的字符串文字或 &＃43; 运算符连接字符串&＃xff1a;

void main() {
var s1 &＃61; &＃39;String &＃39;
&＃39;concatenation&＃39;
" works even over line breaks.";
print(s1 &＃61;&＃61;
&＃39;String concatenation works even over &＃39;
&＃39;line breaks.&＃39;);
var s2 &＃61; &＃39;The &＃43; operator &＃39; &＃43; &＃39;works, as well.&＃39;;
print(s2 &＃61;&＃61; &＃39;The &＃43; operator works, as well.&＃39;);
}
Log
true
true


 创建多行字符串的方法&＃xff1a;使用带有单引号或双引号的三重引号&＃xff1a;

void main() {
var s1 &＃61; &＃39;&＃39;&＃39;
You can create
multi-line strings like this one.
&＃39;&＃39;&＃39;;
print(s1);
var s2 &＃61; """This is also a
multi-line string.""";
print(s2);
}
Log
This is also a
multi-line string.


 可以通过在其前面加上 r 来创建“raw”字符串

void main() {
var s &＃61; r&＃39;In a raw string, not even \n gets special treatment.&＃39;;
print(s);
}
Log
In a raw string, not even \n gets special treatment.

 文字字符串是编译时常量&＃xff0c;只要任何内插表达式是计算为 null 或数字、字符串或布尔值的编译时常量。

// These work in a const string.
const aConstNum &＃61; 0;
const aConstBool &＃61; true;
const aConstString &＃61; &＃39;a constant string&＃39;;
// These do NOT work in a const string.
var aNum &＃61; 0;
var aBool &＃61; true;
var aString &＃61; &＃39;a string&＃39;;
const aConstList &＃61; [1, 2, 3];
const validConstString &＃61; &＃39;$aConstNum $aConstBool $aConstString&＃39;;
// const invalidConstString &＃61; &＃39;$aNum $aBool $aString $aConstList&＃39;;

Booleans

为了表示布尔值&＃xff0c;Dart 有一个名为 bool 的类型。 只有两个对象具有 bool 类型&＃xff1a;布尔文字 true 和 false&＃xff0c;它们都是编译时常量。

为了表示布尔值&＃xff0c;Dart 使用了一种名为 bool 的类型。在 Dart 里&＃xff0c;只有两个对象具有 bool 类型&＃xff1a;true 和 false&＃xff0c;它们都是编译时常量。

Dart 的类型安全意味着你不能使用像 if (nonbooleanValue) 或 assert (nonbooleanValue) 这样的代码。 相反&＃xff0c;显式检查值&＃xff0c;如下所示&＃xff1a;

void main() {
// Check for an empty string.
var fullName &＃61; &＃39;&＃39;;
print(fullName.isEmpty);
// Check for zero.
var hitPoints &＃61; 0;
print(hitPoints <&＃61; 0);
// Check for null.
var unicorn;
print(unicorn &＃61;&＃61; null);
// Check for NaN.
var iMeantToDoThis &＃61; 0 / 0;
print(iMeantToDoThis.isNaN);
}
Log:
true
true
true
true

在 Dart 中的对应实现是 List 和 Map&＃xff0c;统称为集合类型。

容器里的元素也需要有类型&＃xff0c;比如上述代码中 arr2 的类型是 List&＃xff0c;map2 的类型则为 Map。Dart 会自动根据上下文进行类型推断&＃xff0c;所以你后续往容器内添加的元素也必须遵照这一类型。

如果编译器自动推断的类型不符合预期&＃xff0c;我们当然可以在声明时显式地把类型标记出来&＃xff0c;不仅可以让代码提示更友好一些&＃xff0c;更重要的是可以让静态分析器帮忙检查字面量中的错误&＃xff0c;解除类型不匹配带来的安全隐患或是 Bug。

Lists

Dart 列表文字由逗号分隔的表达式或值列表表示&＃xff0c;括在方括号 ([]) 中。

void main() {
var list &＃61; [1,2,3];
print(list);
}
Log:
[1, 2, 3]

注意&＃xff1a;Dart 推断列表的类型为 List。 如果您尝试将非整数对象添加到此列表&＃xff0c;分析器或运行时会引发错误。

在 Dart 集合文字的最后一项之后添加一个逗号。 这个尾随逗号不会影响集合&＃xff0c;但它可以帮助防止复制粘贴错误。

var list &＃61; [
&＃39;Car&＃39;,
&＃39;Boat&＃39;,
&＃39;Plane&＃39;,
];

列表使用从零开始的索引&＃xff0c;其中 0 是第一个值的索引&＃xff0c;list.length - 1 是最后一个值的索引。 您可以使用 .length 属性获取列表的长度&＃xff0c;并使用下标运算符 ([]) 访问列表的值&＃xff1a;

void main() {
var list &＃61; [1, 2, 3];
print(list.length &＃61;&＃61; 3);
print(list[1] &＃61;&＃61; 2);
list[1] &＃61; 1;
print(list[1] &＃61;&＃61; 1);
}
Log
true
true
true

 要创建一个作为编译时常量的列表&＃xff0c;请在列表字面量之前添加 const&＃xff1a;

void main() {
var constantList &＃61; const [1, 2, 3];
print(constantList);
}
[1, 2, 3]

Dart 支持扩展运算符 (...) 和 null 感知扩展运算符 (...?)&＃xff0c;它们提供了一种将多个值插入集合的简洁方法。

例如&＃xff0c;可以使用扩展运算符 (...) 将一个列表的所有值插入到另一个列表中&＃xff1a;

void main() {
var list &＃61; [1, 2, 3];
var list2 &＃61; [0, ...list];
print(list2.length &＃61;&＃61; 4);
print(list2);
}
Log:
true
[0, 1, 2, 3]

如果展开运算符右侧的表达式可能为空&＃xff0c;则可以通过使用可识别空值的展开运算符&＃xff08;...&＃xff1f;&＃xff09;来避免异常&＃xff1a;

void main() {
var list &＃61; null;
var list2 &＃61; [0, ...?list];
print(list2.length &＃61;&＃61; 1);
print(list2);
}
Log
true
[0]

Dart 还提供了 collection if 和 collection for&＃xff0c;您可以使用它们来使用条件 (if) 和重复 (for) 构建集合。

下面是一个使用 collection if 来创建包含三个或四个项目的列表的示例&＃xff1a;

void main() {
var promoActive &＃61; true;
var nav &＃61; [&＃39;Home&＃39;, &＃39;Furniture&＃39;, &＃39;Plants&＃39;, if (promoActive) &＃39;Outlet&＃39;];
print(nav);
}
Log
[Home, Furniture, Plants, Outlet]

这是一个在将列表项添加到另一个列表之前使用 collection for 操作列表项的示例&＃xff1a;

void main() {
var listOfInts &＃61; [1, 2, 3];
var listOfStrings &＃61; [&＃39;#0&＃39;, for (var i in listOfInts) &＃39;#$i&＃39;];
print(listOfStrings[1] &＃61;&＃61; &＃39;#1&＃39;);
print(listOfStrings);
}
Log
true
[#0, #1, #2, #3]

Sets

Dart 中的Set是唯一项的无序集合。 Dart 对Set的支持由{}和 Set 类型提供。

这是一个简单的 Dart Set&＃xff0c;使用{}创建&＃xff1a;

void main() {
var halogens &＃61; {&＃39;fluorine&＃39;, &＃39;chlorine&＃39;, &＃39;bromine&＃39;, &＃39;iodine&＃39;, &＃39;astatine&＃39;};
print(halogens);
}
Log
{fluorine, chlorine, bromine, iodine, astatine}

注意&＃xff1a;Dart 推断 halogens 的类型为 Set。 如果您尝试将错误类型的值添加到集合中&＃xff0c;分析器或运行时会引发错误。

要创建一个空集&＃xff0c;请在 {} 前面加上一个类型参数&＃xff0c;或将 {} 分配给 Set 类型的变量&＃xff1a;

void main() {
var names &＃61; {};
print(names.length);
Set names2 &＃61; {}; // This works, too.
print(names2.length);
var names3 &＃61; {}; // Creates a map, not a set.
print(names3 is Set);
print(names3 is Map);
}
Log
0
0
false
true

 注意&＃xff1a;Set还是map?  {} 默认为 Map 类型。 如果忘记了 {} 上的类型注释或它分配给的变量&＃xff0c;那么 Dart 会创建一个 Map 类型的对象。

使用 add() 或 addAll() 方法将项目添加到现有集合&＃xff1a;

void main() {
var halogens &＃61; {&＃39;fluorine&＃39;, &＃39;chlorine&＃39;, &＃39;bromine&＃39;, &＃39;iodine&＃39;, &＃39;astatine&＃39;};
var elements &＃61; {};
elements.add("1");
elements.addAll(halogens);
print(elements);
}
Log
{1, fluorine, chlorine, bromine, iodine, astatine}

 使用 .length 获取集合中的项目数&＃xff1a;

void main() {
var halogens &＃61; {&＃39;fluorine&＃39;, &＃39;chlorine&＃39;, &＃39;bromine&＃39;, &＃39;iodine&＃39;, &＃39;astatine&＃39;};
var elements &＃61; {};
elements.add(&＃39;fluorine&＃39;);
elements.addAll(halogens);
print(elements.length &＃61;&＃61; 5);
}
Log
true

 要创建一个作为编译时常量的Set&＃xff0c;请在Set字面量之前添加 const&＃xff1a;

void main() {
final constantSet &＃61; const {
&＃39;fluorine&＃39;,
&＃39;chlorine&＃39;,
&＃39;bromine&＃39;,
&＃39;iodine&＃39;,
&＃39;astatine&＃39;,
};
//此处代码会报错。
constantSet.add("66");
}

 Set支持扩展运算符&＃xff08;...和...&＃xff1f;&＃xff09;和集合 if 和 for&＃xff0c;就像List一样。

Maps

通常&＃xff0c;Map是关联键和值的对象。 键和值都可以是任何类型的对象。 每个键只出现一次&＃xff0c;但您可以多次使用相同的值。 Dart 对地图的支持由地图字面量和 Map 类型提供。

这里有几个简单的 Dart 地图&＃xff0c;使用地图字面量创建&＃xff1a;

void main() {
var gifts &＃61; {
// Key: Value
&＃39;first&＃39;: &＃39;partridge&＃39;,
&＃39;second&＃39;: &＃39;turtledoves&＃39;,
&＃39;fifth&＃39;: &＃39;golden rings&＃39;
};
print(gifts);
var nobleGases &＃61; {
2: &＃39;helium&＃39;,
10: &＃39;neon&＃39;,
18: &＃39;argon&＃39;,
};
print(nobleGases);
}
Log
{first: partridge, second: turtledoves, fifth: golden rings}
{2: helium, 10: neon, 18: argon}

 注意&＃xff1a;Dart 推断 gifts 具有 Map 类型&＃xff0c;而 nobleGases 具有 Map 类型。 如果您尝试向任一映射添加错误类型的值&＃xff0c;则分析器或运行时会引发错误。

使用 Map 构造函数创建相同的对象&＃xff1a;


void main() {
var gifts &＃61; Map();
gifts[&＃39;first&＃39;] &＃61; &＃39;partridge&＃39;;
gifts[&＃39;second&＃39;] &＃61; &＃39;turtledoves&＃39;;
gifts[&＃39;fifth&＃39;] &＃61; &＃39;golden rings&＃39;;
print(gifts);
var nobleGases &＃61; Map();
nobleGases[2] &＃61; &＃39;helium&＃39;;
nobleGases[10] &＃61; &＃39;neon&＃39;;
nobleGases[18] &＃61; &＃39;argon&＃39;;
print(nobleGases);
}
Log
{first: partridge, second: turtledoves, fifth: golden rings}
{2: helium, 10: neon, 18: argon}

 注意&＃xff1a;在C# 或 Java 等语言&＃xff0c;是 new Map() 而不仅仅是 Map()。 在 Dart 中&＃xff0c;new 关键字是可选的。

使用下标赋值运算符 ([]&＃61;) 将新的键值对添加到现有映射&＃xff1a;

void main() {
var gifts &＃61; {&＃39;first&＃39;: &＃39;partridge&＃39;};
gifts[&＃39;fourth&＃39;] &＃61; &＃39;calling birds&＃39;; // Add a key-value pair
print(gifts);
}
Log
{first: partridge, fourth: calling birds}

 使用下标运算符 ([]) 从映射中检索值&＃xff1a;

void main() {
var gifts &＃61; {&＃39;first&＃39;: &＃39;partridge&＃39;};
print(gifts[&＃39;first&＃39;] &＃61;&＃61; &＃39;partridge&＃39;);
}
Log:
true

 寻找一个不在Map中的键&＃xff0c;你会得到 null 作为回报&＃xff1a;

void main() {
var gifts &＃61; {&＃39;first&＃39;: &＃39;partridge&＃39;};
print(gifts[&＃39;fifth&＃39;] &＃61;&＃61; null);
}
Log
true

 使用 .length 获取Map中键值对的数量&＃xff1a;

void main() {
var gifts &＃61; {&＃39;first&＃39;: &＃39;partridge&＃39;};
gifts[&＃39;fourth&＃39;] &＃61; &＃39;calling birds&＃39;;
print(gifts.length &＃61;&＃61; 2);
}
Log
true

 创建作为编译时常量的映射&＃xff0c;请在Map字面量之前添加 const&＃xff1a;

void main() {
final constantMap &＃61; const {
2: &＃39;helium&＃39;,
10: &＃39;neon&＃39;,
18: &＃39;argon&＃39;,
};
//此处会报错
constantMap[2] &＃61; &＃39;Helium&＃39;; // This line will cause an error.
}

参考文档&＃xff1a;Numbers in Dart | Dart

Language tour | Dart