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
Google · Typescript
Practice Typescript questions specifically asked in Google interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
17
Tagged for this company + subject
Company
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 Google Typescript round.
Compatibility is about shape. If two types have the same required members, values are assignable between them—names don’t need to match.
type A = { x: number };
interface B { x: number }
const a: A = { x: 1 };
const b: B = a; // shape-compatibleFor 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.
ReadonlyArray<T> allows reading (map, slice, reduce) but blocks mutation (no push/pop). Perfect for API inputs.
function total(nums: ReadonlyArray<number>) { return nums.reduce((a,b)=>a+b,0); }`readonly` prevents reassignment of tuple elements and disallows mutating methods. It does not deep-freeze nested object values—it’s a type-level immutability.
const t: readonly [number, string] = [1, 'a']; // t[0] = 2; // ❌ cannot assign to read-only element
Setting `"strict": true` enables a bundle of strictness flags (like `noImplicitAny`, `strictNullChecks`) that catch bugs early.
// tsconfig.json
{
"compilerOptions": {
"strict": true
}
}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 exportsA mixin takes a base class and returns a new class with extra behavior. It’s composition: `const WithX = <TBase extends Constructor>(Base: TBase) => class extends Base { … }`.
type Ctor<T = {}> = new (...args: any[]) => T;
function WithTimestamp<TBase extends Ctor>(Base: TBase){
return class extends Base { timestamp = Date.now(); };
}
class Model {}
class TimedModel extends WithTimestamp(Model) {}Use “extends” to restrict a generic. Read it aloud as: T must be a subtype of U. This lets you safely use U’s properties inside the generic body.
function prop<T extends object, K extends keyof T>(obj: T, key: K) {
return obj[key];
}
// prop(123, 'x') // ❌ 123 is not an object“infer” lets you pull out a type part from the left side of a conditional. Think: pattern-match a type and bind the inner piece.
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T; type X = UnwrapPromise<Promise<number>>; // number
`never` marks code paths that cannot produce a value—such as a function that always throws or an infinite loop. It is also used to enforce exhaustive checks on unions; a fall-through to a `never` variable signals a missing case.
function fail(msg: string): never { throw new Error(msg); }
while (true) { /* ... */ } // type of this loop is never
// Exhaustive example
function assertNever(x: never) { /* compile-time guard */ }TypeScript uses structural typing: two types are compatible if their required members line up, regardless of their declared names. This applies across interfaces, type aliases, and classes treated as shapes.
type Point = { x: number; y: number }
interface Coords { x: number; y: number }
const p: Point = { x: 1, y: 2 };
const c: Coords = p; // ✅ structural compatibility`null` is an explicit, intentional “no value.” `undefined` means “not assigned yet.” With `strictNullChecks`, include these in a union when you want to allow them.
let val: string | null = null; // allow null explicitly in strict mode let maybe: number | undefined; // declared, not yet assigned
With this flag on, reading arr[i] is typed as possibly undefined unless the code proves otherwise. This prevents many out-of-bounds mistakes.
// tsconfig.json
{
"compilerOptions": {
"noUncheckedIndexedAccess": true
}
}
// const x = arr[10]; // x: T | undefinedUse ES modules (`import`/`export`) for clear boundaries, tree-shaking, and compatibility with modern bundlers and runtimes. Namespaces and globals are legacy patterns and make code harder to split.
// math.ts
export const add = (a: number, b: number) => a + b;
// app.ts
import { add } from './math.js';
console.log(add(2,3));Use `number[]` or `Array<number>` to type numeric arrays. Mixing a string like "3" with numbers breaks type safety. `Array` without a generic is too loose, and `list<number>` is not a TypeScript type.
const a: number[] = [1, 2, 3]; const b: Array<number> = [4, 5, 6]; // const bad: number[] = [1, '3']; // ❌
`for…in` exists but is not ideal for arrays—it iterates enumerable keys (including custom properties) as strings. Prefer `for`, `for…of`, or `Array.prototype.forEach` for arrays.
const arr = [10, 20, 30];
for (const v of arr) {/* values */}
arr.forEach(v => {/* values */});
for (let i = 0; i < arr.length; i++) {/* indices */}
// for...in iterates keys as strings; avoid for numeric arraysInterfaces with the same name merge into a single interface. Type aliases do not merge—redeclaring the same type name is an error.
interface Box { id: string }
interface Box { size: number }
// Merged => interface Box { id: string; size: number }string, number, boolean, bigint, and symbol are primitive types—immutable values stored by value. null and undefined are also primitives but are often discussed separately as special values. Objects, arrays, and functions are reference types, while enums and tuples are TypeScript constructs built on top of JavaScript.
const s: string = 'hi';
const n: number = 42;
const b: boolean = true;
const big: bigint = 9007199254740993n;
const sym: symbol = Symbol('id');