Salta al contenuto principale

03 - Quanti file JavaScript scarica una pagina Angular SSR: contarli con il Resource Timing

Una pagina articolo chiede 69 file JavaScript per 801 KB, la home 51 per 638 KB. L'HTML ne dichiara 3: gli altri li chiede il codice mentre gira.

Cosa ne pensi di questo articolo?

03 - Quanti file JavaScript scarica una pagina Angular SSR: contarli con il Resource Timing
Angular Performancefedericocalo.dev

In Breve

Una pagina articolo chiede 69 file JavaScript per 801 KB, la home 51 per 638 KB. L'HTML ne dichiara 3: gli altri li chiede il codice mentre gira.

In breve. Una pagina Angular ben fatta non scarica un solo main.js: scarica un file principale e molti blocchi caricati a richiesta. La domanda utile non è «quanto pesa il bundle», è quanti file e quanti kilobyte arrivano davvero quando apri quella pagina, e questo si conta in un minuto con l'API Resource Timing del browser. Su questo sito, l'8 novembre 2026, con un telefono emulato e una rete non limitata, la home richiede 51 file JavaScript di proprietà del sito per 638 KB trasferiti, la pagina /servizi 56 file per 681 KB e una pagina articolo 69 file per 801 KB. Il documento HTML di un articolo dichiara solo 3 tag script e 20 suggerimenti modulepreload: gli altri file li chiede il codice mentre gira.

I numeri dicono quanto codice la pagina tira giù, non quanto costa eseguirlo, e non spiegano perché sono 69 e non 30. Questa parte ti dà lo script, ti mostra che cosa vede e che cosa non può vedere - compreso un dettaglio della specifica per cui il totale che leggi è gonfiato di una costante - e dice con chiarezza cosa resta da misurare con una build che qui non ho lanciato.

Metodo. Chromium headless di Playwright 1.59.1 (build chromium_headless_shell-1234), Node.js 24.11.0, profilo Pixel 7, nessuna limitazione di rete o CPU, produzione di federicocalo.dev l'8 novembre 2026. Il progetto usa @angular/core 21.2.14 (verificato con node -p "require('@angular/core/package.json').version"). Ogni conteggio e ogni peso riportati qui si sono ripetuti identici in due esecuzioni a un'ora di distanza; i tempi, come vedrai, no.

È la terza parte di una serie in cui misuro questo sito prima di toccarlo: nella prima parte ho misurato i tempi e ho scoperto quanto variano, nella seconda una larghezza che non varia affatto. Qui si contano file e byte, che stanno nel mezzo: stabili entro la stessa versione del sito, diversi a ogni pubblicazione.

Che cosa significa «pesante»

Una pagina può essere pesante in tre modi diversi, e confonderli porta a ottimizzare la cosa sbagliata. Può richiedere molte richieste, ognuna con la sua latenza. Può trasferire molti byte sul filo, già compressi.

Può imporre molto lavoro al processore per interpretare ed eseguire il codice una volta scaricato. L'API Resource Timing risponde alle prime due; la terza richiede il profilo del thread principale, che qui non ho preso.

Nel campo transferSize di ogni voce c'è la dimensione trasferita, e qui va letta la specifica invece di tirare a indovinare: non è «il corpo più le intestazioni vere». La specifica W3C prescrive tre casi - zero se la risorsa è arrivata dalla cache locale, esattamente 300 se è stata rivalidata, altrimenti la dimensione compressa del corpo più 300 - e spiega perché: quella costante sta al posto del peso reale delle intestazioni, che esporre rivelerebbe la presenza di certi cookie.

Tradotto in conseguenza sui miei numeri: il totale di 801 KB su una pagina articolo contiene 69 volte quella costante, cioè circa 20 KB, il 2,5% del totale, che non è codice. È poco, e però è esattamente il genere di dettaglio per cui un numero preso da un'API va letto nella specifica dell'API: chi conta pochi file grandi sbaglia poco, chi conta molti file piccoli sbaglia tanto.

Un limite da conoscere subito, dalla documentazione MDN di PerformanceResourceTiming.transferSize: per le risorse di un'altra origine, il valore è zero se il server non invia l'intestazione Timing-Allow-Origin con l'origine che chiede.

Per questo sito significa che gli script di terze parti, Tag Manager, Analytics e Clarity, compaiono nell'elenco con zero byte, e che il mio totale riguarda solo gli script serviti dal sito stesso. Il costo reale della pagina è più alto di quanto scrivo.

