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
Node + Typescript interview questions for placements and exams.
Questions
12
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.
Enable esModuleInterop to allow `import x from 'cjs-lib'` when the library uses `module.exports`. Without it, you often need `import * as x from 'cjs-lib'`.
// tsconfig.json
{
"compilerOptions": { "esModuleInterop": true }
}
import express from 'express'; // works with CJS exportsFor complete preparation, combine this set with full subject-wise practice for Typescript. You can also explore other subjects and sets from the links below.
For Node Readable streams, you typically listen to `data`, `readable`, `end`, and `error`. These cover consumption, flow control, and failures.
process.stdin
.on('data', c => {/*...*/})
.on('end', () => {/*...*/})
.on('error', e => {/*...*/});Use a schema validator (like zod) to parse `process.env`, fail fast on bad values, and return a typed config. This prevents runtime surprises.
import { z } from 'zod';
const Env = z.object({ PORT: z.coerce.number().int().positive(), NODE_ENV: z.enum(['development','production','test']) });
export const env = Env.parse(process.env);Classic Node style is error-first: the first arg is an error or null, and the second is the result. This matches many fs and net APIs.
type NodeCallback<T> = (err: NodeJS.ErrnoException | null, result: T) => void;
Adopt the web-standard AbortController/AbortSignal. It composes across layers and works in Node fetch and many libraries.
const ac = new AbortController();
fetch(url, { signal: ac.signal });
setTimeout(() => ac.abort(), 1000);Source maps link compiled JavaScript back to TypeScript, so errors and logs point to your original TS files—perfect for debugging CLI tools.
// tsconfig.json
{
"compilerOptions": { "sourceMap": true, "outDir": "dist" }
}
// run Node with source-map support if neededPrefer `readable.pipe(writable)` for simplicity—Node handles backpressure. For manual control, pause when `write()` returns false and resume on `drain`. Always handle `error` and `close`.
import { createReadStream, createWriteStream } from 'node:fs';
import { ReadStream, WriteStream } from 'node:fs';
function copyPipe(src: string, dst: string) {
const r: ReadStream = createReadStream(src);
const w: WriteStream = createWriteStream(dst);
r.pipe(w).on('error', console.error);
}
function copyManual(src: string, dst: string) {
const r: ReadStream = createReadStream(src);
const w: WriteStream = createWriteStream(dst);
r.on('data', (chunk: Buffer) => {
const canContinue = w.write(chunk);
if (!canContinue) r.pause();
});
w.on('drain', () => r.resume());
r.on('end', () => w.end());
r.on('error', e => w.destroy(e));
w.on('error', e => r.destroy(e));
}With ESM, prefer `import x, { y } from 'pkg'`. For CommonJS, enable esModuleInterop for default-like imports. Use `import type` to import types only—these vanish at emit, keeping runtime clean.
// ESM style
import http, { request } from 'node:http';
// CJS library with esModuleInterop
import express from 'express'; // ok when enabled
// Type-only import (erased at emit)
import type { Request, Response } from 'express';
// Dynamic import in ESM
const { readFile } = await import('node:fs/promises');In Node, ESM is enabled by setting "type": "module" in package.json for .js files, or by using the .mjs extension. Both approaches tell Node to treat your files as ES modules.
// package.json
{ "type": "module" }
// or name files: app.mjs
// then use: import x from './x.js'Express Request is fully generic: `Request<Params, ResBody, ReqBody, Query>`. You can type each part precisely and get IntelliSense everywhere.
import { Request, Response } from 'express';
function handler(req: Request<{id:string}, any, {name:string}, {q?:string}>, res: Response){
res.json({ ok: true });
}Type each generic so `req.params`, `req.body`, and `req.query` are fully checked. Then validate the body at runtime with a schema or a custom guard to keep types honest.
import express, { Request, Response } from 'express';
import { z } from 'zod';
const CreateUser = z.object({ name: z.string().min(1), age: z.number().int().positive() });
type Params = { id: string };
type ResBody = { ok: true } | { ok: false; error: string };
type ReqBody = z.infer<typeof CreateUser>;
type Query = { ref?: string };
const app = express();
app.use(express.json());
app.post(
'/users/:id',
(req: Request<Params, ResBody, ReqBody, Query>, res: Response<ResBody>) => {
const parse = CreateUser.safeParse(req.body);
if (!parse.success) return res.status(400).json({ ok: false, error: 'Invalid body' });
// req.body is now ReqBody at compile time; parse.data is validated at runtime
return res.json({ ok: true });
}
);Pick a modern target your runtime supports, use Node’s ESM settings, emit to dist, and keep strict on to catch bugs early. Source maps make logs debuggable. Paths help avoid deep relatives—align them with your bundler or resolver if you use one.
// tsconfig.json (Node 18+ ESM)
{
"compilerOptions": {
"strict": true,
"target": "ES2022",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"outDir": "dist",
"rootDir": "src",
"sourceMap": true,
"esModuleInterop": true,
"baseUrl": ".",
"paths": { "@/*": ["src/*"] }
},
"include": ["src"]
}
// Rationale: modern JS output, correct resolution for Node ESM,
// clean dist folder, debuggable builds, strict typing, friendly import aliases.