unknown versus any begrijpen
Waarom unknown het typeveilige alternatief voor any is
unknown versus any begrijpen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.
Twee toptypen
TypeScript heeft twee typen die elke waarde kunnen bevatten: any en unknown. Ze lijken op elkaar, maar gedragen zich heel verschillend. Het juiste type kiezen is een belangrijke vaardigheid voor typeveilige code.
let a: any = 5;
let u: unknown = 5;
console.log(a, u);any schakelt typecontrole uit
any is een ontsnappingsmogelijkheid waarmee je de typecontrole voor die waarde uitschakelt. Je kunt elke eigenschap benaderen of de waarde als functie aanroepen — de compiler blijft stil, zelfs als dit tijdens uitvoering tot een crash zou leiden.
const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtimeunknown dwingt controles af
unknown accepteert ook elke waarde, maar je kunt die waarde niet gebruiken voordat je hebt bewezen wat ze is. De compiler blokkeert toegang tot eigenschappen en functieaanroepen totdat je het type hebt vernauwd.
const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);unknown vernauwen met typeof
Een typeof-controle vernauwt unknown binnen het blok tot een concreet type. Zodra het type is vernauwd, zijn alle methoden van dat type veilig beschikbaar.
function shout(value: unknown): string {
if (typeof value === 'string') {
return value.toUpperCase(); // safe here
}
return 'not a string';
}
console.log(shout('hi'), shout(42));Waarom unknown veiliger is
unknown staat voor eerlijke onzekerheid: 'Ik weet nog niet wat dit is.' Het dwingt je om de waarde te valideren voordat je die gebruikt, waardoor fouten tijdens het compileren worden gevonden. any verbergt de onzekerheid en de fouten alleen maar.
function len(value: unknown): number {
if (typeof value === 'string') return value.length;
if (Array.isArray(value)) return value.length;
return 0;
}
console.log(len('abc'), len([1, 2]), len(99));Toewijzen aan en vanuit unknown
Elke waarde is toewijsbaar aan unknown. Maar unknown is alleen toewijsbaar aan unknown of any — niet aan specifieke typen zonder vernauwing. Deze asymmetrie zorgt ervoor dat het type veilig blijft.
let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Errorany verspreidt zich door je code
Een gevaarlijke eigenschap van any is dat het zich verspreidt. Zodra een waarde any is, wordt alles wat daaruit wordt afgeleid ook any, waardoor de typeveiligheid in stilte in je hele programma afneemt.
const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);unknown houdt het risico binnen
Met unknown blijft de onzekerheid op haar plaats. Je moet aan elke grens expliciet het type vernauwen, zodat onveilige bewerkingen zich niet verder kunnen verspreiden. Het risico blijft dus waar het hoort.
const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
console.log('Has count property');
}Typen aan API- en JSON-grenzen
Externe gegevens — JSON, netwerkreacties en gebruikersinvoer — bieden geen garanties. Door ze als unknown te typen in plaats van als any, dwing je validatie af voordat je de gegevens vertrouwt. Dat is de veilige standaard.
function parse(text: string): unknown {
return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
console.log('Got an object');
}Wanneer any aanvaardbaar is
any is soms een pragmatische keuze — voor snelle prototypes, een geleidelijke migratie vanuit JavaScript of interoperabiliteit met bibliotheken zonder typen. Behandel het echter als een tijdelijke markering, niet als een gewoonte. Geef waar mogelijk de voorkeur aan unknown.
// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);Een praktische vergelijking
Naast elkaar bekeken: de versie met any compileert, maar kan crashen; de versie met unknown weigert onveilige toegang te compileren. De compiler doet zijn werk en beschermt je.
const a: any = 42;
console.log(a.toFixed(2)); // OK by luck
const u: unknown = 42;
if (typeof u === 'number') {
console.log(u.toFixed(2)); // checked, safe
}Snelle controle
Toets je begrip van unknown en any.
Samenvatting: unknown en any
Belangrijkste punten:
anyschakelt typecontrole uit en verspreidt zich via afgeleide waarden.unknownaccepteert elke waarde, maar blokkeert het gebruik ervan totdat je het type vernauwt.- Gebruik
unknownvoor externe gegevens (JSON, API's en gebruikersinvoer) om validatie af te dwingen. - Gebruik
anyalleen voor migratie of interoperabiliteit met code zonder typen, als tijdelijke markering.
Vervolgens bekijken we het lege type: never.
function safeLen(v: unknown): number {
return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));
Leer TypeScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 101
- Lessen
- 352
Veelgestelde vragen
Is de les “unknown versus any begrijpen” gratis?
Ja — de volledige tekst van “unknown versus any begrijpen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.
Wat leer ik in “unknown versus any begrijpen”?
Waarom unknown het typeveilige alternatief voor any is Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met TypeScript Academy te beginnen?
Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “unknown versus any begrijpen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?
Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- unknown versus any begrijpen
- Het never-type en onmogelijke toestanden
- Het void-type in functies
- Typeveilig omgaan met unknown