Lo script

Lo script apre ogni percorso una volta, aspetta tre secondi dopo l'evento load, poi dalla pagina legge tutte le voci di tipo risorsa il cui percorso finisce in .js, le divide fra quelle della stessa origine e le altre, e conta quanti file superano i 50 KB. La soglia di 50 KB è una mia scelta di comodo per far emergere i pezzi grossi, non un valore consigliato da qualcuno.


import { chromium, devices } from 'playwright';

const [origine, ...percorsi] = process.argv.slice(2);
const browser = await chromium.launch({ executablePath: process.env.CHROME_PATH });

for (const percorso of percorsi) {
  const page = await (await browser.newContext({ ...devices['Pixel 7'] })).newPage();
  await page.goto(origine + percorso, { waitUntil: 'load' });
  await page.waitForTimeout(3000);
  const r = await page.evaluate((origine) => {
    const js = performance.getEntriesByType('resource').filter((e) => new URL(e.name).pathname.endsWith('.js'));
    const mia = js.filter((e) => e.name.startsWith(origine));
    const altri = js.filter((e) => !e.name.startsWith(origine));
    const kb = (v) => Math.round(v.reduce((s, e) => s + e.transferSize, 0) / 1024);
    return {
      mioN: mia.length, mioKB: kb(mia),
      altriN: altri.length, altriKB: kb(altri),
      sopra50: mia.filter((e) => e.transferSize > 50 * 1024).length,
    };
  }, origine);
  console.log(percorso, JSON.stringify(r));
}
await browser.close();

Il comando prende l'origine e poi i percorsi, uno per argomento. Ne ho scelti quattro con un criterio: la home, una pagina di contenuto statico come /servizi, e due articoli diversi invece di uno, perché due articoli sono il minimo per distinguere il costo della rotta dal costo del testo che contiene.


CHROME_PATH=$HOME/.cache/ms-playwright/chromium_headless_shell-1234/chrome-headless-shell-linux64/chrome-headless-shell \
node peso-js.mjs https://federicocalo.dev /it/ /it/servizi \
  /it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026 \
  /it/blog/workflow-professionale-progetto-angular-cursor

L'uscita, una riga per percorso: mioN e mioKB sono file e kilobyte serviti da questo dominio, altriN e altriKB quelli di terze parti, sopra50 il numero di file oltre i 50 KB.


/it/ {"mioN":51,"mioKB":638,"altriN":1,"altriKB":0,"sopra50":4}
/it/servizi {"mioN":56,"mioKB":681,"altriN":1,"altriKB":0,"sopra50":4}
/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026 {"mioN":69,"mioKB":801,"altriN":1,"altriKB":0,"sopra50":5}
/it/blog/workflow-professionale-progetto-angular-cursor {"mioN":69,"mioKB":801,"altriN":1,"altriKB":0,"sopra50":5}

Tre cose si leggono subito. La prima: due articoli diversi hanno esattamente gli stessi numeri, 69 file e 801 KB, il che suggerisce che il costo sia della forma della pagina (la rotta, i componenti) e non del testo dell'articolo. È un'inferenza da due campioni, non una prova.

La seconda: la home pesa meno di una pagina di dettaglio, e il passaggio da 51 a 69 file non si spiega con la quantità di testo. La terza: le voci di terze parti sono una sola, con zero byte, e questo è l'effetto di Timing-Allow-Origin descritto sopra; non significa che Tag Manager non carichi nulla.

Cosa dichiara l'HTML e cosa chiede il browser

Il documento della pagina è il punto di partenza di tutto quello che arriva dopo, e si può leggere senza browser. Ho scaricato l'HTML di una pagina articolo e ho contato i tag:


curl -s --compressed https://federicocalo.dev/it/blog/workflow-professionale-progetto-angular-cursor -o pagina.html
grep -o 'rel="modulepreload"' pagina.html | wc -l
grep -o '<script[^>]*src=[^>]*>' pagina.html | wc -l

20
3

