El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Ja coneixes la gramàtica del llenguatge: sentències, blocs, noms vàlids i mode estricte. Ara toca el contingut: les dades. Programar consisteix, en el fons, a desar informació, transformar-la i mostrar-la. En aquesta lliçó aprendràs a crear variables amb let i const, entendràs per què var pertany al passat, i recorreràs tots els tipus de dades primitius de JavaScript. En acabar podràs modelar amb precisió cada camp d'una tasca de Nómada Tasques fent servir el tipus adequat en cada cas.

Contingut

Què és una variable
Declarar variables: let i const
var i per què està desaconsellat
Tipatge dinàmic i l'operador typeof
El tipus string: text
El tipus number: nombres
El tipus boolean: cert o fals
undefined i null
symbol i bigint
Primitius enfront de referències
Modelar una tasca de Nómada Tasques
Errors Habituals i Consells
Exercicis
Conclusió

Què és una variable

Una variable és un nom associat a un valor desat a la memòria. La imatge habitual és la d'una capsa etiquetada: l'etiqueta és el nom i a dins hi ha el valor.

const responsable = 'Marta';

Tres peces:

Peça	Funció
`const`	La paraula clau de declaració: crea la variable
`responsable`	L'identificador: el nom amb què la faràs servir
`'Marta'`	El valor que es desa

A partir d'aquesta línia, escriure responsable en qualsevol punt posterior equival a escriure 'Marta'.

És important entendre que la variable no és el valor: és una referència amb nom. Pots canviar el que desa (si la vas declarar amb let) sense canviar-ne el nom.

Declarar variables: `let` i `const`

JavaScript modern ofereix dues maneres de declarar variables.

2.1 `const`: el valor no es reassigna

const responsable = 'Iván';
// responsable = 'Lucía'; // TypeError: Assignment to constant variable.

Dues regles de const:

Cal donar-li un valor en declarar-la. const x; és un SyntaxError.
No es pot reassignar després.

2.2 `let`: el valor pot canviar

let estat = 'pendent';
console.log(estat); // pendent

estat = 'en-curs';
console.log(estat); // en-curs

estat = 'feta';
console.log(estat); // feta

let sí que admet declarar-se sense valor inicial; en aquest cas la variable val undefined fins que li assignes alguna cosa:

let seguentResponsable;
console.log(seguentResponsable); // undefined

seguentResponsable = 'Lucía';
console.log(seguentResponsable); // Lucía

2.3 Quina fer servir

La regla és simple i no té excepcions pràctiques: fes servir const per defecte; fes servir let només quan sàpigues que el valor canviarà.

Per què? Perquè const comunica una intenció. Quan algú llegeix const dataLimit = ..., sap immediatament que aquest valor no canviarà en tota la funció. És informació gratuïta que redueix la càrrega mental de llegir codi.

// L'id i el títol d'una tasca no canvien mentre la processem
const id = 1;
const titol = 'Redissenyar la sala polivalent';

// L'estat sí que canvia al llarg de la vida de la tasca
let estat = 'pendent';

2.4 Un matís crucial sobre `const`

const no significa "el valor és immutable". Significa "la variable no es pot reassignar". Si el valor és un objecte o un array, el seu contingut sí que es pot modificar:

const etiquetes = ['disseny', 'espai'];

etiquetes.push('urgent');        // Permès: modifiquem el contingut
console.log(etiquetes);          // ['disseny', 'espai', 'urgent']

// etiquetes = ['una altra cosa']; // TypeError: no es pot reassignar

Això desconcerta molta gent. L'explicació és a l'apartat 10 (primitius enfront de referències) i es desenvolupa al Mòdul 4.

`var` i per què està desaconsellat

Abans d'ES2015 només existia var. El trobaràs en codi antic i en tutorials desactualitzats, així que convé saber per què es va abandonar.

3.1 Problema 1: àmbit de funció, no de bloc

function revisarTasques() {
  if (true) {
    var missatge = 'Amb var';
    let avis = 'Amb let';
  }
  console.log(missatge); // 'Amb var' — s'escapa del bloc
  // console.log(avis);  // ReferenceError — es queda a dins
}

var ignora les claus: només respecta els límits d'una funció. let i const respecten qualsevol bloc, que és el que resulta intuïtiu.

3.2 Problema 2: permet redeclarar

