Dart学习-内置类型

2019年5月8日 245次阅读 来源: 你需要一台永动机

《Dart学习-内置类型》 Dart

Dart语言已经支持了以下类型

  • numbers
  • strings
  • booleans
  • lists (arrays)
  • maps
  • runes(为表达Unicode字符)
  • symbols

你可以使用常量表达式来初始化它们，比如'this is a string'是常量字符串类型，true是常量布尔类型

通常我们可以使用构造器来初始化变量，因为一些类型它们有自己的构造器，比如：我们使用Map()构造器来创建一个map

Numbers

number有两种形式：

  1. int
    Interger的值不在超过64位，具体取决于平台。在DartVm中，值可以从-263 到 263 -1。但是Dart编译成js使用的是js的Number，值可以从-253 到 253 -1
  2. double
    64位（双精度）浮点数，由IEEE 754标准规定。

int和double都是num的子类。num类包含基础的操作符+ - / *，也支持abs(),ceil()和floor()。其中，位运算>>是定义在int中，如果num和及其子类没有你想要的方法，那么可以使用dart:math库

整形的例子

int x = 1;
int hex=0xDEADBEEF;

浮点型的例子

double y = 1.1
double exponents = 1.42e5

以下是String转number的例子

// String -> int
var one = int.parse('1');
assert(one == 1);

// String -> double
var onePointOne = double.parse('1.1');
assert(onePointOne == 1.1);

// int -> String
String oneAsString = 1.toString();
assert(oneAsString == '1');

// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');

int类型的位运算shift(<<,>>),AND(&),和OR(|)

assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 >> 1) == 1); // 0011 >> 1 == 0001
assert((3 | 4) == 7); // 0011 | 0100 == 0111

常量数字是编译时常量。许多算术表达式也是编译时常量，只要它们的操作数是编译为数字的编译时常量。

const msPerSecond = 1000;
const secondsUntilRetry = 5;
const msUntilRetry = secondsUntilRetry * msPerSecond;

Strings

Dart字符串采用的是UTF-16字符编码。使用单引号或双引号来创建字符串：

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

使用$ {expression}将表达式的值放在字符串中。如果表达式是标识符，则可以跳过{}。要获取对应于对象的字符串，Dart调用对象的toString()方法

var s = 'string interpolation';

assert('Dart has $s, which is very handy.' ==
    'Dart has string interpolation, ' +
        'which is very handy.');
assert('That deserves all caps. ' +
        '${s.toUpperCase()} is very handy!' ==
    'That deserves all caps. ' +
        'STRING INTERPOLATION is very handy!');

==运算符测试两个对象是否等效。如果两个字符串包含相同的代码单元序列，则它们是等效的。
PS:类似Kotlin的字符串模板。

使用相邻的字符串常量或+运算符来连接字符串：

var s1 = 'String '
    'concatenation'
    " works even over line breaks.";
assert(s1 ==
    'String concatenation works even over '
    'line breaks.');

var s2 = 'The + operator ' + 'works, as well.';
assert(s2 == 'The + operator works, as well.');

创建多行字符串的另一种方法：使用带有单引号或双引号的三重引号：

var s1 = '''
You can create
multi-line strings like this one.
''';

var s2 = """This is also a
multi-line string.""";

通过在其前面加上r来创建“行”字符串：

var s = r'In a raw string, not even \n gets special treatment.';

常量字符串是编译时常量，只要任何插值表达式是一个编译时常量，其值为null或数值，字符串或布尔值。

// 这些【可以】 在常量字符串中使用
const aConstNum = 0;
const aConstBool = true;
const aConstString = 'a constant string';

//这些【不可以】在常量字符串中使用
var aNum = 0;
var aBool = true;
var aString = 'a string';
const aConstList = [1, 2, 3];

const validConstString = '$aConstNum $aConstBool $aConstString';
// const invalidConstString = '$aNum $aBool $aString $aConstList';

Booleans

为了表示布尔值，Dart有一个名为bool的类型。只有两个对象具有bool类型： 布尔常量true和false，它们都是编译时常量。

