// ユーザーを作成するクラスの定義
class User {
    constructor(username, password) {
        this.username = username;
        this.password = password;
    }

    login() {
        console.log(`ログイン[${this.username}/${this.password}]`);
    }
}

const taro = new User("独習太郎", "taro-pwd");  // オブジェクトの生成：独習太郎
const hanako = new User("独習花子", "hanako-pwd"); // オブジェクトの生成：独習花子

[構文]クラスの記法
class クラス名 {
    constructor([引数,....]) {
        this.プロパティ = 値;
    }

    メソッド([引数,.....]) {

    }
}

[構文] インスタンス化によってオブジェクトを生成する
引数あり：
const オブジェクト = new クラス名([引数1, 引数2,...]);

引数なし:
const オブジェクト = new クラス名;

class TestCls {
    method(arg) {
        console.log(`引数:[${arg}]でメソッドを実行`);
    }
}

const test = new TestCls;
test.method("テスト");

> 引数[テスト]でメソッドを実行

[構文]静的メソッド、静的プロパティの定義方法

class クラス名 {
    static プロパティ名 = 値;
    static メソッド名() {...}
}

[構文]静的メソッド、静的プロパティの利用方法
クラス名.プロパティ名;
クラス名.メソッド名();

(使用例)
class Human {
    static TYPE = "普通の人";

    static staticMove() {
        console.log(Human.TYPE + "は歩いて移動します。");
    }

    constructor(name) {
        this.name = name;
    }

    move() {
        console.log(this.name + "は歩いて移動します。");
    }
}

const taro = new Human("太郎");
Human.staticMove();
> 普通の人は歩いて移動します。

console.log(Human.TYPE);
> 普通の人

taro.move();
> 太郎は歩いて移動します。

[構文] ゲッターとセッターの定義方法
class クラス名 {
    get ゲットプロパティ() {
        return ゲットプロパティを参照した際に取得される値;
    }

    set セットプロパティ(設定された値) {
        プロパティに値を設定するときに実行したい処理;
    }
}

[構文] ゲッターとセッターの使用方法
const obj = new クラス名
console.log(obj.ゲットプロパティ);
obj.セットプロパティ = 値;

[使用例]
class Person {
    constructor(firstname, lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }

    get fullname() {
        return this.lastname + this.firstname;
    }

    set age( value ) {
        this._age = Number(value);
    }

    get age() {
        return this._age;
    }
}

const taro = new Person("太郎", "独習");

console.log(taro.fullname());
> 独習太郎

taro.age = "18";

console.log(typeof taro.age);
> number

console.log(taro);
> {firstname: "太郎", lastname: "独習", _age: 18}

class Parent {
    constructor(value) {
        this.parentProp = value;
    }

    parentMethod() {
        console.log("親クラスのメソッド");
    }
}

class Child extends Parent {
    constructor(parentProp, childProp) {
        super(parentProp);
        this.childProp = childProp;
    }

    childMethod() {
        console.log(`子から親にアクセス[${this.parentProp}]`);
    }
}

const childObject = new Child("親", "子");
console.log(childObject);
> {parentProp: "親", childProp: "子"}

childObject.parentMethod();
> 親クラスのメソッド

childObject.childMethod();
> 子から親にアクセス[親]

[構文] instanceofの記法
let result = インスタンス instanceof クラス名;

class Parent { }
class Child extends Parent { }

const obj = new Child;
console.log(obj instanceof Child);
> true
console.log(obj instanceof Parent);
> true

[構文] hasOwnPropertyの記法
let 真偽値 = オブジェクト.hashOwnProperty("プロパティ名");

[構文] in 演算子の記法
let 真偽値 = "プロパティ名" in オブジェクト;

(ES2015の場合):
class ES2015 {
    constructor() {
        this.prop = 0;
    }
}

// ES2022のクラスで書いた場合
class ES2022 {
    prop = 0; // クラスのトップレベルでプロパティを設定可能
}

class ES2022 {
    prop1 = 0; // コンストラクタの引数を代入しない場合

