기울어진 TypeScript

TypeScript에 대한 나의 주석.

명령:


  • npm 빈 패키지(package.json) 초기화

  • npm init -y
    
    Wrote to C:\TypeScript\package.json:
    
    {
      "name": "typescript",
      "version": "1.0.0",
      "description": "",
      "main": "index.js",
      "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
      },
      "keywords": [],
      "author": "",
      "license": "ISC"
    }
    


  • TypeScript 설치

  • npm install --save-dev typescript
    or
    npm i -D typescript
    
    added 1 package, and audited 2 packages in 3s
    
    found 0 vulnerabilities
    


  • 타이프 스크립트 구성

  • npx tsc --init
    
    Created a new tsconfig.json with:
                                                                                                             TS
      target: es2016
      module: commonjs
      strict: true
      esModuleInterop: true
      skipLibCheck: true
      forceConsistentCasingInFileNames: true
    
    
    You can learn more at https://aka.ms/tsconfig.json
    


  • TS 컴파일

  • npx tsc
    


  • package.json를 사용하여 컴파일하도록 npm를 수정합니다.
  • "빌드"추가


  •   "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1",
        "build": "tsc"
    



    npm run build
    


  • tsconfig.json를 사용하여 다음과 같은 프로젝트 구성을 수정합니다.
  • "rootDir": "./src"
  • "outDir": "./build"
  • "noEmitOnError": 참


  • 데이터 유형






    let nome: string;
    
    nome = 'João';
    
    function nomeCompleto(nome: string, sobrenome: string) {
      return nome + ' ' + sobrenome;
    }
    
    nomeCompleto('João', 'Silva');
    


    숫자




    let idade: number;
    
    idade = 25;
    
    function somar(a: number, b: number) {
        return a + b;
    }
    
    somar(1,1);
    somar(2,4);
    


    부울




    let active: boolean;
    
    active = true;
    
    function verificarAtivo(ativo: boolean) {
        if (active) {
            return 'Ativo';
        } else {
            return 'Inativo';
        }
    }
    
    verificarAtivo(false);
    


    정렬




    const nomes: string[] = ['João', 'Maria', 'Pedro'];
    
    function printNames(nomes: string[]) {
      return `nomes: ${nomes.join(', ')}`;
    }
    
    console.log(printNames(nomes));
    


    튜플




    const pessoas: [string, string, string] = ['João', 'Maria', 'Pedro'];
    
    const joao: [string, number] = ['João', 25];
    
    const maria: [string, number] = ['Maria', 20];
    


    열거형




    enum Profiles{
        admin,
        editor, 
        user
    }
    
    enum Cores {
      red = '\u001b[31m',
      black = '\u001b[30m',
    }
    
    const usuario = {
        level: Profiles.admin
    }
    
    console.log(usuario);
    


    유형 별칭




    type User = {
      name : string;
      lastName: string;
      birthday: string;
      age?: number;  //optional
    }
    
    const user: User = {
      name: 'some name',
      lastName: 'some last name',
      birthday: '01/01/1900',
    }
    


    조합 유형




    type LogLevel = 'info' | 'error' | 'debug'
    
    function logMessage(message: string, level: LogLevel) {
      console.log(`[${level}] - ${message}`)
    }
    
    logMessage("A message", 'info')
    


    교차점 유형




    type About = {
      bio: string;
      interests: string[];
    }
    
    type Profile = User & About;
    const userWithProfile: Profile = {
      name: 'name',
      lastName: 'lastname',
      birthday: '01/01/1900',
      bio: 'bio',
      interests: ['games', 'sports'],
    }
    


    다른 유형



  • 어느
  • 유형이 정의되지 않았습니다.


  • let value: any;
    
    value = 25;
    value = '25';
    



  • 알려지지 않은
  • any + 유효성 검사를 입력합니다.


  • let informations: unknown;
    let completeInformations: string;
    
    completeInformations = informations; //don't compile, with any compile
    



  • 한정되지 않은
  • 값이 없는 인스턴스;

  • 오브젝트
  • 무효


  • 절대, 함수에서 사용:
  • 오류 반환;
  • 무한 루프;


  • 사물




    class User {
    
      public name;
      public idade;
    
      constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
      }
    }
    
    //inheritance
    class Player extends User {
    
      public game;
    
      constructor(name: string, age: number, game: string) {
        super(name, age);
        this.game = game;
      }
    
      currentGame() {
        return `I am playing ${this.game}`; 
      }
    
      static currentTime() {
        return Date();
      }
    }
    
    const user = new User("name", 15)
    console.log(user)
    
    const player = new Player("name", 18, "game");
    console.log(player.currentGame());
    
    //static
    console.log(Player.currentTime());
    


    개인 x 보호




    class Game {
      private name;
      protected otherName;
    
      constructor(name: string, otherName: string) {
        this.name = name;
        this.otherName = otherName;
      }
    
      getName() {
        return name;
      }
    }
    
    class SpecialGame extends Game {
      private description;
    
      constructor(name: string, description: string) {
        super(name, "other");
        this.description = description;
      }
    
      getOtherName() {
        return this.otherName;
      }
    }
    


    상호 작용




    interface IGame {
      getDescription(): string;
    }
    
    class Game implements IGame {
    
      getDescription(): string {
        return "";
      }
    }
    
    const objeto: IGame = {
      getDescription(): string {
        return "something";
      }
    }
    


    참조:
    Typescript Lang

    좋은 웹페이지 즐겨찾기