Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Meta · Typescript
Practice Typescript questions specifically asked in Meta interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
11
Tagged for this company + subject
Company
Meta
View company-wise questions
Subject
Typescript
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your Meta Typescript round.
Tuples model a fixed-length, ordered list where each index can have its own type (e.g., `[string, number]`). They can be mutable or readonly, and tuple elements can even be optional.
type Pair = [string, number]; const p: Pair = ['x', 1]; // Optional element example: type Log = [string, number?];
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
When enabled, you can write `import x from 'cjs-lib'` for CommonJS modules that export with `module.exports`. It smooths default import ergonomics.
// tsconfig.json
{
"compilerOptions": {
"esModuleInterop": true
}
}
// Now possible:
import express from 'express';Interfaces are easy to extend, merge, and use with classes. Use types when you need unions, intersections, or advanced mapped/conditional types.
interface Animal { speak(): void }
class Dog implements Animal { speak() { /* ... */ } }readonly blocks reassigning the property, but it doesn’t deep-freeze nested objects. `as const` applies to expressions and narrows literals; `readonly` is a member-level modifier.
class Config { readonly host = 'localhost'; }
const c = new Config();
// c.host = 'x'; // ❌ cannot assign to 'host' because it is a read-only property`unknown` forces you to check and narrow before using the error value. It avoids the unsafe, anything-goes behavior of `any`.
try {
// ...
} catch (e: unknown) {
if (e instanceof Error) console.error(e.message);
else console.error('Unknown error');
}A conditional type reads: if T is assignable to U, produce X, otherwise produce Y. It’s purely a type-level if-else.
type IsString<T> = T extends string ? true : false; type A = IsString<'hi'>; // true type B = IsString<123>; // false
`unknown` can hold any value but cannot be used directly until you refine it with checks like typeof, instanceof, 'in', or a custom predicate. This pushes safe handling at compile time, unlike `any`, which allows all operations without checks.
function parse(json: string): unknown {
return JSON.parse(json);
}
const data = parse('{"x":1}');
// data.x // ❌ Error
if (typeof data === 'object' && data !== null && 'x' in data) {
// ✅ safe after narrowing
}`void` signals that a function doesn’t return a useful value (it returns `undefined` implicitly). Do not confuse with `never`: `void` functions return, `never` functions do not return at all.
function log(msg: string): void { console.log(msg); }
const result: void = undefined; // typical value associated with voidPick<T, K> keeps only K from T. The opposite is Omit<T, K>, which drops K from T.
type User = { id: string; name: string; email: string };
type UserPreview = Pick<User, 'id' | 'name'>;Interfaces with the same name merge into one. Type aliases cannot merge—redeclaring the same type name is an error.
interface Box { id: string }
interface Box { size: number }
// Merged: { id: string; size: number }Template literal types let you build string types using pieces like number and unions. They enforce string shapes at compile time.
type UserKey = `user:${number}`;
const k: UserKey = 'user:42'; // ✅
// const bad: UserKey = 'u:42'; // ❌