Typescriptの基本構文13個を共有する

const a: 文字列 = 'オーロラ'

const b: number = 666 // NAN 無限大を含む

定数 c: ブール値 = true

定数d:null = null

定数 e: 未定義 = 未定義

const h: シンボル = シンボル()

const foo1: オブジェクト = {};
const foo2: オブジェクト = [];
const foo3: オブジェクト = 関数(){};

const obj: {名前: 文字列、年齢: 数値} = {
    名前: 「オーロラ」
    年齢:18
}

const arr: 配列<数値> = [1,2,3]

定数arr: 数値[] = [1,2,3]

定数タプル: [数値、文字列、ブール値] = [666、'auraros'、true]

列挙ステータス{
    ペディング = 1、
    解決 = 2、
    拒否 = '3'
}
//アクセス console.log(Status.pedding);

関数 fun (名前:文字列,年齢:数値):文字列{
  'sss' を返す
}
fun('オーロラ',18);

関数 fun (名前:文字列,年齢?:数値):文字列{
  'sss' を返す
}
fun('オーロラ');

関数 fun (名前:文字列,年齢:数値=666):文字列{
  'sss' を返す
}
fun('オーロラ');

関数 fun (name:文字列,age:数値=666,...res:数値[]):文字列{
  'sss' を返す
}
fun('オーロラ',1,2,3);

const fun2:(名前:文字列,年齢:数値)=>文字列 = 関数(名前:文字列,年齢:数値){
  'sss' を返す
}

num:any = 1 とします。
数値 = 'a';
数値 = true;

定数res = 1;
const num = res を数値として扱います。

定数res = 1;
const num = <数値>res

インターフェース Post {
    名前: 文字列;
    年齢:番号
}

インターフェース Post {
    名前: 文字列;
    年齢:番号
}

関数 printPost(post: Post){
    console.log(投稿名);
    console.log(投稿の年齢);
}
printPost({name:'asd',age:666})

インターフェース Post {
    名前: 文字列;
    年齢:番号;
    性別?:文字列;
}

const オーロラ:Post = {
    名前:'asd',
    年齢: 18
}

インターフェース Post {
    名前: 文字列;
    年齢:番号;
    性別?:文字列;
    読み取り専用 like:文字列 
}

const オーロラ:Post = {
    名前:'asd',
    年齢: 18歳
    例えば: 'natrue'
}
オーロラの名前 = 'aaaa';
// 保証されたエラー auroras.like = 'wind';

インターフェース Post {
  [prop:文字列]:文字列
} 
const オーロラ:Post = {
    名前:'asd',
    例えば: 'natrue'
}

クラス Person {
    名前: 文字列;
    年齢: 番号;
    コンストラクター(名前:文字列,年齢:数値){
       this.name = 名前;
       this.age = 年齢;
    }
    sayHi(メッセージ:文字列):void {
        console.log(`こんにちは、${msg}、私は${this.name}です`);
    }
}

クラス Person {
  パブリック名: 文字列;
  プライベート年齢：番号;
  コンストラクター(名前:文字列,年齢:数値){
       this.name = 名前;
       this.age = 年齢;
    }
  sayHi(メッセージ:文字列):void {
        console.log(`こんにちは、${msg}、私は${this.name}です`);
        コンソールにログ出力します。
    }
}

定数ジャック = 新しい Person('ジャック',20);
//Person クラスのパブリック プロパティにアクセスできます console.log(jack.name);
//Person クラスのプライベート プロパティにはアクセスできません console.log(jack.age);
protected はそれを保護されたものとして変更し、外部からアクセスできなくなります。しかし、private との違いは、継承されたサブクラスがアクセスできることです。

クラス Person {
  パブリック名: 文字列;
  プライベート年齢：番号;
  // 保護されています
  保護された性別: ブール値;
    コンストラクター(名前:文字列,年齢:数値){
       this.name = 名前;
       this.age = 年齢;
       性別をtrueに設定します。
    }
    sayHi(メッセージ:文字列):void {
        console.log(`こんにちは、${msg}、私は${this.name}です`);
        コンソールにログ出力します。
    }
}

クラスの子はPersonを拡張します{ 
    コンストラクター(名前:文字列,年齢:数値){
        super(名前,年齢,);
        //console.log(this.gender); にアクセスできます。
    }
}

クラス Person {
  パブリック名: 文字列;
  プライベート年齢：番号;
  // 読み取り専用
  保護された読み取り専用の性別: ブール値;
    コンストラクター(名前:文字列,年齢:数値){
       this.name = 名前;
       this.age = 年齢;
       性別をtrueに設定します。
    }
    sayHi(メッセージ:文字列):void {
        console.log(`こんにちは、${msg}、私は${this.name}です`);
        コンソールにログ出力します。
    }
}

//EatインターフェースインターフェースEat {
    食べる(食べ物:文字列):void
}
//実行インターフェース interface Run {
    実行(動作:文字列):void
}
//クラスPeopleはEat、Runを実装します{
    食べる(食べ物: 文字列){
       console.log(`テーブルの上の${food}を食べます`);
    }
    実行(動作:文字列){
       console.log(`立っている ${behavior}`);
    }
}
//AnimalクラスAnimalはEat、Runを実装します{
    食べる(食べ物: 文字列){
       console.log(`地面にある${food}を食べる`);
    }
    実行(動作:文字列){
       console.log(`${behavior} をクロールしています`);
    }
}

抽象クラス Animal {
    食べる(食べ物: 文字列){
       console.log(`地面にある${food}を食べる`);
    }
    抽象実行 (動作:文字列):void
}
//CatクラスDogはAnimalを拡張します{
    実行(動作:文字列):void{
        console.log(動作);
    }
}
定数 d1 = 新しい Dog();
d1.eat('骨')
d1.run('4本足で這う') 
//rabbitクラスrabbitはAnimalを拡張します{
    実行(動作:文字列):void{
        console.log(動作);
    }
}
定数 r1 = 新しい rabbit();
d1.eat('大根')
d1.run('ジャンプ') 

 関数のアイデンティティ(引数:数値):数値{
     戻り引数
 }
文字列が渡された場合、関数は次のようになります。

 関数のアイデンティティ(引数:文字列):文字列{
     戻り引数
 }
これは面倒すぎるので、一般的に大文字の T で表されるジェネリックを使用できます。ジェネリックは複数の型に適用でき、入力型と戻り型は同じです。

 関数のアイデンティティ<T>(引数:T):T{
     戻り引数
 }