🧮 Gardar datos

Unha variable permite gardar un valor e usalo despois. Estes son os tipos básicos:

String nome = 'Xurxo';
int faltas = 0;
double nota = 7.5; // Nos números usamos punto para os decimais.
bool matriculado = true;

faltas = 1; // Podemos cambiar o valor dunha variable.
print('$nome: $nota, faltas: $faltas, matriculado: $matriculado');

🔎 Inferencia con var

Se escribimos var, Dart deduce o tipo a partir do valor inicial. Non significa que despois admita calquera tipo.

var nome = 'Diego'; // Dart deduce String.
nome = 'Rosa';
// nome = 10; // Non válido: a variable é de tipo String.
print(nome);

Usa o tipo explícito cando axude a entender o dato e var cando o valor inicial o deixe claro.

🔐 final e const

• final: só podemos asignar o valor unha vez. Pode calcularse cando se executa o programa.
• const: o valor debe poder calcularse antes de executar o programa, en tempo de compilación.

final agora = DateTime.now(); // Coñecemos o valor ao executar.
const instituto = 'IES San Mamede';
const minutosDuasHoras = 2 * 60; // Unha expresión constante tamén vale.
print('$instituto: $agora ($minutosDuasHoras minutos)');
// instituto = 'Outro centro'; // Non podemos reasignalo.

Cando un dato non vaia cambiar, normalmente usaremos final. Para valores constantes, const. Ao estudar listas veremos a diferenza entre cambiar unha variable e modificar o seu contido.

🔤 Traballar con texto

Podemos usar comiñas simples ou dobres. A interpolación permite introducir valores dentro dun texto:

• $variable: cando só precisamos o valor dunha variable.
• ${expresion}: cando facemos un cálculo, accedemos a un membro ou chamamos a unha función. Dart avalía o que hai entre as chaves e introduce o resultado no texto.

String nome = 'Diego';
String apelidos = 'Rodicio';
print('$nome $apelidos'); // Diego Rodicio
print('Letras do nome: ${nome.length}');
print(nome.toUpperCase()); // DIEGO
print('IES San Mamede\n2º DAM'); // \n introduce un salto de liña.

Por exemplo, as chaves permiten sumar notas ou chamar a toUpperCase() dentro da mensaxe:

String nome = 'Iria';
int nota1 = 7;
int nota2 = 9;
print('Alumna: $nome'); // Só unha variable.
print('Media: ${(nota1 + nota2) / 2}'); // Primeiro calcula a media: 8.0.
print('Nome en maiúsculas: ${nome.toUpperCase()}'); // IRIA

'$nota1 + $nota2' produciría o texto 7 + 9; '${nota1 + nota2}' produciría 16. Se a expresión é longa, garda antes o resultado nunha variable para facilitar a lectura.

Métodos útiles: trim() quita espazos ao principio e ao final; toLowerCase() pasa a minúsculas; toUpperCase() pasa a maiúsculas. isEmpty indica se o texto está baleiro.

🔢 Converter texto en números

int.parse() e double.parse() converten un texto válido nun número. Se o texto non é válido, producen unha excepción (veremos como tratala máis adiante).

int faltas = int.parse('2');
double nota = double.parse('7.5');
String texto = faltas.toString(); // Conversión de número a texto.
print('$texto faltas; nota: $nota');

Para datos escritos polo usuario preferiremos tryParse(): se non pode converter o texto, devolve null. Explicámolo no seguinte apartado.

🔎 Object e dynamic: cando o tipo é máis xeral

Normalmente usaremos tipos concretos ou var. Tamén atoparemos:

Con Object só podemos usar directamente as operacións que ese tipo ofrece. Para usar unha operación propia de String, por exemplo, primeiro hai que comprobar ou concretar o tipo. Object? tamén permite null.

Object dato = 'Diego';
dato = 8; // Object admite tamén un enteiro.
print(dato); // Mostrar o valor é válido.

// Con dynamic, esta operación compróbase ao executar.
dynamic nome = 'Diego';
print(nome.toUpperCase()); // Funciona porque o valor é un texto.
nome = 8;
// print(nome.toUpperCase()); // Fallaría: un int non ten ese método.
print(nome);

dynamic tamén admite null. Non significa que o tipo declarado da variable cambie: o que cambia é o valor que garda. En Flutter aparecerá sobre todo ao tratar datos de JSON, bases de datos ou argumentos de navegación. Veremos un exemplo de Map<String, dynamic> nas coleccións.

Sempre que coñezamos o tipo, é mellor indicalo ou deixar que var o deduza: así o editor pode axudarnos a detectar erros antes de executar.

📚 Consulta: sistema de tipos — https://dart.dev/language/type-system.

🕓 Inicializar máis adiante con late

Ás veces necesitamos declarar unha variable, pero aínda non temos o seu valor. Con late indicamos a Dart: «dareille un valor antes de usala».

late String profesor; // O valor asignarase máis adiante.

void prepararDatos() {
  profesor = 'Diego Rodicio';
}

void main() {
  prepararDatos(); // Primeiro asignamos o valor.
  print(profesor); // Agora podemos lelo.
}

Neste exemplo, a variable está fóra das funcións e recibe o valor ao chamar a prepararDatos(). Se intentamos lela antes de asignarlle un valor, o programa falla ao executarse. late non asigna un valor inicial. Que a variable admita null depende do seu tipo: String non o admite e String? si.

Veremos máis usos de late coas clases e en Flutter.

📌 Non sempre necesitamos late

Dentro dunha función, se Dart pode comprobar que asignamos o valor antes de usalo, non fai falta:

void main() {
  String profesor;
  profesor = 'Diego'; // Asignamos o valor antes de lelo.
  print(profesor);
}

🧪 Exemplo completo

🔗 Ver o código en DartPad — https://dartpad.dev/?id=3fe9d227bc5510ead6b84db9151d2d7b

<iframe
  src="https://dartpad.dev/embed-inline.html?id=3fe9d227bc5510ead6b84db9151d2d7b"
  width="100%"
  height="600"
  style="border: 1px solid #ccc; border-radius: 8px;"
  allow="camera; microphone; geolocation; fullscreen;"
></iframe>

void main() {
  // Os tipos describen os datos que gardamos.
  String profesor = 'Diego Rodicio';
  var usuario = 'drodicio';
  int alumnos = 8;
  double notaMedia = 7.5;
  bool claseAberta = true;

  const instituto = 'IES San Mamede';
  final inicio = DateTime.now(); // O valor obtense ao executar.

  print('$profesor ($usuario) — $instituto');
  print('Alumnos: $alumnos. Media: $notaMedia');
  print('Clase aberta: $claseAberta. Inicio: $inicio');

  // O texto numérico pódese converter para facer cálculos.
  int novasMatriculas = int.parse('2');
  alumnos += novasMatriculas;
  print('Agora hai $alumnos alumnos');

  // As chaves permiten facer cálculos e chamar a métodos dentro do texto.
  print('Dous grupos iguais: ${alumnos ~/ 2} alumnos por grupo');
  print('Usuario: ${usuario.toUpperCase()}');
}