var responsable = 'Marta';
var responsable = 'Iván'; // Permès, sense cap avís

let hores = 8;
// let hores = 6; // SyntaxError: Identifier 'hores' has already been declared

Redeclarar per accident en un fitxer llarg és una manera silenciosa de perdre dades. let t'avisa.

3.3 Problema 3: hoisting confús

console.log(ambVar);  // undefined  (no falla, però enganya)
var ambVar = 'valor';

// console.log(ambLet); // ReferenceError: Cannot access 'ambLet' before initialization
let ambLet = 'valor';

Amb var obtens undefined en lloc d'un error, cosa que amaga el problema real. Amb let obtens un error clar. El mecanisme s'explica a Hoisting i el Context d'Execució.

3.4 Taula comparativa

Característica	`var`	`let`	`const`
Àmbit	Funció	Bloc	Bloc
Es pot reassignar	Sí	Sí	No
Es pot redeclarar	Sí	No	No
Ús abans de declarar	`undefined`	`ReferenceError`	`ReferenceError`
Requereix valor inicial	No	No	Sí
Crea propietat a l'objecte global	Sí	No	No
Recomanat avui	No	Sí, si canvia	Sí, per defecte

Conclusió: no escriguis var en codi nou. Només cal que el reconeguis quan el vegis.

Tipatge dinàmic i l'operador `typeof`

JavaScript és de tipatge dinàmic: les variables no tenen tipus, els valors sí. Una mateixa variable pot desar valors de tipus diferents al llarg del programa.

let dada = 'alta';    // ara conté un text
dada = 12;            // ara un nombre
dada = true;          // ara un booleà

És flexible, però també perillós: res no t'avisa si una variable acaba contenint una cosa diferent de la que esperaves.

Per saber quin tipus té un valor, existeix l'operador typeof:

console.log(typeof 'Marta');    // 'string'
console.log(typeof 12);         // 'number'
console.log(typeof true);       // 'boolean'
console.log(typeof undefined);  // 'undefined'
console.log(typeof Symbol());   // 'symbol'
console.log(typeof 10n);        // 'bigint'
console.log(typeof {});         // 'object'
console.log(typeof []);         // 'object'  ← un array també és 'object'
console.log(typeof null);       // 'object'  ← el famós error històric!

Les dues últimes línies mereixen atenció:

typeof [] retorna 'object' perquè en JavaScript un array és un tipus especial d'objecte.
typeof null retorna 'object' per una errada de la primeríssima implementació del 1995 que mai no s'ha corregit, perquè fer-ho trencaria codi existent. És la cicatriu històrica que vam esmentar a la primera lliçó.

4.1 El mapa de tipus

JavaScript té set tipus primitius i un tipus de referència (object, que engloba arrays, funcions, dates...).

flowchart TD
    T["Tipus de dades en JavaScript"]
    T --> P["Primitius<br/>(valor immutable)"]
    T --> O["Objectes<br/>(referència)"]
    P --> S["string"]
    P --> N["number"]
    P --> B["boolean"]
    P --> U["undefined"]
    P --> NU["null"]
    P --> SY["symbol"]
    P --> BI["bigint"]
    O --> OB["object · array · function · Date..."]

El tipus `string`: text

Un string és una seqüència de caràcters: noms, títols, estats, dates en format text.

5.1 Les tres maneres d'escriure text

const ambSimples = 'Redissenyar la sala polivalent';
const ambDobles = "Redissenyar la sala polivalent";
const ambPlantilla = `Redissenyar la sala polivalent`;

Les cometes simples i dobles són equivalents. La convenció majoritària en JavaScript és fer servir cometes simples, i reservar les dobles per quan el text contingui un apòstrof:

const nota = "La Marta diu que el taller no està a punt";
const altra = 'La Marta diu que el taller no està a punt';
const ambApostrof = "L'espai polivalent";  // més còmode amb dobles

També pots escapar un caràcter amb la barra invertida:

const escapat = 'L\'espai polivalent';

5.2 Template literals: la forma moderna

