Bild des Autors
# Einführung
Sie haben eine Weile in Python codiert, es absolut lieben und wahrscheinlich Dekorateure in Ihrem Schlaf schreiben. Aber es gibt diese nörgelnde Stimme in Ihrem Kopf, die sagt, dass Sie Typenkript lernen sollten. Vielleicht ist es für diese Vollstapelrolle, oder Sie sind es leid zu erklären, warum Python für große Codebasen „völlig in Ordnung“ ist.
Hier ist die Sache: TypeScript ist nicht nur „JavaScript mit Typen“. Es ist das, was JavaScript von Anfang an hätte sein sollen. Und wenn Sie aus Python kommen, verstehen Sie bereits mehr als Sie denken.
# Gehen Sie von Python zu Typscript
Python gibt Ihnen Enten -Typing und dynamische Flexibilität. TypeScript bietet Ihnen die gleiche Flexibilität mit einem Sicherheitsnetz. Denken Sie an als Pythons Mypy Wenn MyPy tatsächlich überall arbeitete.
In Python können Sie eine beliebige Methode für jedes Objekt aufrufen und „hoffen“, dass sie funktioniert. TypeScript teilt Sie zum Kompilierzeit mit, ob es funktionieren wird, und rettet Sie vor diesen "AttributeError: 'NoneType' object has no attribute 'identify'" Momente.
# Python: You hope this works
def process_user(consumer):
return consumer.identify.higher()
// TypeScript: You already know this works
operate processUser(consumer: Person): string {
return consumer.identify.toUpperCase();
}Wenn consumer hat keine identify Eigenschaft, Typscript fängt es vor, bevor Ihr Code jemals ausgeführt wird. Sie brauchen additionally keine Verteidigung if hasattr(obj, 'attribute') Überall überall.
# Typscript -Grundlagen
Beginnen wir mit den Grundlagen von Typenkript.
// Variablen und Grundtypen
Pythons Typ -Hinweise sind optionale Vorschläge. Typscript -Typen sind eher erzwungene Verträge. Die guten Nachrichten? TypeScript kann die meisten Typen automatisch schließen, sodass Sie nicht alles mit Anmerkungen versehen müssen.
# Python
identify = "Alice"
age = 30
is_active = True
scores = (95, 87, 92)
consumer = {"identify": "Bob", "age": 25}
// TypeScript
const identify = "Alice"; // string (inferred)
const age = 30; // quantity (inferred)
const isActive = true; // boolean (inferred)
const scores = (95, 87, 92); // quantity() (inferred)
const consumer = { identify: "Bob", age: 25 }; // object (inferred)
// Or be specific
const identify: string = "Alice";
const scores: quantity() = (95, 87, 92);Sie benötigen nur explizite Anmerkungen, wenn die Inferenz nicht offensichtlich ist oder wenn Sie Ihre Absichten besonders klar machen möchten.
// Funktionen
Die Funktionssyntaxkarten karten quick direkt, aber der Ansatz von TypeScript zu Standardparametern ist sauberer als Pythons veränderliches Standardargument Gotchas.
# Python
def greet(identify: str, excited: bool = False) -> str:
suffix = "!" if excited else "."
return f"Hiya, {identify}{suffix}"
// TypeScript
operate greet(identify: string, excited = false): string {
const suffix = excited ? "!" : ".";
return `Hiya, ${identify}${suffix}`;
}
// Or arrow operate (Python lambda equal)
const greet = (identify: string, excited = false): string =>
`Hiya, ${identify}${excited ? "!" : "."}`;Die Pfeilfunktionssyntax ähnelt Pythons Lambda, aber mächtiger. Sie können vollständige Funktionskörper oder prägnante Einzeiler schreiben. Vorlagenliterale (diese Backticks) funktionieren genau wie Pythons F-Strings.
// Klassen
TypeScript -Klassen fühlen sich immer optimierter als Python -Klassen. Nicht mehr self Überall und Konstruktorparameter können automatisch zu Eigenschaften werden.
# Python
class Person:
def __init__(self, identify: str, e mail: str):
self.identify = identify
self.e mail = e mail
def greet(self) -> str:
return f"Hello, I am {self.identify}"
// TypeScript
class Person {
constructor(public identify: string, public e mail: string) {}
greet(): string {
return `Hello, I am ${this.identify}`;
}
}Das public Das Schlüsselwort im Konstruktor ist die Abkürzung von TypeScript für „Erstellen Sie diese Eigenschaft automatisch und weisen Sie ihm den Parameterwert zu.“ Sie müssen additionally die nicht benutzen self.identify = identify Kesselplatte. Sie können auch verwenden non-public oder protected zur Kapselung.
# Wo Typscript interessant wird
Hier fühlt sich TypeScript interessant an, wenn Sie über die Grundlagen hinausgehen.
// Gewerkschaftstypen (Python’s Union aber besser)
Pythons Gewerkschaftstypen aus der Schreibmodularbeit, aber manchmal ausführlich. Die Gewerkschaftstypen von TypeScript sind in die Sprache eingebaut.
# Python
from typing import Union
def process_id(user_id: Union(str, int)) -> str:
return str(user_id)
// TypeScript
operate processId(userId: string | quantity): string {
return userId.toString();
}Der | Syntax ist sauberer als Union(str, int)Der Compiler von TypeScript kann eine ausgefeiltere Typüberprüfung durchführen. Es weiß, welche Methoden basierend auf dem spezifischen Typ zur Laufzeit verfügbar sind.
// Wörtliche Typen
Pythons wörtliche Typen sind relativ neu, aber hilfsbereit. TypeScript hat jedoch viel effektivere Wörteltypen.
# Python
from typing import Literal
Standing = Literal("pending", "authorized", "rejected")
def update_status(standing: Standing) -> None:
print(f"Standing: {standing}")
// TypeScript
kind Standing = "pending" | "authorized" | "rejected";
operate updateStatus(standing: Standing): void {
console.log(`Standing: ${standing}`);
}Versuchen Sie, eine ungültige Zeichenfolge wie „vielleicht“ an zu übergeben updateStatusund Typscript weigern sich zu kompilieren. Ihr Editor bietet sogar automatische Vervollständigung für die gültigen Optionen. Es ist, als würde man eine Aufzählung haben, die tatsächlich nützlich ist.
// Schnittstellen
Pythons DataClasses eignen sich hervorragend zum Erstellen strukturierter Daten:
# Python
from dataclasses import dataclass
@dataclass
class Person:
identify: str
e mail: str
age: intSchnittstellen in TypeScript sind jedoch flexibler. Sie beschreiben die Daten, ohne eine bestimmte Klassenimplementierung zu erstellen.
// TypeScript
interface Person {
identify: string;
e mail: string;
age: quantity;
}
// Use it anyplace
const consumer: Person = { identify: "Alice", e mail: "alice@instance.com", age: 30 };Jedes Objekt, das die richtigen Eigenschaften hat, erfüllt automatisch die Schnittstelle. Keine Vererbung erforderlich, keine explizite Klassen -Instanziierung erforderlich. Es ist Enten, mit der Überprüfung der Kompilierung zu tippen.
# Weitere Typenkriptfunktionen lernen
Lassen Sie uns nun ein paar weitere nützliche Funktionen von TypeScript lernen.
// Generika (wie Pythons TypeVar)
Pythons generisches Tippen funktioniert, aber es ist klobig. Typscript Generics fühlt sich natürlich und mächtig an.
# Python
from typing import TypeVar, Listing
T = TypeVar('T')
def first(gadgets: Listing(T)) -> T:
return gadgets(0)
// TypeScript
operate first(gadgets: T()): T {
return gadgets(0);
}
// Works with something
const firstNumber = first((1, 2, 3)); // quantity
const firstString = first(("a", "b", "c")); // string Typscript färbt den generischen Typ automatisch von der Verwendung. Anruf first mit Zahlen, und es gibt eine Nummer zurück. Rufen Sie es mit Saiten an und es gibt eine Zeichenfolge zurück. Keine explizite Typparameter erforderlich, aber Sie können sie bereitstellen, wenn die Inferenz nicht klar ist.
// Geben Sie Wachen ein
Mit Typ Guards können Sie Laufzeitüberprüfungen schreiben, die der Compiler versteht und zum Eingrenzung von Typen in nachfolgenden Code verwendet.
operate isString(worth: unknown): worth is string {
return typeof worth === "string";
}
operate processValue(worth: string | quantity) {
if (isString(worth)) {
return worth.toUpperCase();
}
return worth.toFixed(2);
}Der worth is string Syntax sagt TypeScript, dass der Parameter definitiv eine Zeichenfolge ist, wenn diese Funktion true zurückgibt. Im IF -Block erhalten Sie vollständige Stringmethoden und Eigenschaften. Kein Casting, keine Behauptungen, nur ein intelligenter Typ verengen sich basierend auf Ihren Laufzeitüberprüfungen.
// Zugeordnete Typen (Listenverständnisse für Typen)
Stellen Sie sich kartierte Typen als Listenverständnis vor, aber für Typtransformationen. Sie können neue Typen erstellen, indem Sie vorhandene transformieren.
kind Person = {
identify: string;
e mail: string;
age: quantity;
};
// Make all properties non-obligatory
kind PartialUser = Partial;
// Make all properties readonly
kind ReadonlyUser = Readonly;
// Decide particular properties
kind UserContact = Decide; Diese Dienstprogrammtypen versenden mit TypeScript und lösen gemeinsame Muster. Wenn Sie einen Typ benötigen, der wie Benutzer, jedoch mit optionalen Feldern für Updates ist, können Sie verwenden Partial<Person>. Und wenn Sie nach der Erstellung keine Änderungen sicherstellen müssen, verwenden Sie die Verwendung Readonly<Person>.
# Fehlerbehandlung in TypeScript
Python -Entwickler lieben es, versuchen/außer Blöcken, aber sie können ausführlich werden. TypeScript verwendet einen anderen Ansatz mithilfe von Ergebnistypen und Gewerkschaftstypen für die Fehlerbehandlung, die Fehler in Ihren Funktionssignaturen explizit machen:
// Outcome kind sample (impressed by Rust)
kind Outcome = { success: true; information: T } | { success: false; error: E };
// Make this file a module
export {};
// Assuming you've got a Person kind and parseUser operate
interface Person {
identify: string;
// ... different properties
}
operate parseUser(information: unknown): Person {
// Your parsing logic right here
// This could throw an error if parsing fails
if (!information || typeof information !== 'object') {
throw new Error('Invalid consumer information');
}
const consumer = information as any;
if (!consumer.identify || typeof consumer.identify !== 'string') {
throw new Error('Person identify is required and have to be a string');
}
return { identify: consumer.identify };
}
async operate safeParseUser(information: unknown): Promise> {
strive {
const consumer = parseUser(information);
return { success: true, information: consumer };
} catch (error) {
// Repair: Deal with the case the place error won't have a message property
const errorMessage = error instanceof Error ? error.message : String(error);
return { success: false, error: errorMessage };
}
} Sie können es so verwenden wie so:
// Utilization (wrapped in an async operate or use at prime stage in a module)
async operate instance() {
const rawData = { identify: "John Doe" }; // Instance information
const end result = await safeParseUser(rawData);
if (end result.success) {
console.log(end result.information.identify); // TypeScript is aware of that is Person
} else {
console.error(end result.error); // TypeScript is aware of that is string
}
}
// Name the instance operate
instance();Dieses Muster macht Fehler im Typ des Typs explizit. Anstelle von Ausnahmen, die unsichtbar herumfliegen, werden Fehler Teil des Rückkehrtyps. Der Outcome<T, E> Typ zwingt Sie dazu, sowohl Erfolg als auch Misserfolg zu bewältigen. Die diskriminierten Gewerkschaften von TypeScript machen dieses Muster einfach: Die Erfolgseigenschaft zeigt an, in welcher Gewerkschaft Sie sich befinden, sodass es weiß, ob Daten oder Fehler verfügbar sind.
# Abschluss
Typscript wird in Webentwicklung, groß angelegten Anwendungen und überall, wo Sie robuste APIs benötigen.
Bei dem Übergang geht es nicht darum, eine neue Sprache zu lernen. Es geht mehr darum, alles, was Sie über gutes Softwaredesign wissen, in einem anderen Ökosystem anzuwenden. Ihre Python -Instinct für sauberes Code, lesbare APIs und nachdenkliche Abstraktionen übersetzt direkt.
Additionally öffnen Sie vs Code, erstellen Sie a .ts Datei und mit dem Codieren beginnen. Das Schlimmste, was passiert? Sie lernen etwas Neues. Das Beste? Möglicherweise finden Sie Ihre neue Lieblingssprache. Pleased Coding!
Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.