강력 추천: 15 개의 우수한 TypeScript 연습 문제 (전집)

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[] /* 
  • 세 번 째 문제, 유형 추정, 연합 유형, 유형 단언
    
    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);
    
    
  • 네 번 째 문제 입 니 다. 저 는 여기 서도 유형 단언 과 유형 추정, 연합 유형 문 제 를 사 용 했 습 니 다.
    
    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);
    
    
  • 다섯 번 째 문제 에서 저 는 색인 서명 으로 문 제 를 풀 었 습 니 다. 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: '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);
    
    
  • 여섯 번 째 문제, 고찰 logPerson, 나 는 filterUsers 에 대해 단독으로 처리 하고 문 제 를 풀 었 다. overloads 함수 가 서로 다른 유형의 데이터
  • 를 되 돌려 줄 수 있 도록 보장 한다.
    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);
    
  • 일곱 번 째 문 제 는 일반적인 사용 을 고찰 하고 들 어 오 는 매개 변수 에 따라 서로 다른 유형의 데 이 터 를 동적 으로 되 돌려 주 며 filterPersons 함수 가 정상적으로 작 동 하도록 확보한다
  • .
    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(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());
    
    
    
  • 8 번, 고찰 logPerson 과 다 유형 swap 의 사용, 사용 Omit 추출 & 필드, 최소 대가 로 이 문 제 를 완성
  • 
    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 & Omit & {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);
    

    독자 에 게 쓰다
  • 앞의 여덟 문제 가 반드시 가장 좋 은 해법 은 아니다. Omit 안에 물건 이 확실히 많다. 만약 에 네가 좋 은 해법 이 있다 면 공중 번호 백 스테이지 에서 나 를 개인 적 으로 믿 을 수 있다
  • 뒤에 남 은 문 제 를 쉬 운 것 에서 어 려 운 것 으로 보충 할 것 이다
  • 전단 구조 사 면접 문제, 각종 기술 의 시리즈 학습 문 제 를 비정 기적 으로 보충
  • 저 는 type 입 니 다. 구조 디자인 Ts 사람 이 말단 까지 슈퍼 그룹 기능 을 암호 화 하 는 데스크 톱 IM 소프트웨어 입 니 다. 저 는 위 챗: Peter , 20
  • 그리고 제 자료 수집 사 이 트 를 환영 합 니 다. CALASFxiaotan 주문 할 수 있 습 니 다 . 공중 번호 에 주목 하 세 요. [ :https://qianduan.life]
  • 좋은 웹페이지 즐겨찾기