refs/tags/1.1.0-nullsafety - characters

commit	dadeb1a572d3b29cb2907099a03dcd66d655ce79	[log] [tgz]
author	Jacob MacDonald <jakemac@google.com>	Wed Jun 24 11:02:07 2020 -0700
committer	GitHub <noreply@github.com>	Wed Jun 24 20:02:07 2020 +0200
tree	793f48a13d8edda22ae8f067c1b8e10a83369ac2
parent	5b04b14b40a985d666a2f5bec11fffceb9587844 [diff]

tree: 793f48a13d8edda22ae8f067c1b8e10a83369ac2

README.md

Characters are strings viewed as sequences of user-perceived characters, also known as Unicode (extended) grapheme clusters.

The Characters class allows access to the individual characters of a string, and a way to navigate back and forth between them using a CharacterRange.

Unicode characters and representations

There is no such thing as plain text.

Computers only know numbers, so any “text” on a computer is represented by numbers, which are again stored as bytes in memory.

The meaning of those bytes are provided by layers of interpretation, building up to the glyphs that the computer displays on the screen.

Abstraction	Dart Type	Usage	Example
Bytes	`ByteBuffer`, `Uint8List`	Physical layout: Memory or network communication.	`file.readAsBytesSync()`
Code units	`Uint8List` (UTF‑8) `Uint16List`, `String` (UTF‑16)	Standard formats for encoding code points in memory. Stored in memory using one (UTF‑8) or more (UTF‑16) bytes. One or more code units encode a code point.	`string.codeUnits` `string.codeUnitAt(index)` `utf8.encode(string)`
Code points	`Runes`	The Unicode unit of meaning.	`string.runes`
Grapheme Clusters	`Characters`	Human perceived character. One or more code points.	`string.characters`
[Glyphs][]		Visual rendering of grapheme clusters.	`print(string)`

A Dart String is a sequence of UTF-16 code units, just like strings in JavaScript and Java. The runtime system decides on the underlying physical representation.

That makes plain strings inadequate when needing to manipulate the text that a user is viewing, or entering, because string operations are not working at the grapheme cluster level.

For example, to abbreviate a text to, say, the 15 first characters or glyphs, an string like “A 🇬🇧 text in English” should abbreviate to "A 🇬🇧 text in Eng… when counting characters, but will become “A 🇬🇧 text in …” if counting code units using String operations.

Whenever you need to manipulate strings at the character level, you should be using the Characters type, not the methods of the String class.

The Characters class

The Characters class exposes a string as a sequence of grapheme clusters. All operations on Characters operate on entire grapheme clusters, so it removes the risk of splitting combined characters or emojis that are inherent in the code-unit based String operations.

You can get a Characters object for a string using either the constructor Characters(string) or the extension getter string.characters.

At its core, the class is an Iterable<String> where the element strings are single grapheme clusters. This allows sequential access to the individual grapheme clusters of the original string.

On top of that, there are operations mirroring the operations of String that are not index, code-unit or code-point based, like startsWith or replaceAll. There are some differences between these and the String operations. For example the replace methods only accept characters as pattern. Regular expressions are not grapheme cluster aware, so they cannot be used safely on a sequence of characters.

Grapheme clusters have varying length in the underlying representation, so operations on a Characters sequence cannot be index based. Instead the CharacterRange iterator provided by Characters.iterator has been greatly enhanced. It can move both forwards and backwards, and it can span a range of grapheme cluster. Most operations that can be performed on a full Characters can also be performed on the grapheme clusters in the range of a CharacterRange. The range can be contracted, expanded or moved in various ways, not restricted to using moveNext, to move to the next grapheme cluster.

Example:

// Using String indices.
String firstTagString(String source) {
  var start = string.indexOf("<") + 1;
  if (start > 0) {
    var end = string.indexOf(">", start);
    if (end >= 0) {
	    return string.substring(start, end);
    }
  }
  return null;
}

// Using CharacterRange operations.
Characters firstTagCharacters(Characters source) =>
  var range = source.findFirst("<".characters);
  if (range != null && range.moveUntil(">".characters)) {
    return range.currentCharacters;
  }
  return null;
}