关于javascript:强烈推荐2020年15道优秀的TypeScript练习题-上集

54次阅读

共计 9067 个字符，预计需要花费 23 分钟才能阅读完成。

TypeScript 是目前不得不学的内容

  • Ts 的货色其实十分十分的多，上到 tsconfig 的配置，下到写法，内容。
  • Ts 正在疯狂的迭代，进入 4.0 版本行将，外面的内容十分十分的多，能够说，入门很简略，然而要写精通，真的还是要花很多功夫。
  • 本文一共分上、下集, 欢送你关注我的公众号：【前端巅峰】, 前端、后端、源码、架构、算法、面试都有, 更有理财，心理学、开源我的项目等日常分享。

正式开始

  • 第一题, 根本 interface 应用考查, 定义一个 item 接口，合乎应用
interface item {
  name: string;
  age: number;
  occupation: string;
}

const users: item[] = [
  {
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {
    name: 'Kate Müller',
    age: 23,
    occupation: 'Astronaut',
  },
];

function logPerson(user: item) {console.log(` - ${chalk.green(user.name)}, ${user.age}`);
}

console.log(chalk.yellow('Users:'));
users.forEach(logPerson);
  • 第二题, 考查联结类型, 让 logPerson 函数不报错

interface User {
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  name: string;
  age: number;
  role: string;
}
type Person = User | Admin;
const persons: Person[] /* <- Person[] */ = [
  {
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {
    name: 'Jane Doe',
    age: 32,
    role: 'Administrator',
  },
  {
    name: 'Kate Müller',
    age: 23,
    occupation: 'Astronaut',
  },
  {
    name: 'Bruce Willis',
    age: 64,
    role: 'World saver',
  },
];

function logPerson(user: Person) {console.log(` - ${chalk.green(user.name)}, ${user.age}`);
}

persons.forEach(logPerson);
  • 第三题, 类型推断、联结类型、类型断言（此题我感觉不是最优解法, 欢送大家指出）, 让 logPerson 不报错

interface User {
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  name: string;
  age: number;
  role: string;
}

type Person = User | Admin;

const persons: Person[] = [
  {
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {
    name: 'Jane Doe',
    age: 32,
    role: 'Administrator',
  },
  {
    name: 'Kate Müller',
    age: 23,
    occupation: 'Astronaut',
  },
  {
    name: 'Bruce Willis',
    age: 64,
    role: 'World saver',
  },
];

function logPerson(person: Person) {
  let additionalInformation: string;
  if ((person as Admin).role) {additionalInformation = (person as Admin).role;
  } else {additionalInformation = (person as User).occupation;
  }
  console.log(` - ${chalk.green(person.name)}, ${person.age}, ${additionalInformation}`
  );
}

persons.forEach(logPerson);
  • 第四题，我这里同样应用了类型断言和类型推断、联结类型解题（感觉也不是最优），让 logPerson 不报错

interface User {
  type: 'user';
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  type: 'admin';
  name: string;
  age: number;
  role: string;
}

type Person = User | Admin;

const persons: Person[] = [
  {
    type: 'user',
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {type: 'admin', name: 'Jane Doe', age: 32, role: 'Administrator'},
  {type: 'user', name: 'Kate Müller', age: 23, occupation: 'Astronaut'},
  {type: 'admin', name: 'Bruce Willis', age: 64, role: 'World saver'},
];

function isAdmin(person: Person) {return person.type === 'admin';}

function isUser(person: Person) {return person.type === 'user';}

function logPerson(person: Person) {
  let additionalInformation: string = '';
  if (isAdmin(person)) {additionalInformation = (person as Admin).role;
  }
  if (isUser(person)) {additionalInformation = (person as User).occupation;
  }
  console.log(` - ${chalk.green(person.name)}, ${person.age}, ${additionalInformation}`
  );
}

console.log(chalk.yellow('Admins:'));
persons.filter(isAdmin).forEach(logPerson);

console.log();

console.log(chalk.yellow('Users:'));
persons.filter(isUser).forEach(logPerson);
  • 第五题, 我应用了索引签名解题, 保障 filterUsers 函数不报错

interface User {
  type: 'user';
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  type: 'admin';
  name: string;
  age: number;
  role: string;
}

type Person = User | Admin;

const persons: Person[] = [
  {
    type: 'user',
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {
    type: 'admin',
    name: 'Jane Doe',
    age: 32,
    role: 'Administrator',
  },
  {
    type: 'user',
    name: 'Kate Müller',
    age: 23,
    occupation: 'Astronaut',
  },
  {
    type: 'admin',
    name: 'Bruce Willis',
    age: 64,
    role: 'World saver',
  },
  {
    type: 'user',
    name: 'Wilson',
    age: 23,
    occupation: 'Ball',
  },
  {
    type: 'admin',
    name: 'Agent Smith',
    age: 23,
    role: 'Administrator',
  },
];

const isAdmin = (person: Person): person is Admin => person.type === 'admin';
const isUser = (person: Person): person is User => person.type === 'user';

function logPerson(person: Person) {
  let additionalInformation: string = '';
  if (isAdmin(person)) {additionalInformation = person.role;}
  if (isUser(person)) {additionalInformation = person.occupation;}
  console.log(` - ${chalk.green(person.name)}, ${person.age}, ${additionalInformation}`
  );
}

function filterUsers(persons: Person[],
  criteria: {age: number; [index: string]: number }
): User[] {return persons.filter(isUser).filter((user) => {let criteriaKeys = Object.keys(criteria) as (keyof User)[];
    return criteriaKeys.every((fieldName) => {return user[fieldName] === criteria[fieldName];
    });
  });
}

console.log(chalk.yellow('Users of age 23:'));

filterUsers(persons, {age: 23,}).forEach(logPerson);
  • 第六题，考查 overloads, 我对filterPersons 独自进行了解决，解题，保障 logPerson 函数能够返回不同的类型数据
interface User {
  type: 'user';
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  type: 'admin';
  name: string;
  age: number;
  role: string;
}

type Person = User | Admin;

const persons: Person[] = [
  {
    type: 'user',
    name: 'Max Mustermann',
    age: 25,
    occupation: 'Chimney sweep',
  },
  {type: 'admin', name: 'Jane Doe', age: 32, role: 'Administrator'},
  {type: 'user', name: 'Kate Müller', age: 23, occupation: 'Astronaut'},
  {type: 'admin', name: 'Bruce Willis', age: 64, role: 'World saver'},
  {type: 'user', name: 'Wilson', age: 23, occupation: 'Ball'},
  {type: 'admin', name: 'Agent Smith', age: 23, role: 'Anti-virus engineer'},
];

function logPerson(person: Person) {
  console.log(` - ${chalk.green(person.name)}, ${person.age}, ${person.type === 'admin' ? person.role : person.occupation}`
  );
}

function filterPersons(persons: Person[],
  personType: 'user',
  criteria: {[fieldName: string]: number }
): User[];

function filterPersons(persons: Person[],
  personType: 'admin',
  criteria: {[fieldName: string]: number }
): Admin[];

function filterPersons(persons: Person[],
  personType: string,
  criteria: {[fieldName: string]: number }
) {
  return persons
    .filter((person) => person.type === personType)
    .filter((person) => {let criteriaKeys = Object.keys(criteria) as (keyof Person)[];
      return criteriaKeys.every((fieldName) => {return person[fieldName] === criteria[fieldName];
      });
    });
}

let usersOfAge23: User[] = filterPersons(persons, 'user', { age: 23});
let adminsOfAge23: Admin[] = filterPersons(persons, 'admin', { age: 23});

console.log(chalk.yellow('Users of age 23:'));
usersOfAge23.forEach(logPerson);

console.log();

console.log(chalk.yellow('Admins of age 23:'));
adminsOfAge23.forEach(logPerson);
  • 第七题, 考查泛型应用，依据传入参数不同, 动静返回不同类型的数据, 保障 swap 函数运行失常
interface User {
  type: 'user';
  name: string;
  age: number;
  occupation: string;
}

interface Admin {
  type: 'admin';
  name: string;
  age: number;
  role: string;
}

function logUser(user: User) {const pos = users.indexOf(user) + 1;
  console.log(` - #${pos} User: ${chalk.green(user.name)}, ${user.age}, ${user.occupation}`
  );
}

function logAdmin(admin: Admin) {const pos = admins.indexOf(admin) + 1;
  console.log(` - #${pos} Admin: ${chalk.green(admin.name)}, ${admin.age}, ${admin.role}`
  );
}

const admins: Admin[] = [
  {
    type: 'admin',
    name: 'Will Bruces',
    age: 30,
    role: 'Overseer',
  },
  {
    type: 'admin',
    name: 'Steve',
    age: 40,
    role: 'Steve',
  },
];

const users: User[] = [
  {
    type: 'user',
    name: 'Moses',
    age: 70,
    occupation: 'Desert guide',
  },
  {
    type: 'user',
    name: 'Superman',
    age: 28,
    occupation: 'Ordinary person',
  },
];

function swap<T, L>(v1: T, v2: L): [L, T] {return [v2, v1];
}

function test1() {console.log(chalk.yellow('test1:'));
  const [secondUser, firstAdmin] = swap(admins[0], users[1]);
  logUser(secondUser);
  logAdmin(firstAdmin);
}

function test2() {console.log(chalk.yellow('test2:'));
  const [secondAdmin, firstUser] = swap(users[0], admins[1]);
  logAdmin(secondAdmin);
  logUser(firstUser);
}

function test3() {console.log(chalk.yellow('test3:'));
  const [secondUser, firstUser] = swap(users[0], users[1]);
  logUser(secondUser);
  logUser(firstUser);
}

function test4() {console.log(chalk.yellow('test4:'));
  const [firstAdmin, secondAdmin] = swap(admins[1], admins[0]);
  logAdmin(firstAdmin);
  logAdmin(secondAdmin);
}

function test5() {console.log(chalk.yellow('test5:'));
  const [stringValue, numericValue] = swap(123, 'Hello World');
  console.log(` - String: ${stringValue}`);
  console.log(` - Numeric: ${numericValue}`);
}

[test1, test2, test3, test4, test5].forEach((test) => test());
  • 第八题，考查 Omit 和多类型 & 的应用，应用 Omit 提取 type 字段，最小代价实现了这道题

interface User {
    type: 'user';
    name: string;
    age: number;
    occupation: string;
}

interface Admin {
    type: 'admin';
    name: string;
    age: number;
    role: string;
}


type Person = User | Admin | PowerUser;

const persons: Person[] = [{ type: 'user', name: 'Max Mustermann', age: 25, occupation: 'Chimney sweep'},
    {type: 'admin', name: 'Jane Doe', age: 32, role: 'Administrator'},
    {type: 'user', name: 'Kate Müller', age: 23, occupation: 'Astronaut'},
    {type: 'admin', name: 'Bruce Willis', age: 64, role: 'World saver'},
    {
        type: 'powerUser',
        name: 'Nikki Stone',
        age: 45,
        role: 'Moderator',
        occupation: 'Cat groomer'
    }
];


type PowerUser = Omit<User, 'type'> & Omit<Admin, 'type'> & {type: 'powerUser'};


function isAdmin(person: Person): person is Admin {return person.type === 'admin';}

function isUser(person: Person): person is User {return person.type === 'user';}

function isPowerUser(person: Person): person is PowerUser {return person.type === 'powerUser';}

function logPerson(person: Person) {
    let additionalInformation: string = '';
    if (isAdmin(person)) {additionalInformation = person.role;}
    if (isUser(person)) {additionalInformation = person.occupation;}
    if (isPowerUser(person)) {additionalInformation = `${person.role}, ${person.occupation}`;
    }
    console.log(`${chalk.green(person.name)}, ${person.age}, ${additionalInformation}`);
}

console.log(chalk.yellow('Admins:'));
persons.filter(isAdmin).forEach(logPerson);

console.log();

console.log(chalk.yellow('Users:'));
persons.filter(isUser).forEach(logPerson);

console.log();

console.log(chalk.yellow('Power users:'));
persons.filter(isPowerUser).forEach(logPerson);

写给读者

  • 后面八道题并不一定是最优解法,Ts外面货色的确多，如果你有好的解法能够公众号后盾私信我
  • 前面会补充剩下的题目，由易到难
  • 不定期补充前端架构师面试题、各种技术的系列学习题目
  • 我是 Peter 酱，架构设计过20 万 人端到端加密超级群性能的桌面 IM 软件, 我微信:CALASFxiaotan,不闲聊
  • 另外欢送珍藏我的材料网站:前端生存社区:https://qianduan.life, 能够 右下角 点个 在看 ，关注一波公众号:[ 前端巅峰]

正文完
javascript
发表至： javascript
2020-07-20
 0
js数据结构-二叉树（二叉搜索树）
如果有一个业务代码不修改业务内代码如何添加自己的逻辑代码优化
浅谈webpack之plugin，webpack-manifest-plugin源码解读
关于javascript:从零搭建-Nodejs-企业级-Web-服务器四异常处理