Dart的类型安全意味着您不能使用if(nonbooleanValue)或assert(nonbooleanValue)等代码。相反，明确检查值，如下所示：

// 检查空字符串。
var fullName = '';
assert(fullName.isEmpty);

// 检查数字零。
var hitPoints = 0;
assert(hitPoints <= 0);

// 检查对象是否为空
var unicorn;
assert(unicorn == null);

// 检查 NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

Lists

几乎每种编程语言中最常见的集合可能是数组或有序的对象组。在Dart中，数组是List对象，因此大多数人只是将它们称为lists。
dart的列表（list）常量跟js的集合（array）常量有点类似：

var list = [1, 2, 3];

注意：分析器推断列表的类型为List <int>。如果尝试将非整数对象添加到此列表，则分析器或运行时会引发错误。

列表使用从零开始的索引，其中0是第一个元素的索引，list.length – 1是最后一个元素的索引。您可以像在js中一样获取列表的长度并引用列表元素：

var list = [1, 2, 3];
assert(list.length == 3);
assert(list[1] == 2);

list[1] = 1;
assert(list[1] == 1);

要创建一个编译时常量的列表，请在列表常量之前添加const：

var constantList = const [1, 2, 3];
// constantList[1] = 1; // 取消注释会导致错误。

Maps

通常，是Map关联键和值的对象。键和值都可以是任何类型的对象。每个键只出现一次，但可以多次使用相同的值。maps由map常量和Map类型提供。

以下是一些简单的Dart映射，使用map常量创建:

var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

var nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

分析器推断gifts的类型为Map <String，String>，而nobleGases的类型为Map <int，String>。 如果您尝试将错误类型的值添加到任一Map中，则分析器或运行时会引发错误。

像在js中一样，将新的键值对添加到现有Map上：

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds'; // Add a key-value pair

以与在js中相同的方式从Map中检索值：

var gifts = {'first': 'partridge'};
assert(gifts['first'] == 'partridge');

如果您查找不在map中的键，则返回null：

var gifts = {'first': 'partridge'};
assert(gifts['fifth'] == null);

使用.length来获取map中键值对的数量：

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds';
assert(gifts.length == 2);

要创建一个编译时常量的map，请在map常量之前添加const：

final constantMap = const {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

// constantMap[2] = 'Helium'; // Uncommenting this causes an error.

Runes(符文)

在Dart中，Runes是采用UTF-32字符编码的字符串。

Unicode为世界上所有书写系统中使用的每个字母，数字和符号定义唯一的数值。由于Dart字符串是采用UTF-16字符编码，因此在字符串中表示32位Unicode值需要特殊语法。

表达Unicode字符的常用方法是\ uXXXX，其中XXXX是4位十六进制值。 例如，心脏角色（♥）是\ u2665。 要指定多于或少于4个十六进制数字，请将值放在大括号中。 例如，笑的表情符号（😆）是\ u {1f600}。

String类有几个属性可用于提取Runes信息。 codeUnitAt和codeUnit属性返回16位比特。使用runes属性获取字符串的Runes。

main() {
  var clapping = '\u{1f44f}';
  print(clapping);
  print(clapping.codeUnits);
  print(clapping.runes.toList());

  Runes input = new Runes(
      '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
  print(new String.fromCharCodes(input));
}
-------------------------------------------------------------------------------
👏
[55357, 56399]
[128079]
♥  😅  😎  👻  🖖  👍

使用列表操作操作Runes时要小心。这种方法很容易崩溃，具体取决于特定的语言，字符集和操作。

Symbols(符号)

Symbol对象表示在Dart程序中声明的运算符或标识符。 您可能永远不需要使用Symbols，但它们对于按名称引用标识符的API非常有用，因为缩小会更改标识符名称而不会更改标识符符号。

要获取标识符的符号，请使用符号常量，它只是＃后跟标识符：

#radix
#bar

Symbols常量是编译时常量。

PS:本文整理自官方文档，若有发现问题请致邮 caoyanglee92@gmail.com

    原文作者：你需要一台永动机
    原文地址: https://www.jianshu.com/p/df74a68f5d7b
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