    constructor(arg) {
        this.prop2 = arg; // コンストラクタの引数を代入する場合、constructor内で行う。
    }
}

class Counter {
    #count = 0; // プライベートプロパティ

    #print() { // プライベートメソッド
        console.log(this.count);
    }

    increment() { // パブリックメソッド
        this.#count++;
        this.#print(); // プライベートメソッドを実行
    }
}

const counter = new Counter();
counter.increment();

> 1

[構文] コンストラクタ関数の定義
function FunctionName([引数1, 引数2,....]) {
    this.プロパティ名 = 値;
}

function Test() {}
// 関数はオブジェクトの一種
Test.prop = "値"; // Test関数はオブジェクトなので、プロパティに値を設定できる
console.log(Test.prop);
> 値

// prototypeプロパティの存在確認
console.log("prototype" in Test);
> true // 関数を定義するとprototypeプロパティが自動的に設定される。

// prototypeにはオブジェクトが格納されている
console.log(typeof Test.prototype);
> object

function Person(name) {
    this.name = name;
}

Person.prototype.hello = function() { // Personコンストラクタのprototypeオブジェクトのhelloプロパティに無名関数を登録
    console.log(`こんにちは、${this.name}`);
}

const taro = new Person("独習太郎");
taro.hello();
> こんにちは、独習太郎

const hanako = new Person("独習花子");
hanako.hello();
> こんにちは、独習花子

function Test() { }
Test.prototype.hello = function() { console.log("こんにちは") };
const instance = new Test;

console.log(instance.__proto__ === Test.prototype); // __proto__とprototypeは同じオブジェクト
> true

instance.__proto__.hello();
> こんにちは

function Test() { }
Test.prototype.hello = function() { console.log("こんにちは") };
const instance = new Test;

console.log(instance.__proto__ === Test.prototype); // __proto__とprototypeは同じオブジェクト
> true

instance.hello();
> こんにちは

class Test {
    hello() {
        console.log("こんにちは");
    }
}

const instance = new Test;

Test.prototype.hello();
> こんにちは

instance.__proto__.hello();
> こんにちは

instance.hello();
> こんにちは

class Test {
    hello() {
        console.log("こんにちは");
    }
}

const instance = new Test;

Test.prototype.hello = function() {
    console.log("Hello");
}

instance.hello();
> Hello

const obj = {
    __proto__: {
        __proto__: {
            hello() {
                console.log("こんにちは");
            }
        },
    },
};

obj.hello();

> こんにちは

[構文] Object.createの使用方法
const resObj = Object.create(protoObj)

resObj: Object.createの引数に指定したオブジェクト(protoObj)への参照を__proto__に格納した空のオブジェクトが作成される。
仮にprotoObjが{hello: function() {}}のようなオブジェクトの場合、Object.create(protoObj)を実行すると、resObjは次のようなオブジェクトを生成する
{
    __proto__: {hello: function() {}}
}

protoObj:__proto__の参照先として設定したいオブジェクトを渡す。

(使用例)
const fruit1 = {
    apple: function() {
        console.log("リンゴ");
    },
};

const fruit2 = Object.create(fruit1);
fruit2.banana = function() {
    console.log("バナナ");
};

const fruit3 = Object.create(fruit2);
fruit3.melon = function() {
    console.log("メロン");
};

fruit3.apple();
> リンゴ
fruit3.banana();
> バナナ
fruit3.melon();
> メロン

// 親のコンストラクタを宣言
function Parent() { }

// 子のコンストラクタを宣言
function Child() { }

// 親のプロトタイプにメソッドを追加
Parent.prototype.parentMethod = function() {
    console.log("親のメソッド");
};

// 親のプロトタイプを継承
Child.prototype = Object.create(Parent.prototype);

// 子のプロトタイプにメソッドを追加
Child.prototype.childMethod = function() {
    console.log("このメソッド");
}

// インスタンス化
const childObj = new Child;
childObj.parentMethod();
> 親のメソッド
childObj.childMethod();
> 子のメソッド