Detaillierte Erklärung generischer Fälle in TypeScript

// Anforderung 1: Generika können nicht angegebene Datentypen unterstützen. Dies erfordert, dass die übergebenen und die zurückgegebenen Parameter konsistent sind. // Obwohl diese Methode Konsistenz zwischen den übergebenen und zurückgegebenen Parametern erreichen kann, geht die Typparameterprüfung verloren. /*
Funktion getData(Wert: beliebig): beliebig {
    Rückgabewert „Erfolg“
}
*/

// Generika definieren, um Anforderung 1 zu erfüllen // T steht für Generika (der Großbuchstabe kann hier beliebig definiert werden, ist aber standardmäßig T) Der konkrete Typ wird beim Aufruf dieser Methode bestimmt function getData<T>(value: T):T{
    Rückgabewert;
}

//Eingehender String-Typ var get = getData<string>("hallo")
console.log(abrufen)

// Der übergebene Typ ist eine Zahl var getTwo = getData<Zahl>(666)
console.log(getTwo)

// Anforderung 2: Beispielsweise gibt es einen minimalen Heap-Algorithmus, der sowohl Zahlen als auch Zeichenfolgen zurückgeben muss. Dies kann durch Klassengenerika erreicht werden. // Klassengenerika definieren class minCla<T> {
    Liste: T[] = [];

    hinzufügen(Wert: T):void {
        diese.Liste.push(Wert);
    }

    min(): T {
        var minNum = diese.Liste[0];
        für(var i=0; i<diese.Liste.Länge; i++) {
            wenn (minNum > diese.Liste[i]) {
                minNum = diese.Liste[i]
            }
        }
        minNum zurückgeben
    }
}

var minNum = neue minCla<Zahl>();
minNum.add(2);
minNum.add(1);
minNum.add(7);
console.log(minNum.min()); // gibt 1 zurück


// Zeichen werden nach ASCII-Code verglichen var minNumTwo = new minCla<string>();
minNumTwo.add("c");
minNumTwo.add("z");
minNumTwo.add("a");
console.log(minNumTwo.min()) // Gibt einen

// Zwei Möglichkeiten zur Implementierung generischer Schnittstellen // Methode 1:
// Definieren Sie eine generische Schnittstelle interface Func {
    <T>(Wert: T): T
}

// Definieren Sie eine Funktion zur Implementierung der generischen Schnittstelle var f: Func = function<T>(value: T) {
    Rückgabewert;
}
f<string>("hallo")
f<Zahl>(666)

// Methode 2:
Schnittstelle FuncONe {
    <T>(Wert: T): T
}

var f1: FuncONe = Funktion<T>(Wert: T):T {
    Rückgabewert;
}

f1<string>("Welt")
f1<Zahl>(666)

/*
1. Definieren Sie eine Benutzerklasse, die zum Zuordnen von Datenbankfeldern verwendet wird. 2. Definieren Sie dann eine MysqlDb-Klasse, die zum Bedienen der Datenbank verwendet wird. 3. Übergeben Sie dann die Benutzerklasse als Parameter an MysqlDb. */

/*Version 1:
Klasse Benutzer {
    Benutzername: Zeichenfolge | nicht definiert;
    Passwort: Zeichenfolge | nicht definiert;
}

Klasse MysqlDb {
    add(Benutzer: Benutzer): boolean {
        console.log(Benutzer);
        gibt true zurück;
    }
}

var u1 = neuer Benutzer();
u1.Benutzername = "pika";
u1.password = "pika"

var msql = neue MysqlDb();
msql.add(u1);
*/

// Allerdings können die oben definierten Tabellen und Datenbanken die Richtigkeit der eingehenden Daten nicht garantieren // Version 2 // Definieren Sie die generische Klasse MysqlDb <T>{
    hinzufügen(info: T): boolean {
        konsole.log(info);
        gibt true zurück;
    }
}

// Definieren Sie eine Benutzerklasse und ordnen Sie sie der Datenbankklasse User { zu.
    Benutzername: Zeichenfolge | nicht definiert;
    Passwort: Zeichenfolge | nicht definiert;
}

var u1 = neuer Benutzer();
u1.Benutzername = "pika";
u1.password = "pika"