Els template literals fan servir accents greus (`) i aporten dos superpoders.

Superpoder 1: interpolació amb ${}. Pots inserir el valor de qualsevol expressió dins del text:

const responsable = 'Iván';
const horesEstimades = 12;

// Forma antiga: concatenació
const antiga = 'Tasca de ' + responsable + ': ' + horesEstimades + ' hores';

// Forma moderna: template literal
const moderna = `Tasca de ${responsable}: ${horesEstimades} hores`;

console.log(moderna); // Tasca de Iván: 12 hores

Es llegeix moltíssim millor, i desapareixen els errors d'espais oblidats entre cometes.

Dins de ${} hi pot anar qualsevol expressió, no només una variable:

const horesIvan = 12;
const horesLucia = 8;
console.log(`Càrrega conjunta: ${horesIvan + horesLucia} hores`); // 20 hores

Superpoder 2: salts de línia reals. El text s'escriu tal qual, en diverses línies:

const resum = `Tasca: Redissenyar la sala polivalent
Responsable: Iván
Prioritat: alta`;

console.log(resum);

Amb cometes normals caldria fer servir \n, que es llegeix molt pitjor.

5.3 Propietats i mètodes bàsics

Encara que string és un primitiu, JavaScript et permet fer servir propietats i mètodes sobre ell:

const titol = 'Redissenyar la sala polivalent';

console.log(titol.length);          // 30 — nombre de caràcters
console.log(titol.toUpperCase());   // REDISSENYAR LA SALA POLIVALENT
console.log(titol.includes('sala')); // true
console.log(titol[0]);              // 'R' — primer caràcter (posició 0)

Un detall fonamental: els strings són immutables. Cap mètode modifica l'original; tots en retornen un de nou.

const original = 'pendent';
const enMajuscules = original.toUpperCase();

console.log(original);      // 'pendent' — intacte
console.log(enMajuscules);  // 'PENDENT' — string nou

El tipus `number`: nombres

JavaScript té un sol tipus numèric: number. No distingeix entre enters i decimals com altres llenguatges.

const horesEstimades = 12;      // enter
const horesReals = 12.5;        // decimal
const desviacio = -0.5;         // negatiu
const gairebeZero = 1.5e-4;     // notació científica: 0.00015
const ambSeparador = 1_000_000; // el guió baix millora la lectura

6.1 Valors numèrics especials

Hi ha tres valors que són de tipus number però no són nombres normals:

Valor	Significa	Com apareix
`Infinity`	Infinit positiu	`1 / 0`, o un nombre massa gran
`-Infinity`	Infinit negatiu	`-1 / 0`
`NaN`	Not a Number: resultat no numèric	`'alta' * 2`, `Number('hola')`

console.log(10 / 0);            // Infinity
console.log('alta' * 2);        // NaN
console.log(typeof NaN);        // 'number' ← sí, NaN és de tipus number

NaN té una propietat desconcertant: no és igual a si mateix.

console.log(NaN === NaN); // false

Per això, per detectar-lo es fa servir la funció Number.isNaN():

const hores = Number('dotze'); // NaN
console.log(Number.isNaN(hores)); // true

NaN és el resultat típic d'un error de dades: algú va escriure text on esperaves un nombre. Veure'l a la consola gairebé sempre significa "revisa d'on ve aquesta dada".

6.2 La precisió en coma flotant

Aquest és un dels primers ensurts de tot programador:

console.log(0.1 + 0.2);           // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);   // false

No és una fallada de JavaScript. Els nombres s'emmagatzemen en binari seguint l'estàndard IEEE 754, i alguns decimals (com 0.1) no tenen representació binària exacta, igual que 1/3 no té representació decimal exacta. Gairebé tots els llenguatges es comporten igual.

Solucions pràctiques:

const total = 0.1 + 0.2;

// Arrodonir als decimals que necessitis
console.log(total.toFixed(2));         // '0.30' (compte: retorna un string)
console.log(Number(total.toFixed(2))); // 0.3 (nombre)

// Comparar amb una tolerància
console.log(Math.abs(total - 0.3) < Number.EPSILON); // true

Consell professional: per a diners, no facis servir decimals. Desa els cèntims com a enters. A Nómada Tasques treballarem amb hores, on mig punt de precisió és més que suficient.

6.3 Operacions matemàtiques útils

const hores = 12.7;

console.log(Math.round(hores));  // 13 — arrodoniment normal
console.log(Math.floor(hores));  // 12 — cap avall
console.log(Math.ceil(hores));   // 13 — cap amunt
console.log(Math.max(12, 8, 6)); // 12
console.log(Math.min(12, 8, 6)); // 6

El tipus `boolean`: cert o fals

Un boolean només pot valer true o false. És el tipus de les decisions.

const estaCompletada = false;
const esUrgent = true;

Els booleans solen sorgir de comparacions:

const horesEstimades = 12;
const esTascaLlarga = horesEstimades > 8;

console.log(esTascaLlarga);        // true
console.log(typeof esTascaLlarga); // 'boolean'

Convenció de noms: als booleans se'ls posa un nom que es llegeixi com una afirmació certa o falsa: esUrgent, estaCompletada, teEtiquetes, esPotEditar. Compara if (estaCompletada) amb if (completada): el primer es llegeix sol.

`undefined` i `null`

Tots dos representen "absència de valor", però no són el mateix, i la diferència és conceptual:

	`undefined`	`null`
Significat	"No s'ha assignat cap valor"	"Deliberadament buit"
Qui l'hi posa	JavaScript, automàticament	Tu, explícitament
`typeof`	`'undefined'`	`'object'` (error històric)
Quan apareix	Variable declarada sense valor, paràmetre no passat, propietat inexistent	Quan decideixes que una cosa és buida

// undefined: JavaScript no té res per posar-hi
let seguentRevisor;
console.log(seguentRevisor); // undefined

// null: nosaltres declarem que no hi ha responsable assignat
let responsable = null;
console.log(responsable); // null

La distinció pràctica a Nómada Tasques: si una tasca encara no té responsable, farem servir null (sabem que està sense assignar). Si consultem un camp que ni tan sols existeix, obtindrem undefined (no hi ha informació).

console.log(null == undefined);  // true  ← comparació laxa
console.log(null === undefined); // false ← comparació estricta

Aquest contrast és la porta d'entrada a la lliçó vinent; allà veuràs per què passa.

`symbol` i `bigint`

Els dos primitius restants són especialitzats. N'hi ha prou que sàpigues que existeixen.

symbol (ES2015) crea identificadors únics i irrepetibles, utilitzats sobretot com a claus de propietat que no col·lideixen amb d'altres:

const clau1 = Symbol('id');
const clau2 = Symbol('id');
console.log(clau1 === clau2); // false — cada símbol és únic

bigint (ES2020) permet treballar amb enters més grans dels que number pot representar amb exactitud. S'escriu afegint n al final:

const enorme = 9007199254740993n;
console.log(typeof enorme); // 'bigint'

És útil en criptografia o identificadors molt grans. A Nómada Tasques no el necessitarem: els id de tasca seran nombres normals.

Primitius enfront de referències

Aquesta és la idea més important de la lliçó i la que més errors evita a llarg termini.

Els valors primitius es copien per valor. En assignar una variable primitiva a una altra, es copia el contingut: queden dos valors independents.

let horesIvan = 12;
let horesLucia = horesIvan; // es copia el valor 12

horesLucia = 8;

console.log(horesIvan);  // 12 — no l'ha afectat
console.log(horesLucia); // 8

Els objectes i arrays es copien per referència. En assignar-los, no es copia el contingut: es copia l'adreça on és el contingut. Les dues variables apunten al mateix lloc.

const etiquetesIvan = ['disseny', 'espai'];
const etiquetesCopia = etiquetesIvan; // es copia la referència, no la llista

etiquetesCopia.push('urgent');

console.log(etiquetesIvan);  // ['disseny', 'espai', 'urgent'] ← també ha canviat!
console.log(etiquetesCopia); // ['disseny', 'espai', 'urgent']

Això sorprèn sempre la primera vegada. L'analogia habitual: un primitiu és com fotocopiar un document (dos papers independents); un objecte és com enviar l'adreça d'una casa (dues persones amb la mateixa adreça entren a la mateixa casa).

flowchart TD
    subgraph PR["Primitius: còpia per valor"]
        A1["horesIvan → 12"]
        A2["horesLucia → 12"]
        A1 -.->|còpia independent| A2
    end
    subgraph RE["Objectes: còpia per referència"]
        B1["etiquetesIvan"] --> C["['disseny','espai','urgent']"]
        B2["etiquetesCopia"] --> C
    end

I això explica també el comportament de const que hem vist abans: const protegeix la referència, no el contingut apuntat.

Com copiar objectes de debò (còpia superficial i profunda) s'estudia a JSON i Còpies d'Objectes. Per ara queda't amb la idea: primitius, còpia; objectes, referència compartida.

Modelar una tasca de Nómada Tasques

Apliquem tot el que hem après. Aquests són els camps d'una tasca de Taller Nómada amb el tipus que correspon a cadascun:

Camp	Tipus	Per què aquest tipus	Exemple
`id`	`number`	Identificador numèric correlatiu	`1`
`titol`	`string`	Text lliure	`'Redissenyar la sala polivalent'`
`responsable`	`string` (o `null`)	Nom de la persona; `null` si està sense assignar	`'Iván'`
`prioritat`	`string`	Un de tres valors fixos	`'alta'`
`estat`	`string`	Un de tres valors fixos	`'en-curs'`
`etiquetes`	`array` de `string`	Zero o més etiquetes	`['disseny', 'espai']`
`horesEstimades`	`number`	Quantitat, admet decimals	`12`
`dataLimit`	`string`	Data ISO `'yyyy-mm-dd'`: s'ordena bé com a text	`'2026-09-30'`

I el codi, fent servir només el que hem vist en aquesta lliçó:

'use strict';

// --- Tasca 1 de Taller Nómada -------------------------------------
const id = 1;                                    // number
const titol = 'Redissenyar la sala polivalent';  // string
const responsable = 'Iván';                      // string
const prioritat = 'alta';                        // string
let estat = 'en-curs';                           // string (canviarà: let)
const etiquetes = ['disseny', 'espai'];          // array de strings
const horesEstimades = 12;                       // number
const dataLimit = '2026-09-30';                  // string ISO

// Un valor derivat, calculat a partir d'altres
const esTascaLlarga = horesEstimades > 8;        // boolean

// Encara no sabem qui la revisarà
const revisor = null;                            // null: buit expressament

// Resum amb template literals
console.log(`[${id}] ${titol}`);
console.log(`Responsable: ${responsable} · Prioritat: ${prioritat}`);
console.log(`Estat: ${estat} · ${horesEstimades} h · Venç: ${dataLimit}`);
console.log(`Etiquetes: ${etiquetes.join(', ')}`);
console.log(`Tasca llarga? ${esTascaLlarga}`);
console.log(`Revisor assignat: ${revisor}`);

Sortida:

[1] Redissenyar la sala polivalent
Responsable: Iván · Prioritat: alta
Estat: en-curs · 12 h · Venç: 2026-09-30
Etiquetes: disseny, espai
Tasca llarga? true
Revisor assignat: null

Decisions de disseny que convé entendre:

estat és let perquè una tasca passa de 'pendent' a 'en-curs' i a 'feta'. Tota la resta és const.
dataLimit és un string, no un objecte Date. El format ISO yyyy-mm-dd té una propietat molt pràctica: ordenat alfabèticament coincideix amb l'ordre cronològic. Simplifica moltíssim la feina.
esTascaLlarga no és una dada: és un càlcul. Es deriva d'horesEstimades. No es desa com a camp de la tasca.
revisor és null, no undefined. Estem afirmant que no hi ha revisor, no que no en sapiguem res.

Ara mateix són vuit variables soltes, cosa incòmoda si cal manejar tres tasques. Al Mòdul 4 aprendràs a agrupar-les en un objecte, que és com estaran realment a Nómada Tasques.

Errors Habituals i Consells

Errors habituals

Creure que const congela el contingut. Protegeix la variable davant de reassignacions, no l'objecte al qual apunta.
Fer servir let per defecte. Comença sempre per const i canvia a let només quan el compilador mental et digui "això canvia".
Confondre el nombre 12 amb l'string '12'. Semblen iguals a la consola però es comporten de manera molt diferent: 12 + 12 és 24, '12' + '12' és '1212'. La lliçó vinent es dedica a això.
Comparar decimals amb ===. 0.1 + 0.2 === 0.3 és false. Fes servir toFixed o una tolerància.
Comparar amb NaN. NaN === NaN és false. Fes servir Number.isNaN().
Fer servir null i undefined indistintament. undefined l'hi posa JavaScript; null l'hi poses tu. Mantén la distinció i el teu codi dirà més.
Copiar un array esperant independència. const copia = original; no copia res: comparteix la mateixa llista.

Consells

const per defecte, let quan canviï, var mai.
Fes servir template literals per a tot text que combini variables. Menys errors i millor lectura.
Anomena els booleans com afirmacions: esUrgent, estaFeta, teRevisor.
Fes servir typeof quan alguna cosa es comporti de manera estranya. Un console.log(typeof x, x) resol la meitat dels misteris.
Desa les dates en format ISO 'yyyy-mm-dd'. S'ordenen soles i es llegeixen igual a qualsevol país.
Escriu els nombres decimals amb cura en diners i percentatges. Arrodoneix en mostrar, no en calcular.

Exercicis

Exercici 1: Tria el tipus correcte

Per a cada dada de Taller Nómada, indica el tipus més adequat, si faries servir let o const, i escriu la línia de codi:

L'identificador d'una tasca, que val 7 i no canviarà.
El nombre de tasques pendents, que anirà variant.
Si el taller de serigrafia està reservat per dijous.
El nom de la persona que revisarà la tasca, encara sense decidir.
El nombre màxim d'hores setmanals de l'equip: 40, valor fix de configuració.
Les hores dedicades fins ara, que valen 3.5 i augmentaran.

Exercici 2: Prediu la sortida

Sense executar el codi, escriu el que imprimeix cada línia i explica per què:

let horesIvan = 12;
let horesLucia = horesIvan;
horesLucia = 8;
console.log(horesIvan, horesLucia);          // A

const etiquetes = ['disseny'];
const copia = etiquetes;
copia.push('urgent');
console.log(etiquetes.length);               // B

console.log(typeof null);                    // C
console.log(typeof NaN);                     // D
console.log(0.1 + 0.2 === 0.3);              // E

const titol = 'Revisar factures';
titol.toUpperCase();
console.log(titol);                          // F

let revisor;
console.log(revisor === null);               // G

Exercici 3: Fitxa completa amb template literals

Escriu un script que declari, amb el tipus i la paraula clau adequats, tots els camps d'aquesta tasca:

id: 4
Títol: Muntar exposició de tardor
Responsable: Lucía
Prioritat: mitjana
Estat: pendent (podrà canviar)
Etiquetes: muntatge, esdeveniment
Hores estimades: 7.5
Data límit: 2026-11-05

Després, calcula i mostra:

Una capçalera amb l'id i el títol, fent servir un template literal.
Una línia amb responsable, prioritat i estat.
Un booleà esTascaLlarga (més de 8 hores) mostrat com a text.
El nombre d'etiquetes.
El títol en majúscules, comprovant després que l'original continua intacte.
El tipus d'horesEstimades i el de dataLimit, fent servir typeof.

Solucions

Exercici 1

#	Tipus	Paraula clau	Codi
1	`number`	`const`	`const id = 7;`
2	`number`	`let`	`let tasquesPendents = 5;`
3	`boolean`	`const`	`const estaReservatDijous = true;`
4	`null`	`let`	`let revisor = null;`
5	`number`	`const`	`const MAX_HORES_SETMANA = 40;`
6	`number`	`let`	`let horesDedicades = 3.5;`

El cas 4 mereix un comentari: fem servir null perquè sabem que no hi ha revisor assignat, i let perquè més endavant n'hi haurà un. El cas 5 va en UPPER_SNAKE_CASE per ser una constant global de configuració.

Exercici 2

Línia	Sortida	Explicació
A	`12 8`	Els nombres són primitius: en assignar es copia el valor, queden independents
B	`2`	Els arrays es copien per referència: `copia` i `etiquetes` són la mateixa llista
C	`'object'`	Error històric del 1995 que mai no es va corregir per compatibilitat
D	`'number'`	`NaN` és de tipus `number`: representa un resultat numèric no vàlid
E	`false`	`0.1 + 0.2` dona `0.30000000000000004` per la representació binària IEEE 754
F	`'Revisar factures'`	Els strings són immutables: `toUpperCase()` en retorna un de nou que aquí es descarta
G	`false`	`revisor` val `undefined`, i `undefined === null` és `false` (tipus diferents)

Exercici 3

'use strict';

// --- Dades de la tasca --------------------------------------------
const id = 4;
const titol = 'Muntar exposició de tardor';
const responsable = 'Lucía';
const prioritat = 'mitjana';
let estat = 'pendent';                     // let: canviarà amb el temps
const etiquetes = ['muntatge', 'esdeveniment'];
const horesEstimades = 7.5;
const dataLimit = '2026-11-05';

// --- Valors derivats ----------------------------------------------
const esTascaLlarga = horesEstimades > 8;  // false
const titolEnMajuscules = titol.toUpperCase();

// --- Sortida -------------------------------------------------------
console.log(`[${id}] ${titol}`);
console.log(`Responsable: ${responsable} · Prioritat: ${prioritat} · Estat: ${estat}`);
console.log(`Tasca llarga? ${esTascaLlarga} (${horesEstimades} h, venç ${dataLimit})`);
console.log(`Etiquetes (${etiquetes.length}): ${etiquetes.join(', ')}`);
console.log(`En majúscules: ${titolEnMajuscules}`);
console.log(`Original intacte: ${titol}`);
console.log(`Tipus d'horesEstimades: ${typeof horesEstimades}`);
console.log(`Tipus de dataLimit: ${typeof dataLimit}`);

Sortida:

[4] Muntar exposició de tardor
Responsable: Lucía · Prioritat: mitjana · Estat: pendent
Tasca llarga? false (7.5 h, venç 2026-11-05)
Etiquetes (2): muntatge, esdeveniment
En majúscules: MUNTAR EXPOSICIÓ DE TARDOR
Original intacte: Muntar exposició de tardor
Tipus d'horesEstimades: number
Tipus de dataLimit: string

Fixa't en l'última línia: dataLimit és un string, no un tipus de data. És una decisió deliberada del projecte i la mantindrem durant tot el curs.

Conclusió

Ja saps desar informació. Declares variables amb const per defecte i let quan el valor canvia, i entens per què var pertany al passat (àmbit de funció, redeclaració permesa i hoisting enganyós). Coneixes el tipatge dinàmic i l'operador typeof, amb les seves dues raresses famoses (typeof null i typeof [] retornen 'object'). Domines els primitius: string amb els seus template literals i la interpolació ${}, number amb NaN, Infinity i la precisió en coma flotant, boolean, la distinció entre undefined i null, i l'existència de symbol i bigint. I has entès la diferència entre còpia per valor (primitius) i còpia per referència (objectes i arrays), que explica per què const no congela un array.

Sobretot, has modelat per primera vegada una tasca completa de Nómada Tasques triant el tipus adequat per a cada camp.

Ara que tens dades, el pas natural és operar-hi. A la lliçó següent, Operadors Bàsics, aprendràs a sumar hores, calcular percentatges d'avenç, combinar condicions lògiques i fer servir operadors moderns com ?? i ?.. Amb ells calcularàs la càrrega de treball real de la Marta, l'Iván i la Lucía.

Variables i Tipus de Dades

Contingut

Què és una variable

Declarar variables: let i const

2.1 const: el valor no es reassigna

2.2 let: el valor pot canviar

2.3 Quina fer servir

2.4 Un matís crucial sobre const

var i per què està desaconsellat

3.1 Problema 1: àmbit de funció, no de bloc

3.2 Problema 2: permet redeclarar

3.3 Problema 3: hoisting confús

3.4 Taula comparativa

Tipatge dinàmic i l'operador typeof

4.1 El mapa de tipus

El tipus string: text

5.1 Les tres maneres d'escriure text

5.2 Template literals: la forma moderna

5.3 Propietats i mètodes bàsics

El tipus number: nombres

6.1 Valors numèrics especials

6.2 La precisió en coma flotant

6.3 Operacions matemàtiques útils

El tipus boolean: cert o fals

undefined i null

symbol i bigint

Primitius enfront de referències

Modelar una tasca de Nómada Tasques

Errors Habituals i Consells

Exercicis

Exercici 1: Tria el tipus correcte

Exercici 2: Prediu la sortida

Exercici 3: Fitxa completa amb template literals

Solucions

Conclusió

Curs de JavaScript: De Principiant a Avançat

Mòdul 1: Introducció a JavaScript

Mòdul 2: Estructures de Control

Mòdul 3: Funcions

Mòdul 4: Objectes i Arrays

Mòdul 5: Objectes i Funcions Avançades

Mòdul 6: El Model d'Objectes del Document (DOM)

Mòdul 7: APIs del Navegador i Temes Avançats

Mòdul 8: Proves i Depuració

Mòdul 9: Rendiment i Optimització

Mòdul 10: Frameworks i Llibreries de JavaScript

Mòdul 11: Projecte Final