Tipos integrados

El lenguaje Dart tiene soporte especial para lo siguiente:

• Numbers (int, double)
• Cadenas (Strings) (String)
• Booleans (bool)
• Registros ((value1, value2))
• Funciones (Function)
• Listas (List, también conocidas como arrays)
• Sets (Set)
• Maps (Map)
• Runes (Runes; a menudo reemplazadas por la API de characters)
• Symbols (Symbol)
• El valor null (Null)

Este soporte incluye la capacidad de crear objetos mediante literales. Por ejemplo, 'this is a string' es un literal de cadena, y true es un literal booleano.

Debido a que cada variable en Dart se refiere a un objeto (una instancia de una clase), normalmente puedes usar constructores para inicializar variables. Algunos de los tipos integrados tienen sus propios constructores. Por ejemplo, puedes usar el constructor Map() para crear un mapa.

Algunos otros tipos también tienen roles especiales en el lenguaje Dart:

• Object: La superclase de todas las clases de Dart excepto Null.
• Enum: La superclase de todos los enums.
• Future y Stream: Utilizados en programación asíncrona.
• Iterable: Utilizado en bucles for-in y en funciones generadoras síncronas.
• Never: Indica que una expresión nunca puede terminar de evaluarse con éxito. Se utiliza con mayor frecuencia para funciones que siempre lanzan una excepción.
• dynamic: Indica que deseas desactivar la comprobación estática. Normalmente deberías usar Object u Object? en su lugar.
• void: Indica que un valor nunca se utiliza. A menudo se usa como tipo de retorno.

Las clases Object, Object?, Null y Never tienen roles especiales en la jerarquía de clases. Obtén información sobre estos roles en Entendiendo null safety.

Los números en Dart vienen en dos variantes:

int

Valores enteros no mayores de 64 bits, según la plataforma. En plataformas nativas, los valores pueden ser de -2⁶³ a 2⁶³ - 1. En la web, los valores enteros se representan como números de JavaScript (valores de punto flotante de 64 bits sin parte fraccionaria) y pueden ser de -2⁵³ a 2⁵³ - 1.

double

Números de punto flotante de 64 bits (doble precisión), según lo especificado por el estándar IEEE 754.

Tanto int como double son subtipos de num. El tipo num incluye operadores básicos como +, -, /, y *, y también es donde encontrarás abs(), ceil() y floor(), entre otros métodos. (Los operadores a nivel de bits, como >>, se definen en la clase int). Si num y sus subtipos no tienen lo que estás buscando, es posible que la librería dart:math sí lo tenga.

Los enteros son números sin punto decimal. Aquí hay algunos ejemplos de definición de literales enteros:

var x = 1;
var hex = 0xDEADBEEF;

Si un número incluye un decimal, es un double. Aquí hay algunos ejemplos de definición de literales double:

var y = 1.1;
var exponents = 1.42e5;

También puedes declarar una variable como num. Si haces esto, la variable puede tener tanto valores enteros como double.

num x = 1; // x can have both int and double values
x += 2.5;

Los enteros literales se convierten automáticamente a doubles cuando es necesario:

double z = 1; // Equivalent to double z = 1.0.

Así es como conviertes una cadena en un número, o viceversa:

// 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');

El tipo int especifica los operadores tradicionales de desplazamiento a nivel de bits (<<, >>, >>>), complemento (~), AND (&), OR (|) y XOR (^), que son útiles para manipular y enmascarar banderas en campos de bits. Por ejemplo:

assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 | 4) == 7); // 0011 | 0100 == 0111
assert((3 & 4) == 0); // 0011 & 0100 == 0000

Para obtener más ejemplos, consulta la sección de operadores de desplazamiento y a nivel de bits.

Los literales numéricos son constantes en tiempo de compilación. Muchas expresiones aritméticas también son constantes en tiempo de compilación, siempre que sus operandos sean constantes en tiempo de compilación que se evalúen como números.

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

Para más información, consulta Números en Dart.

Puedes usar uno o más guiones bajos (_) como separadores de dígitos para hacer que los literales numéricos largos sean más legibles. Los separadores de múltiples dígitos permiten agrupaciones de nivel superior.