Venti suggerimenti modulepreload e tre tag script con src. Il browser arriva a 69 file JavaScript: gli altri vengono chiesti dal codice mentre gira, presumibilmente con import() dinamici, che è il meccanismo dietro un componente di rotta definito con loadComponent (non l'ho verificato aprendo i file).

Il progetto non fa eccezione: nei file di rotte sotto frontend/src/app ci sono 737 occorrenze di loadComponent, contate con grep -ro "loadComponent" src/app --include=*routes*.ts | wc -l.

Molte rotte, quindi, sono caricate a richiesta. Non ho, però, aperto uno per uno i 69 file per dire a quale rotta o componente appartenga ciascuno: senza una build e il suo file di statistiche, i nomi dei blocchi (chunk-FGG2EIKH.js e simili) sono hash che non rimandano al codice sorgente.

I blocchi grossi, e un dettaglio sul tempo

I pezzi sopra i 50 KB sono 4 sulla home e 5 sugli articoli. Per vederli uno per uno basta cambiare il corpo dello script: invece dei totali, l'elenco ordinato per peso, con il nome del file e il momento in cui la richiesta è partita.


const r = await page.evaluate((o) => performance.getEntriesByType('resource')
  .filter((e) => new URL(e.name).pathname.endsWith('.js') && e.name.startsWith(o))
  .map((e) => ({ f: e.name.split('/').pop(), kb: Math.round(e.transferSize / 1024), start: Math.round(e.startTime) }))
  .sort((a, b) => b.kb - a.kb).slice(0, 6), origine);

/it/
   176 KB  start   568 ms  chunk-FGG2EIKH.js
    87 KB  start   568 ms  chunk-TTPLJXEB.js
    81 KB  start   569 ms  chunk-MATBZCZT.js
    61 KB  start   388 ms  main-JWNIMX6J.js
    33 KB  start   387 ms  chunk-IW5ICXUF.js
    27 KB  start   566 ms  chunk-WGHKVMTA.js
/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026
   176 KB  start  1776 ms  chunk-FGG2EIKH.js
    87 KB  start  1776 ms  chunk-TTPLJXEB.js
    81 KB  start  1776 ms  chunk-MATBZCZT.js
    63 KB  start  2259 ms  chunk-6ON7HASR.js
    61 KB  start  1593 ms  main-JWNIMX6J.js
    41 KB  start  1593 ms  chunk-F744HDVC.js

Le prime tre righe sono identiche sulle due pagine, nomi compresi: chunk-FGG2EIKH, chunk-TTPLJXEB e chunk-MATBZCZT valgono 344 KB di codice condiviso che ogni pagina paga, qualunque cosa tu stia leggendo. La differenza fra la home e l'articolo non sta lì: sta nel chunk-6ON7HASR da 63 KB, che sulla home non compare.

La colonna dei tempi dice un'altra cosa: il file principale parte prima dei tre blocchi grossi (388 contro 568 ms sulla home, 1593 contro 1776 ms sull'articolo), e fra questi sei file quello specifico dell'articolo parte per ultimo, a 2259 ms. La catena è sequenziale: il documento chiede il principale, il principale chiede i blocchi condivisi, e l'ultimo arriva quando i precedenti sono già in volo.

Sui millisecondi, però, non costruisco nessuna conclusione, e ho il modo di mostrarti perché. Ho rieseguito lo stesso script un'ora dopo, sulla stessa produzione, e questa è la colonna dei tempi della pagina articolo nelle due tornate, affiancata alla colonna dei pesi:


file                   KB    start 1a tornata   start 2a tornata
chunk-FGG2EIKH.js     176       1776 ms            5038 ms
chunk-TTPLJXEB.js      87       1776 ms            5038 ms
chunk-MATBZCZT.js      81       1776 ms            5038 ms
chunk-6ON7HASR.js      63       2259 ms            5424 ms
main-JWNIMX6J.js       61       1593 ms            4933 ms
chunk-F744HDVC.js      41       1593 ms            4933 ms

Nomi identici, kilobyte identici al byte arrotondato, ordine identico - e tempi quasi triplicati: 5038 ms contro 1776 per lo stesso blocco. Non ho cambiato nulla fra le due esecuzioni. È la stessa lezione della prima parte, vista da un'altra API: in questa tabella due colonne su tre sono fatti e una è un aneddoto. Peso e numero di file li puoi citare; i millisecondi di una singola esecuzione no, e quando li vedi in un articolo senza un intervallo accanto sai che qualcuno ha misurato una volta sola.

Dove si interviene, e dove ho scelto di non farlo

La documentazione di Angular sul blocco @defer (pagina corrente al 2026-11-08, il progetto è sulla 21.2.14) indica due condizioni perché le dipendenze di un blocco vengano davvero rimandate: devono essere standalone e non devono essere referenziate fuori da blocchi @defer nello stesso file.