// Instanziieren Sie eine Datenbank (die Klasse wird als Parameter verwendet, um den Typ des eingehenden Parameters einzuschränken)
var msql = new MysqlDb<Benutzer>();
msql.add(u1); // Stellen Sie sicher, dass das Format der eingehenden Daten vom Typ „Benutzer“ ist

brauchen:
Funktion: Definieren Sie eine Datenbankoperationsbibliothek zur Unterstützung von Mysql MongoDb
Anforderung 1: Mysql und MongoDb haben dieselben Funktionen, beide haben Methoden zum Hinzufügen, Aktualisieren, Löschen und Abrufen. Hinweis: Lösungen für eingeschränkte einheitliche Spezifikationen und Wiederverwendung von Code: Es sind eingeschränkte Spezifikationen erforderlich, daher müssen Schnittstellen definiert werden, und es ist eine Wiederverwendung von Code erforderlich, daher werden Generika verwendet. 1. Schnittstelle: In der objektorientierten Programmierung ist eine Schnittstelle eine Spezifikationsdefinition, die die Spezifikationen von Verhalten und Aktionen definiert. 2. Generika: Allgemeines Verständnis: Generika sollen die Wiederverwendbarkeit von Methoden der Klassenschnittstelle lösen*/

// Implementierungsprozess:
// Definieren Sie eine Schnittstelle, um alle Methoden einzuschränken Schnittstelle DbMethod<T> {
    hinzufügen (Info: T): Boolesch;
    Update (Info: T, ID: Nummer): Boolesch;
    löschen(id: Nummer): Boolesch;
    get(id: Nummer): Boolesch;
}

// Definieren Sie eine Mysql-Datenbankklasse. Hinweis: Um eine generische Schnittstelle zu implementieren, muss diese Klasse auch eine generische Klasse sein class MysqlDbs<T> implements DbMethod<T> {
    hinzufügen(info: T): boolean {
        konsole.log(info);
        gibt true zurück;
    }    
    
    update(info: T, id: Nummer): boolean {
        var obj = {
            Benutzername: "xxxx",
            Passwort: "666"
        }
        returniere wahr
    }

    löschen(id: Nummer): boolean {
        console.log("Löschen erfolgreich");
        returniere wahr
    }
    
    get(id: Nummer): boolean {
        var arr = [
            {Benutzername: "xxx",
            Passwort: "xxxxx"
            }
        ];
        returniere wahr
    }
}
// prüfen:
Klasse Benutzer {
    Benutzername: Zeichenfolge | nicht definiert;
    Passwort: Zeichenfolge | nicht definiert;
};

// Verwenden Sie die Klasse „Users“, um die Richtigkeit der in var mysql = new MysqlDbs<Users>(); übergebenen Parameter einzuschränken.
var u = neue Benutzer();
u.Benutzername = "xxxx"
u.passwort = "xxxxxx"
//Das Hinzufügen, Löschen, Ändern und Abfragen der Datenbank simulieren mysql.add(u);
mysql.get(1);
mysql.update(u, 1);
mysql.delete(1)



// Definieren Sie eine MongoDb-Datenbankklasse. Hinweis: Um eine generische Schnittstelle zu implementieren, muss diese Klasse auch eine generische Klasse sein. class MongoDb<T> implements DbMethod<T> {
    hinzufügen(info: T): boolean {
        konsole.log(info);
        gibt true zurück;
    }    
    
    update(info: T, id: Nummer): boolean {
        var obj = {
            Benutzername: "xxxx",
            Passwort: "666"
        }
        returniere wahr
    }

    löschen(id: Nummer): Boolesch {
        console.log("Löschen erfolgreich");
        returniere wahr
    }
    
    get(id: Nummer): boolean {
        var arr = [
            {Benutzername: "xxx",
            Passwort: "xxxxx"
            }
        ];
        returniere wahr
    }
}

// prüfen:
Klasse Userd {
    Benutzername: Zeichenfolge | nicht definiert;
    Passwort: Zeichenfolge | nicht definiert;
};

// Verwenden Sie die Klasse „Users“, um die Richtigkeit der in var mysql = new MongoDb<Userd>(); übergebenen Parameter einzuschränken.
var u = neuer Userd();
u.Benutzername = "xxxx"
u.passwort = "xxxxxx"
//Das Hinzufügen, Löschen, Ändern und Abfragen der Datenbank simulieren mysql.add(u);
mysql.get(1);
mysql.update(u, 1);
mysql.delete(1)