var n1 = 1_000_000;
var n2 = 0.000_000_000_01;
var n3 = 0x00_14_22_01_23_45; // MAC address
var n4 = 555_123_4567; // US Phone number
var n5 = 100__000_000__000_000; // one hundred million million!

Una cadena de Dart (objeto String) contiene una secuencia de unidades de código UTF-16. Puedes usar tanto comillas simples como dobles para crear una cadena:

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.";

Puedes colocar el valor de una expresión dentro de una cadena usando ${expression}. Si la expresión es un identificador, puedes omitir las {}. Para obtener la cadena correspondiente a un objeto, Dart llama al método toString() del objeto.

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!',
);

Puedes concatenar cadenas utilizando literales de cadena adyacentes o el operador +:

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.');

Para crear una cadena multilínea, utiliza una comilla triple con comillas simples o dobles:

var s1 = '''
You can create
multi-line strings like this one.
''';
​
var s2 = """This is also a
multi-line string.""";

Puedes crear una cadena "cruda" (raw string) anteponiendo una r:

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

Consulta la sección de Runes y grupos de grafemas para obtener detalles sobre cómo expresar caracteres Unicode en una cadena.

Los literales de cadena son constantes en tiempo de compilación, siempre que cualquier expresión interpolada sea una constante en tiempo de compilación que se evalúe como nulo o un valor numérico, de cadena o booleano.

// These work in a const string.
const aConstNum = 0;
const aConstBool = true;
const aConstString = 'a constant string';
​
// These do NOT work in a const 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';

Para más información sobre el uso de cadenas, consulta Cadenas y expresiones regulares.

Para representar valores booleanos, Dart tiene un tipo llamado bool. Solo dos objetos tienen tipo bool: los literales booleanos true y false, que son ambos constantes en tiempo de compilación.

La seguridad de tipos de Dart significa que no puedes usar código como if (nonBooleanValue) o assert (nonBooleanValue). En su lugar, comprueba explícitamente los valores, así:

// Check for an empty string.
var fullName = '';
assert(fullName.isEmpty);
​
// Check for zero.
var hitPoints = 0;
assert(hitPoints == 0);
​
// Check for null.
var unicorn = null;
assert(unicorn == null);
​
// Check for NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

En Dart, las runas (runes) exponen los puntos de código Unicode de una cadena. Puedes utilizar el paquete characters para ver o manipular caracteres percibidos por el usuario, también conocidos como grupos de grafemas Unicode (extendidos).

Unicode define un valor numérico único para cada letra, dígito y símbolo utilizado en todos los sistemas de escritura del mundo. Debido a que una cadena de Dart es una secuencia de unidades de código UTF-16, expresar puntos de código Unicode dentro de una cadena requiere una sintaxis especial. La forma habitual de expresar un punto de código Unicode es \uXXXX, donde XXXX es un valor hexadecimal de 4 dígitos. Por ejemplo, el carácter de corazón (♥) es \u2665. Para especificar más o menos de 4 dígitos hexadecimales, coloca el valor entre llaves. Por ejemplo, el emoji de risa (😆) es \u{1f606}.

Si necesitas leer o escribir caracteres Unicode individuales, utiliza el getter characters definido en String por el paquete characters. El objeto Characters devuelto es la cadena como una secuencia de grupos de grafemas. Aquí tienes un ejemplo de uso de la API de characters:

import 'package:characters/characters.dart';
​
void main() {
  var hi = 'Hi 🇩🇰';
  print(hi);
  print('The end of the string: ${hi.substring(hi.length - 1)}');
  print('The last character: ${hi.characters.last}');
}

La salida, según tu entorno, se ve algo así:

$ dart run bin/main.dart
Hi 🇩🇰
The end of the string: ???
The last character: 🇩🇰

Para obtener más detalles sobre el uso del paquete characters para manipular cadenas, consulta el ejemplo y la referencia de la API para el paquete characters.

Un objeto Symbol representa un operador o identificador declarado en un programa Dart. Es posible que nunca necesites usar símbolos, pero son invaluables para las APIs que hacen referencia a identificadores por su nombre, porque la minificación (minification) cambia los nombres de los identificadores pero no los símbolos de los identificadores.

Para obtener el símbolo de un identificador, utiliza un literal de símbolo, que es simplemente # seguido del identificador:

#radix
#bar

Los símbolos literales son constantes en tiempo de compilación.