Beste praksis for betinget logikk i TypeScript

Denne artikkelen forklarer beste praksis for betinget logikk i TypeScript.

YouTube Video

Beste praksis for betinget logikk i TypeScript

Innsnevring av typer med typevakter

Ved å utnytte TypeScripts typesystem og bruke typevakter i if-uttalelser, kan du forbedre typesikkerheten og lesbarheten.

1function processInput(input: string | number) {
2    if (typeof input === "string") {
3        console.log(`String input: ${input.toUpperCase()}`);
4    } else {
5        console.log(`Number input: ${input.toFixed(2)}`);
6    }
7}

Bruk av typeof og andre typevakter sikrer at koden i hver blokk er typesikker og kontekstuelt relevant.

Unngå nestede if-uttalelser

Dybdenestede if-uttalelser reduserer kodelesbarheten og vedlikeholdbarheten. Bruk i stedet tidlige returverdier, logiske operatorer eller ekstrakte funksjoner.

Dårlig eksempel:

1function checkUser(user: { age?: number; isAdmin?: boolean }) {
2    if (user.age) {
3        if (user.age > 18) {
4            if (user.isAdmin) {
5                console.log("User is an adult admin.");
6            }
7        }
8    }
9}

Forbedret eksempel:

1function checkUser(user: { age?: number; isAdmin?: boolean }) {
2    if (!user.age || user.age <= 18 || !user.isAdmin) {
3        return;
4    }
5    console.log("User is an adult admin.");
6}

Denne tilnærmingen flater ut koden og gjør logikken mer forståelig.

Bruk valgfri kjeding

Når du sjekker nestede egenskaper, bruk valgfri kjeding (?.) for å unngå unødvendige if-betingelser.

Uten valgfri kjeding:

1if (user && user.profile && user.profile.email) {
2    console.log(user.profile.email);
3}

Ved bruk av valgfri kjeding:

1if (user?.profile?.email) {
2    console.log(user.profile.email);
3}

Dette reduserer boilerplate-kode og forbedrer lesbarheten. Her refererer boilerplate-kode til repetitiv, standardisert kode som ofte kreves for å utføre spesifikke oppgaver i programmering.

Bruk strenge likhetsoperatorer

TypeScript støtter streng typifisering, og bruk av streng likhet (===) eller streng ulikhet (!==) bidrar til å forhindre uventet typekonvertering.

Dårlig eksempel:

1if (value == "123") {
2    console.log("Value is 123.");
3}

Forbedret eksempel:

1if (value === "123") {
2    console.log("Value is 123.");
3}

Bruk enums eller bokstavelige typer for eksplisitte betingelser

Bruk av enums eller bokstavelige typer klargjør betingelser og reduserer sannsynligheten for feil.

 1type Status = "success" | "error" | "loading";
 2
 3function displayMessage(status: Status) {
 4    if (status === "success") {
 5        console.log("Operation succeeded.");
 6    } else if (status === "error") {
 7        console.log("Operation failed.");
 8    } else {
 9        console.log("Loading...");
10    }
11}

Ved å definere forventede verdier, kan TypeScript oppdage typer og sikre nøyaktighet.

Kombiner lignende betingelser

Når flere betingelser deler samme logikk, konsolider dem ved hjelp av logiske operatorer eller en switch-setning.

Dårlig eksempel:

1if (role === "admin") {
2    grantAccess();
3}
4if (role === "superadmin") {
5    grantAccess();
6}

Forbedret eksempel:

1if (role === "admin" || role === "superadmin") {
2    grantAccess();
3}

Alternativt, bruk en switch-setning for å håndtere flere tydelige grener:

 1switch (role) {
 2    case "admin":
 3    case "superadmin":
 4        grantAccess();
 5        break;
 6    case "user":
 7        console.log("Limited access.");
 8        break;
 9    default:
10        console.log("No access.");
11}

Unngå å gjøre betingede uttrykk komplekse

Komplekse betingede uttrykk i if-setninger reduserer lesbarheten. Trekk dem ut i meningsfulle variabler eller funksjoner.

Dårlig eksempel:

1if (user.age > 18 && user.isAdmin && user.permissions.includes("write")) {
2    console.log("User can write.");
3}

Forbedret eksempel:

1const isAdultAdminWithWriteAccess =
2    user.age > 18 && user.isAdmin && user.permissions.includes("write");
3
4if (isAdultAdminWithWriteAccess) {
5    console.log("User can write.");
6}

Å gi betingelsene navn forbedrer klarheten og gjør koden selvforklarende.

Bruk ternære operatorer for enkle betingelser

For enkle betingelser gjør bruken av ternære operatorer koden kortfattet.

Eksempel:

1const message = isLoggedIn ? "Welcome back!" : "Please log in.";
2console.log(message);

Unngå imidlertid å bruke ternære operatorer for komplekse betingelser, da det reduserer lesbarheten.

Erstatt betingede grener med matriser eller kart

Når betingelsen kun er en verdimapping, kan bruk av matriser eller kart forbedre kodelesbarheten og vedlikeholdbarheten sammenlignet med switch-setninger eller komplekse if-else-blokker. I TypeScript kan du utnytte typeinformasjon for å implementere det mer sikkert.

Dårlig eksempel:

 1function getDayName(day: number): string {
 2    switch (day) {
 3        case 0:
 4            return "Sunday";
 5        case 1:
 6            return "Monday";
 7        case 2:
 8            return "Tuesday";
 9        case 3:
10            return "Wednesday";
11        case 4:
12            return "Thursday";
13        case 5:
14            return "Friday";
15        case 6:
16            return "Saturday";
17        default:
18            return "Invalid day";
19    }
20}

Forbedret eksempel: Bruk av en matrise

 1function getDayName(day: number): string {
 2    const days = [
 3        "Sunday",
 4        "Monday",
 5        "Tuesday",
 6        "Wednesday",
 7        "Thursday",
 8        "Friday",
 9        "Saturday"
10    ];
11    return days[day] ?? "Invalid day";
12}

Forbedret eksempel: Bruk av et kart

 1function getDayName(day: number): string {
 2    const dayMap = new Map<number, string>([
 3        [0, "Sunday"],
 4        [1, "Monday"],
 5        [2, "Tuesday"],
 6        [3, "Wednesday"],
 7        [4, "Thursday"],
 8        [5, "Friday"],
 9        [6, "Saturday"]
10    ]);
11    return dayMap.get(day) ?? "Invalid day";
12}

Konklusjon

Ved å følge disse beste praksisene kan du gjøre if-setninger i TypeScript klare, effektive og vedlikeholdbare. Ved å bruke TypeScript-funksjoner som typebeskyttere, valgfri lenking og enumerasjoner, kan du forbedre kodelesbarhet og robusthet. Ved å følge beste praksis kan du holde betingelser kortfattet og klare, noe som resulterer i kode som er enklere å forstå og vedlikeholde.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video