Con il rendering lato server, la stessa pagina spiega che i blocchi @defer mostrano di default il loro @placeholder, e che per rendere sul server il contenuto principale serve l'idratazione incrementale con i trigger hydrate: il meccanismo è raccontato per intero nell'articolo su Angular SSR e idratazione incrementale.

Questo sito usa già @defer: undici template lo contengono, e la forma più frequente è @defer (hydrate on viewport), sedici volte (grep -rho "@defer ([^)]*)" src/app --include=*.html | sort | uniq -c | sort -rn). Prima di aggiungerne un altro serve sapere quale dei 69 file lo giustifica.

Il percorso è questo: una build con il file di statistiche di esbuild per riconoscere i blocchi, poi un confronto prima e dopo con lo script qui sopra. Non ho lanciato una build (dura circa 18 minuti), perciò quel passo resta aperto e non scrivo che cosa troverà.

Cosa questo metodo non ti dice

  • Il lavoro del processore per eseguire lo script: né il tempo di analisi né quello di esecuzione.
  • I byte delle terze parti, per l'assenza di Timing-Allow-Origin.
  • Quale rotta o componente corrisponda a un blocco: servono i nomi della build.
  • Quanto una pagina carichi con la cache calda: ogni caricamento qui parte da un contesto pulito.
  • Quanto costi su una rete lenta: la mia non era limitata.

Le cinque voci non sono difetti dello strumento: sono il confine fra «quanto codice arriva» e «quanto costa», e il Resource Timing risponde solo alla prima domanda. La più importante è la prima, perché è quella che inverte le decisioni: 801 KB su fibra sono un dettaglio, gli stessi 801 KB da interpretare su un telefono di fascia media sono il motivo per cui una pagina resta ferma. La terza, invece, è l'unica che posso togliere oggi senza strumenti nuovi, perché basta una build con il file di statistiche; le altre richiedono un profilo del processore o una rete finta, cioè un altro articolo e un altro metodo.

Adesso sai fare questo

Sai contare i file JavaScript e i kilobyte che una pagina Angular SSR richiede davvero, separare quelli del tuo sito da quelli di terze parti sapendo perché il secondo gruppo risulta a zero, leggere transferSize per quello che la specifica dice che sia, confrontare ciò che l'HTML dichiara con ciò che il browser scarica, e sai che cosa serve (una build con le statistiche) per passare da «69 file» a «questo componente».

Con le tre parti della serie hai anche il metodo intero: i tempi variano e si riportano con mediana e intervallo (parte 1), le larghezze non variano e si trattano come asserzioni in un test (parte 2), i conteggi stanno nel mezzo e cambiano a ogni pubblicazione. Il passo che resta aperto è uno solo, e lo dichiaro invece di prometterlo: mettere accanto ai 69 file i nomi dei componenti, che richiede una build e un confronto prima-dopo che qui non ho eseguito.

Fonti

  • PerformanceResourceTiming.transferSize, MDN - il valore a zero per le risorse cross-origin senza Timing-Allow-Origin, consultata il 2026-11-08
  • Resource Timing, specifica W3C - i tre casi di transferSize (0 dalla cache locale, 300 se rivalidata, corpo compresso più 300 altrimenti) e §3.5.2 sull'intestazione Timing-Allow-Origin, consultata il 2026-11-08
  • Deferrable views, angular.dev - condizioni di @defer (standalone, nessun riferimento fuori dal blocco), comportamento sul server e idratazione incrementale, consultata il 2026-11-08
  • Misura sulla produzione: node peso-js.mjs come sopra, Playwright 1.59.1, 2026-11-08
  • Conteggi nel repository: grep -ro "loadComponent" src/app --include=*routes*.ts | wc -l (737) e grep -rl "@defer" src/app --include=*.html | wc -l (11), 2026-11-08

Delle quattro voci, le due specifiche servono a cose diverse: quella del Resource Timing dice come leggere un numero che l'API mi regala, quella di Angular dice a quali condizioni una correzione funzionerebbe. Le ultime due voci non sono documentazione ma misure mie, e la differenza vale ripeterla: una fonte si consulta, una misura si riesegue. I conteggi del repository (737 e 11) valgono per il commit di quel giorno e invecchieranno; i comandi accanto, no.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti