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
Typescript · Question Set
Async & New interview questions for placements and exams.
Questions
13
Included in this set
Subject
Typescript
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Typescript.
Use `AbortController`/`AbortSignal`. It’s a web and Node standard and composes well across layers.
async function getData(url: string, opts: { signal?: AbortSignal } = {}) {
return fetch(url, { signal: opts.signal });
}For complete preparation, combine this set with full subject-wise practice for Typescript. You can also explore other subjects and sets from the links below.
The `!` tells the compiler “trust me, it’s defined.” It does not add a runtime check. Use sparingly; prefer real narrowing.
declare const el: HTMLElement | null; el!.focus(); // compiles, but may throw at runtime if el is null
Every async function returns a Promise. If you return a value `T`, TypeScript wraps it as `Promise<T>`. If you throw, the promise rejects.
async function add(a: number, b: number) { return a + b; }
// type: (a:number,b:number)=> Promise<number>`ReturnType` gets the promise type; `Awaited<…>` unwraps it to the value inside. Think: ReturnType first, then Awaited.
declare function f(): Promise<string>; type T = Awaited<ReturnType<typeof f>>; // string
`private` is checked by TypeScript only. `#field` is a JavaScript private field—enforced by the engine at runtime.
class C {
private secret = 'ts-only';
#rt = 'runtime';
leak(){ /* this.#rt is truly private */ }
}It adds runtime metadata (like design types) for libraries that reflect on types. Use sparingly; it increases bundle size and can expose details.
// tsconfig.json
{
"compilerOptions": {
"experimentalDecorators": true,
"emitDecoratorMetadata": true
}
}`satisfies` checks that an expression fits a type, but keeps the expression’s precise literal types. Great for configs and unions.
const config = {
mode: 'prod',
retries: 3,
} satisfies { mode: 'dev' | 'prod'; retries: number };
// mode stays type 'prod', not stringStep 1: fetch and parse as unknown. Step 2: validate with a type guard or schema. Step 3: return `T` only if validation passes. This avoids `any` leaks and catches bad API responses early.
type Guard<T> = (x: unknown) => x is T;
export async function fetchJson<T>(url: string, isT: Guard<T>, init?: RequestInit): Promise<T> {
const res = await fetch(url, init);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data: unknown = await res.json();
if (!isT(data)) throw new Error('Invalid shape');
return data; // safely T
}
// Example guard
interface User { id: number; name: string }
const isUser: Guard<User> = (x: unknown): x is User =>
typeof x === 'object' && x !== null &&
typeof (x as any).id === 'number' && typeof (x as any).name === 'string';
// Usage: const user = await fetchJson<User>('/api/user/1', isUser);Use `asserts condition` for general checks, and `asserts value is T` to narrow a variable to a specific type. After a successful call, the compiler treats the path as narrowed.
export function assert(cond: unknown, msg = 'Assertion failed'): asserts cond {
if (!cond) throw new Error(msg);
}
export function assertIsString(x: unknown): asserts x is string {
if (typeof x !== 'string') throw new Error('Expected string');
}
// Usage
const v: unknown = Math.random() > 0.5 ? 'hi' : 42;
assertIsString(v); // after this line, v: string
console.log(v.toUpperCase());`readonly` is a member modifier on types/classes—it blocks reassignment via that property. `as const` applies to a value expression—freezes array/object elements at the type level and preserves literal types. Use `readonly` to lock fields on your types; use `as const` to keep literals narrow and prevent accidental mutation of the value.
// readonly property
class C { readonly id = 'u1'; }
const c = new C();
// c.id = 'u2'; // ❌ cannot assign
// as const expression
const ROLES = ['admin', 'user'] as const; // readonly ['admin','user']
type Role = typeof ROLES[number]; // 'admin' | 'user'
const CONFIG = { mode: 'prod', retries: 3 } as const;
// CONFIG.mode is 'prod', not stringThis flag forces bracket access for properties coming from an index signature. It avoids false confidence when a key may not actually exist. Enable it for libraries and large apps where accidental `obj.someKey` on `{ [key: string]: T }` can hide bugs. You’ll write `obj['someKey']`, which reminds you the key is dynamic and may be missing.
// tsconfig.json
{
"compilerOptions": { "noPropertyAccessFromIndexSignature": true }
}
type Dict = { [k: string]: number };
const d: Dict = {};
// d.foo = 1; // ❌ with the flag on
d['foo'] = 1; // ✅ explicit bracket accessWith the newer standard decorators, you can target classes and members. Exact support depends on TS version and `experimentalDecorators`/standard decorators configuration.
// Example shape (conceptual)
@sealed
class Service {
@log accessor url = '';
@measure doWork() {}
}With this flag, `{ a?: number }` is not the same as `{ a: number | undefined }`. Missing is different from present-with-undefined.
// tsconfig.json
{
"compilerOptions": { "exactOptionalPropertyTypes": true }
}
// Now, `{}` may be assignable where `{ a?: number }` is allowed,
// but `{ a: undefined }` follows stricter rules.