某大厂给前端面试者出了一套 TypeScript 笔试题，要求面试者在线实时答题。这种面试题考察的是应聘者的 TS 硬实力，先把题目和要求给出来，你试试能做出来几个。
答题要求
1、环境搭建
所有题目均为 NodeJS 环境下，TypeScript 编程题。 NodeJS 版本建议 v14 及以上。代码题以本地可以运行通过为准，Node 版本不够则无法运行高版本语法。 请提前配置好开发环境。
npm i ts-node -g
2、依赖
NodeJS 环境运行 TS 文件推荐使用 ts-node，建议提前安装。
运行 ts-node 运行第一题命令如下：
ts-node src/1.reverseWord.ts
3、tsconfig.json
{ "compilerOptions": { "target": "es2016", "module": "commonjs", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true } }
笔试题目
1、objToArray.ts
/** * @file objToArray * * 将对象按照要求转为数组 * 注意console示例运行结果 */ type Obj = Record<string, string>; interface FormatItem { key: string; op: string; value: string; } function objToArray(obj: Record<string, Obj>): FormatItem[] { // 补全此处代码 throw new Error("功能待实现"); } console.log( objToArray({ key1: { op1: "value1", }, key2: { op2: "value2", }, }) ); // result示例 // [ // {key: 'key1', op: 'op1', value: 'value1'}, // {key: 'key2', op: 'op2', value: 'value2'} // ] export default {};
2、reverseWord.ts
/** * @file 反转句子 * * 同时满足以下条件：1、去除首尾空格，2、单词间隔中多个空格变成一个； * 注意console示例运行结果 */ function reverseWord(str: string) { // 补全此处代码 throw new Error('功能待实现'); } console.log(reverseWord('the sky is blue')); // blue is sky the // 去除首尾空格 console.log(reverseWord(" hello world ")); // world hello // 单词间隔中多个空格变成一个 console.log(reverseWord("a good example")); // example good a export default {}
3、firstSingleChar.ts
/** * @file 找出字符串中第一个只出现一次的字符 */ function firstSingleChar(str: string) { // 补全此处代码 throw new Error('功能待实现'); } // a 和 b 都出现了两次，只有 c 出现了一次，返回 c console.log(firstSingleChar('abcba')) // c // b c d 都出现了一次，返回第一个 console.log(firstSingleChar('aabcdee')) // b // a 和 b 都出现了多次，没有只出现一次的元素，返回 undefined console.log(firstSingleChar('aaaabbbb')) // undefined export default {}
4、mergeArray.ts
/** * @file 合并两个有序数组 */ function merge(arr: number[], arr2: number[]): number[] { // 补全此处代码 throw new Error('功能待实现'); } // 参数数组从小到大排列 console.log(merge([1, 2, 3], [2, 5, 6])) // [ 1, 2, 2, 3, 5, 6 ] export default {}
5、map.ts
/** * @file 实现数组 map 方法 */ function myMap<T, R>(arr: T[], callbackFn: (v: T) => R): R[] { // 补全此处代码，可以使用除数组 map 以外的其他任何函数 throw new Error('功能待实现'); } // 测试 console.log(myMap([1, 2, 3], v => v * 2)) // [2, 4, 6] export default {};
6、bTreePath.ts
/** * @file 二叉树所有路径 */ type Tree = { value: number; left?: Tree; right?: Tree; } const tree: Tree = { value: 1, left: { value: 2, right: { value: 5 } }, right: { value: 3 } }; function treePath(root: Tree): string[] { // 补全此处代码 throw new Error('功能待实现'); } console.log(treePath(tree)) // [ '1->2->5', '1->3' ] export default {}
7、mapTree.ts
/** * @file 树结构映射 * 数组 map 保持数组长度相同，将对应位置元素进行映射。 * 与之类似，在二叉树 Tree 上的映射我们称为 mapTree，该函数返回一个结构相同的新树，对应位置 value 字段经过 fn 映射。 */ type Tree = { value: number; left?: Tree; right?: Tree; } function mapTree(tree: Tree, fn: (v: number) => number): Tree { // 补全此处代码 throw new Error('功能待实现'); } // 测试 const tree: Tree = { value: 1, left: { value: 2 }, right: { value: 3 } }; console.log(mapTree(tree, v => v * 2)) // { value: 2, left: { value: 4 }, right: { value: 6 } } export default {};
8、product.ts
/** * @file 计算数组笛卡尔积 */ // 示例 product([1, 2], [3, 4]) // [[1, 3], [1, 4], [2, 3], [2, 4]] function product(xList: number[], yList: number[]): [number, number][] { // 补全内部实现 throw new Error('功能待实现'); } export default {}
9、sleep.ts
/** * @file 返回一个 Promise，并在 ms 毫秒后 Promise 变为完成状态 */ export function sleep(ms: number): Promise<undefined> { // 补全此处代码 throw new Error('功能待实现'); } async function main(){ console.log('a') await sleep(1000); console.log('b'); await sleep(1000); console.log('c'); } main() export default {}
10、promiseAll.ts
/** * @file 实现 PromiseAll 方法 */ import { sleep } from "./8.sleep"; async function myAll<T extends unknown[] | []>(values: T): Promise<{ [P in keyof T]: Awaited<T[P]> }> { // 补全此处代码，使用 Promise.all 以外的语法完成 throw new Error('功能待实现'); } // 一秒钟后返回结果 value async function request(value: string) { await sleep(1000); return value; } async function main() { console.log('start'); const res = await myAll([ request('a'), request('b'), request('c'), ]) console.log(res); // 预期输出 start 一秒后输出 ['a', 'b', 'c'] } main() export default {}
11、asyncAdd.ts
/** * @file 假设加法是一个异步过程，如何计算多个数组之和？ */ function sleep(ms: number) { return new Promise(r => { setTimeout(() => { r(undefined) }, ms); }) } async function asyncAdd(a: number, b: number) { await sleep(1000); return a + b; } function sum(arr: number[]): Promise<number> { // 补全这里代码，涉及 arr 中两数求和只能使用 asyncAdd，禁止使用加号 throw new Error('功能待实现'); } console.time('a') sum([1, 2, 3, 4, 5, 6, 7, 8]) .then(v => { console.log(v) // 36 console.timeEnd('a') // a: <耗时> }) export default {}
参考答案
1、objToArray.ts
/** * @file objToArray * * 将对象按照要求转为数组 * 注意console示例运行结果 */ type Obj = Record<string, string>; interface FormatItem { key: string; op: string; value: string; } function objToArray(obj: Record<string, Obj>): FormatItem[] { // 参考答案 return Object.keys(obj).reduce((value: Array<FormatItem>, key: string) => { var op: string = Object.keys(obj[key])[0]; value.push({ key: key, op: op, value: obj[key][op] }); return value; }, []); } console.log( objToArray({ key1: { op1: "value1", }, key2: { op2: "value2", }, }) ); // result示例 // [ // {key: 'key1', op: 'op1', value: 'value1'}, // {key: 'key2', op: 'op2', value: 'value2'} // ] export default {};
2、reverseWord.ts
/** * @file 反转句子 * * 同时满足以下条件：1、去除首尾空格，2、单词间隔中多个空格变成一个； * 注意console示例运行结果 */ function reverseWord(str: string):string { // 参考答案 return (<string[]>str.match(/\S+/g)).reverse().join(" "); } console.log(reverseWord('the sky is blue')); // blue is sky the // 去除首尾空格 console.log(reverseWord(" hello world ")); // world hello // 单词间隔中多个空格变成一个 console.log(reverseWord("a good example")); // example good a export default {}
3、firstSingleChar.ts
/** * @file 找出字符串中第一个只出现一次的字符 */ function firstSingleChar(str: string) { // 参考答案 return str.split("").filter((item: string, index: number, arr: string[]) => { arr.splice(index, 1); return !arr.includes(item); })[0]; } // a 和 b 都出现了两次，只有 c 出现了一次，返回 c console.log(firstSingleChar("abcba")); // c // b c d 都出现了一次，返回第一个 console.log(firstSingleChar("aabcdee")); // b // a 和 b 都出现了多次，没有只出现一次的元素，返回 undefined console.log(firstSingleChar("aaaabbbb")); // undefined console.log(firstSingleChar("dabvb")); export default {};
4、mergeArray.ts
/** * @file 合并两个有序数组 */ function merge(arr: number[], arr2: number[]): number[] { // 参考答案 return arr.concat(arr2).sort((a: number, b: number) => a - b); } // 参数数组从小到大排列 console.log(merge([1, 2, 3], [2, 5, 6])); // [ 1, 2, 2, 3, 5, 6 ] export default {};
5、map.ts
/** * @file 实现数组 map 方法 */ function myMap<T, R>(arr: T[], callbackFn: (v: T) => R): R[] { // 参考答案 var arr1: R[] = []; for (var i = 0; i < arr.length; i++) { if (i in arr) arr1[i] = callbackFn(arr[i]); } return arr1; } // 测试 console.log(myMap([1, 2, 3], (v) => v * 2)); // [2, 4, 6] export default {};
6、bTreePath.ts
/** * @file 二叉树所有路径 */ type Tree = { value: number; left?: Tree; right?: Tree; }; const tree: Tree = { value: 1, left: { value: 2, right: { value: 5 }, }, right: { value: 3 }, }; function treePath(root: Tree): string[] { // 补全此处代码 // throw new Error('功能待实现'); const answer: [] = []; let tmp: [][] = []; const travel = (r: Tree) => { if (r == null) { return; } //@ts-ignore tmp.push(r.value); if (r.left == null && r.right == null) { //@ts-ignore answer.push(tmp); tmp = [tmp[0]]; return; } if (r.left) travel(r.left); if (r.right) travel(r.right); }; travel(root); //@ts-ignore return answer.map((t) => t.join("->")); } console.log(treePath(tree)); // [ '1->2->5', '1->3' ] export default {};
7、mapTree.ts
/** * @file 树结构映射 * 数组 map 保持数组长度相同，将对应位置元素进行映射。 * 与之类似，在二叉树 Tree 上的映射我们称为 mapTree，该函数返回一个结构相同的新树，对应位置 value 字段经过 fn 映射。 */ type Tree = { value: number; left?: Tree; right?: Tree; }; function mapTree(tree: Tree, fn: (v: number) => number): Tree { // 参考答案 if (tree == null) { return tree; } tree.value = fn(tree.value); if (tree.left) mapTree(tree.left, fn); if (tree.right) mapTree(tree.right, fn); return tree; } // 测试 const tree: Tree = { value: 1, left: { value: 2 }, right: { value: 3 }, }; console.log(mapTree(tree, (v) => v * 2)); // { value: 2, left: { value: 4 }, right: { value: 6 } } export default {};
8、product.ts
/** * @file 计算数组笛卡尔积 */ // 示例 console.log(product([1, 2], [3, 4])); // [[1, 3], [1, 4], [2, 3], [2, 4]] function product(xList: number[], yList: number[]): [number, number][] { // 参考答案 return xList.reduce((v, t) => { return v.concat(yList.map((item) => [t, item])); }, [] as [number, number][]); } export default {};
9、sleep.ts
/** * @file 返回一个 Promise，并在 ms 毫秒后 Promise 变为完成状态 */ export function sleep(ms: number): Promise<undefined> { // 参考答案 return new Promise( ( resolve: (value: undefined) => void, reject: (value: undefined) => void ) => { setTimeout(() => { resolve(undefined); }, ms); } ); } async function main() { console.log("a"); await sleep(1000); console.log("b"); await sleep(1000); console.log("c"); } main(); export default {};
10、promiseAll.ts
/** * @file 实现 PromiseAll 方法 */ import { sleep } from "./8.sleep"; async function myAll<T extends unknown[] | []>( values: T ): Promise<{ [P in keyof T]: Awaited<T[P]> }> { // 补全此处代码，使用 Promise.all 以外的语法完成 // throw new Error('功能待实现'); var arr = []; for (var i = 0; i < values.length; i++) { arr.push(await values[i]); } return arr as { [P in keyof T]: Awaited<T[P]> }; } // 一秒钟后返回结果 value async function request(value: string) { await sleep(1000); return value; } async function main() { console.log("start"); const res = await myAll([request("a"), request("b"), request("c")]); console.log(res); // 预期输出 start 一秒后输出 ['a', 'b', 'c'] } main(); export default {};
11、asyncAdd.ts
/** * @file 假设加法是一个异步过程，如何计算多个数组之和？ */ function sleep(ms: number) { return new Promise((r) => { setTimeout(() => { r(undefined); }, ms); }); } async function asyncAdd(a: number, b: number) { await sleep(1000); return a + b; } async function sum(arr: number[]): Promise<number> { // 参考答案 var s: number = arr[0]; for (var i = 1; i < arr.length; i++) { s = await asyncAdd(s, arr[i]); } return s; } console.time("a"); sum([1, 2, 3, 4, 5, 6, 7, 8]).then((v) => { console.log(v); // 36 console.timeEnd("a"); // a: <耗时> }); export default {};
