TypeScript Node.js: Serveripoolne tüübikindluse rakendamine

Veebiarenduse pidevalt arenevas maastikus on tugevate ja hooldatavate serveripoolsete rakenduste ehitamine ülimalt tähtis. Kuigi JavaScript on pikka aega olnud veebi keel, võib selle dünaamiline olemus mõnikord põhjustada käitusaja vigu ja raskusi suuremate projektide skaleerimisel. TypeScript, JavaScripti ülemhulk, mis lisab staatilise tüübi, pakub võimsat lahendust nendele väljakutsetele. TypeScripti kombineerimine Node.js-iga pakub veenvat keskkonda tüübikindlate, skaleeritavate ja hooldatavate tagalasüsteemide ehitamiseks.

Miks TypeScript Node.js Serveripoolse Arenduse jaoks?

TypeScript toob Node.js arendusse hulga eeliseid, käsitledes paljusid JavaScripti dünaamilise tüübiomaduste piiranguid.

• Täiustatud tüübikindlus: TypeScript jõustab kompileerimisajal range tüübikontrolli, püüdes potentsiaalsed vead kinni enne nende tootmisse jõudmist. See vähendab käitusaja erandite riski ja parandab teie rakenduse üldist stabiilsust. Kujutage ette stsenaariumi, kus teie API ootab kasutaja ID-d numbrina, kuid saab stringi. TypeScript märgistaks selle vea arenduse ajal, vältides potentsiaalset krahhi tootmises.
• Parem koodi hooldatavus: Tüübiannotatsioonid muudavad koodi lihtsamaks mõistmiseks ja refaktoreerimiseks. Meeskonnas töötades aitavad selged tüübi definitsioonid arendajatel kiiresti mõista erinevate koodiosade eesmärki ja oodatavat käitumist. See on eriti oluline pikaajaliste projektide puhul, millel on arenevad nõuded.
• Täiustatud IDE tugi: TypeScripti staatiline tüüp võimaldab IDE-del (Integrated Development Environments) pakkuda paremat automaatset täiendamist, koodis navigeerimist ja refaktoreerimise tööriistu. See parandab oluliselt arendaja tootlikkust ja vähendab vigade tekkimise tõenäosust. Näiteks pakub VS Code'i TypeScripti integratsioon intelligentseid soovitusi ja veahäälestust, muutes arenduse kiiremaks ja tõhusamaks.
• Varajane vea tuvastamine: Tüübipõhiste vigade tuvastamisega kompileerimise ajal võimaldab TypeScript teil probleeme lahendada arendustsükli alguses, säästes aega ja vähendades silumispüüdlusi. See ennetav lähenemine takistab vigade levimist rakenduse kaudu ja mõjutamast kasutajaid.
• Aeglane vastuvõtmine: TypeScript on JavaScripti ülemhulk, mis tähendab, et olemasolevat JavaScripti koodi saab järk-järgult migreerida TypeScripti. See võimaldab teil tüübikindlust järk-järgult kasutusele võtta, ilma et oleks vaja kogu oma koodibaasi ümber kirjutada.

TypeScript Node.js Projekti seadistamine

TypeScripti ja Node.js-iga alustamiseks peate installima Node.js ja npm (Node Package Manager). Kui need on installitud, saate uue projekti seadistamiseks järgida neid samme:

1. Loo projektikataloog: Looge oma projekti jaoks uus kataloog ja navigeerige sellesse oma terminalis.
2. Initsialiseeri Node.js projekt: Käivitage npm init -y, et luua fail package.json.
3. Installi TypeScript: Käivitage npm install --save-dev typescript @types/node, et installida TypeScript ja Node.js tüübi definitsioonid. Pakett @types/node pakub Node.js sisseehitatud moodulite tüübi definitsioone, võimaldades TypeScriptil teie Node.js koodi mõista ja valideerida.
4. Loo TypeScripti konfiguratsioonifail: Käivitage npx tsc --init, et luua fail tsconfig.json. See fail konfigureerib TypeScripti kompilaatori ja määrab kompileerimisvalikud.
5. Konfigureeri tsconfig.json: Avage fail tsconfig.json ja konfigureerige see vastavalt oma projekti vajadustele. Mõned levinumad valikud hõlmavad:
• target: määrab ECMAScripti sihtversiooni (nt "es2020", "esnext").
• module: määrab kasutatava moodulisüsteemi (nt "commonjs", "esnext").
• outDir: määrab kompileeritud JavaScripti failide väljundkataloogi.
• rootDir: määrab TypeScripti lähtefailide juurkataloogi.
• sourceMap: lubab lähtekaardi genereerimise hõlpsamaks silumiseks.
• strict: lubab range tüübikontrolli.
• esModuleInterop: lubab koostalitlusvõime CommonJS-i ja ES-moodulite vahel.

Näidisfail tsconfig.json võib välja näha selline:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": [
    "src/**/*"
  ]
}

See konfiguratsioon ütleb TypeScripti kompilaatorile, et see kompileeriks kõik failid .ts kataloogis src, väljastaks kompileeritud JavaScripti failid kataloogi dist ja genereeriks silumiseks lähtekaardid.

Põhilised tüübiannotatsioonid ja liidesed

TypeScript tutvustab tüübiannotatsioone, mis võimaldavad teil selgesõnaliselt määrata muutujate, funktsiooniparameetrite ja tagastusväärtuste tüübid. See võimaldab TypeScripti kompilaatoril teha tüübikontrolli ja varakult vigu kinni püüda.

Põhitüübid

TypeScript toetab järgmisi põhitüüpe:

• string: esindab tekstiväärtusi.
• number: esindab numbrilisi väärtusi.
• boolean: esindab tõeväärtusväärtusi (true või false).
• null: esindab väärtuse tahtlikku puudumist.
• undefined: esindab muutujat, millele pole väärtust määratud.
• symbol: esindab unikaalset ja muutumatut väärtust.
• bigint: esindab suvalise täpsusega täisarve.
• any: esindab mis tahes tüüpi väärtust (kasutage säästlikult).
• unknown: esindab väärtust, mille tüüp on teadmata (turvalisem kui any).
• void: esindab funktsiooni tagastusväärtuse puudumist.
• never: esindab väärtust, mis ei esine kunagi (nt funktsioon, mis alati viskab vea).
• array: esindab sama tüüpi väärtuste järjestatud kollektsiooni (nt string[], number[]).
• tuple: esindab konkreetsete tüüpidega väärtuste järjestatud kollektsiooni (nt [string, number]).
• enum: esindab nimetatud konstantide komplekti.
• object: esindab mitte-primitiivset tüüpi.

Siin on mõned näited tüübiannotatsioonidest:

let name: string = "John Doe";
let age: number = 30;
let isStudent: boolean = false;

function greet(name: string): string {
  return `Tere, ${name}!`;
}

let numbers: number[] = [1, 2, 3, 4, 5];

let person: { name: string; age: number } = {
  name: "Jane Doe",
  age: 25,
};

Liidesed

Liidesed määratlevad objekti struktuuri. Need täpsustavad omadused ja meetodid, mis objektil peavad olema. Liidesed on võimas viis tüübikindluse jõustamiseks ja koodi hooldatavuse parandamiseks.

Siin on näide liidesest:

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
}

function getUser(id: number): User {
  // ... too kasutajaandmed andmebaasist
  return {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    isActive: true,
  };
}

let user: User = getUser(1);

console.log(user.name); // John Doe

Selles näites määrab liides User kasutajaobjekti struktuuri. Funktsioon getUser tagastab objekti, mis vastab liidesele User. Kui funktsioon tagastab objekti, mis ei vasta liidesele, viskab TypeScripti kompilaator vea.

Tüübialiasid

Tüübialiasid loovad tüübile uue nime. Nad ei loo uut tüüpi - nad annavad olemasolevale tüübile kirjeldavama või mugavama nime.

type StringOrNumber = string | number;

let value: StringOrNumber = "hello";
value = 123;

//Tüübialias keerulise objekti jaoks
type Point = {
 x: number;
 y: number;
};

const myPoint: Point = { x: 10, y: 20 };

Lihtsa API ehitamine TypeScripti ja Node.js-iga

Loome lihtsa REST API, kasutades TypeScripti, Node.js-i ja Express.js-i.

1. Installige Express.js ja selle tüübi definitsioonid: Käivitage npm install express @types/express
2. Looge fail nimega src/index.ts järgmise koodiga:

import express, { Request, Response } from 'express';

const app = express();
const port = process.env.PORT || 3000;

interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: 'Sülearvuti', price: 1200 },
  { id: 2, name: 'Klaviatuur', price: 75 },
  { id: 3, name: 'Hiir', price: 25 },
];

app.get('/products', (req: Request, res: Response) => {
  res.json(products);
});

app.get('/products/:id', (req: Request, res: Response) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);

  if (product) {
    res.json(product);
  } else {
    res.status(404).json({ message: 'Toodet ei leitud' });
  }
});

app.listen(port, () => {
  console.log(`Server töötab pordis ${port}`);
});

See kood loob lihtsa Express.js API kahe lõpp-punktiga:

• /products: tagastab toodete loendi.
• /products/:id: tagastab konkreetse toote ID järgi.

Liides Product määrab tooteobjekti struktuuri. Massiiv products sisaldab tooteobjektide loendit, mis vastavad liidesele Product.

API käivitamiseks peate TypeScripti koodi kompileerima ja Node.js serveri käivitama:

1. Kompileeri TypeScripti kood: Käivitage npm run tsc (võimalik, et peate selle skripti failis package.json defineerima kui "tsc": "tsc").
2. Käivitage Node.js server: Käivitage node dist/index.js.

Seejärel pääsete API lõpp-punktidele juurde oma brauseris või tööriistaga nagu curl:

curl http://localhost:3000/products
curl http://localhost:3000/products/1

Täpsemad TypeScripti tehnikad serveripoolseks arenduseks

TypeScript pakub mitmeid täiustatud funktsioone, mis võivad veelgi parandada tüübikindlust ja koodi kvaliteeti serveripoolses arenduses.

Generics

Generics võimaldavad teil kirjutada koodi, mis võib töötada erinevat tüüpi andmetega, ohverdamata tüübikindlust. Need pakuvad viisi tüüpide parametreerimiseks, muutes teie koodi korduvkasutatavamaks ja paindlikumaks.

Siin on näide üldisest funktsioonist:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);

Selles näites võtab funktsioon identity argumendi tüüpi T ja tagastab sama tüüpi väärtuse. Süntaks <T> näitab, et T on tüübiparameeter. Funktsiooni kutsudes saate määrata T tüübi selgesõnaliselt (nt identity<string>) või lasta TypeScriptil seda argumendist tuletada (nt identity("hello")).

Diskrimineeritud liidud

Diskrimineeritud liidud, tuntud ka kui sildistatud liidud, on võimas viis väärtuste esitamiseks, mis võivad olla üks mitmest erinevast tüübist. Neid kasutatakse sageli olekumasinate modelleerimiseks või erinevat tüüpi vigade esindamiseks.

Siin on näide diskrimineeritud liidust:

type Success = {
  status: 'success';
  data: any;
};

type Error = {
  status: 'error';
  message: string;
};

type Result = Success | Error;

function handleResult(result: Result) {
  if (result.status === 'success') {
    console.log('Õnnestus:', result.data);
  } else {
    console.error('Viga:', result.message);
  }
}

const successResult: Success = { status: 'success', data: { name: 'John Doe' } };
const errorResult: Error = { status: 'error', message: 'Midagi läks valesti' };

handleResult(successResult);
handleResult(errorResult);

Selles näites on tüüp Result diskrimineeritud liit tüüpidest Success ja Error. Omadus status on diskrimineerija, mis näitab, millist tüüpi väärtus on. Funktsioon handleResult kasutab diskrimineerijat, et määrata, kuidas väärtust käsitleda.

Kasulike tüüpide vahendid

TypeScript pakub mitmeid sisseehitatud utiliitüüpe, mis aitavad teil tüüpe manipuleerida ja luua kokkusurutumat ja väljendusrikkamat koodi. Mõned levinumad utiliittüübid hõlmavad:

• Partial<T>: muudab kõik T omadused valikuliseks.
• Required<T>: muudab kõik T omadused nõutavaks.
• Readonly<T>: muudab kõik T omadused kirjutuskaitstud.
• Pick<T, K>: loob uue tüübi ainult T omadustega, mille võtmed on K.
• Omit<T, K>: loob uue tüübi kõigi T omadustega, välja arvatud need, mille võtmed on K.
• Record<K, T>: loob uue tüübi võtmetega tüüpi K ja väärtustega tüüpi T.
• Exclude<T, U>: välistab T-st kõik tüübid, mis on määratavad U-le.
• Extract<T, U>: eraldab T-st kõik tüübid, mis on määratavad U-le.
• NonNullable<T>: välistab null ja undefined T-st.
• Parameters<T>: hankib funktsiooni tüübi T parameetrid tuplina.
• ReturnType<T>: hankib funktsiooni tüübi T tagastustüübi.
• InstanceType<T>: hankib konstruktorfunktsiooni tüübi T eksemplari tüübi.

Siin on mõned näited utiliittüüpide kasutamisest:

interface User {
  id: number;
  name: string;
  email: string;
}

// Muuda kõik Useri omadused valikuliseks
type PartialUser = Partial<User>;

// Loo tüüp ainult Useri nime ja e-posti omadustega
type UserInfo = Pick<User, 'name' | 'email'>;

// Loo tüüp kõigi Useri omadustega, välja arvatud id
type UserWithoutId = Omit<User, 'id'>;

TypeScript Node.js Rakenduste testimine

Testimine on oluline osa usaldusväärsete ja usaldusväärsete serveripoolsete rakenduste ehitamisel. TypeScripti kasutamisel saate tüübisüsteemi ära kasutada, et kirjutada tõhusamaid ja hooldatavamaid teste.

Node.js jaoks populaarsed testimisraamistikud hõlmavad Jesti ja Mohat. Need raamistikud pakuvad erinevaid funktsioone ühiktestide, integratsioonitestide ja lõpust-lõpuni testide kirjutamiseks.

Siin on näide ühiktestist, kasutades Jesti:

// src/utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// test/utils.test.ts
import { add } from '../src/utils';

describe('add', () => {
  it('peaks tagastama kahe arvu summa', () => {
    expect(add(1, 2)).toBe(3);
  });

  it('peaks käsitlema negatiivseid arve', () => {
    expect(add(-1, 2)).toBe(1);
  });
});

Selles näites testitakse funktsiooni add kasutades Jesti. Plokk describe koondab omavahel seotud testid kokku. Plokid it määratlevad üksikud testjuhtumid. Funktsiooni expect kasutatakse koodi käitumise kohta väidete tegemiseks.

TypeScripti koodi testide kirjutamisel on oluline tagada, et teie testid hõlmaksid kõiki võimalikke tüübistsenaariume. See hõlmab testimist erinevat tüüpi sisenditega, testimist null- ja määratlemata väärtustega ning testimist kehtetute andmetega.

Parimad tavad TypeScript Node.js Arenduses

Selleks, et teie TypeScript Node.js projektid oleksid hästi struktureeritud, hooldatavad ja skaleeritavad, on oluline järgida mõningaid parimaid tavasid:

• Kasuta ranget režiimi: lubage failis tsconfig.json range režiim, et jõustada rangemat tüübikontrolli ja püüda potentsiaalsed vead varakult kinni.
• Määratlege selged liidesed ja tüübid: kasutage liideseid ja tüüpe oma andmete struktuuri määratlemiseks ja tüübikindluse tagamiseks kogu oma rakenduses.
• Kasuta generice: kasutage generice, et kirjutada korduvkasutatavat koodi, mis võib töötada erinevat tüüpi andmetega, ohverdamata tüübikindlust.
• Kasuta diskrimineeritud liite: kasutage diskrimineeritud liite, et esitada väärtusi, mis võivad olla üks mitmest erinevast tüübist.
• Kirjuta põhjalikud testid: kirjutage ühiktestid, integratsioonitestid ja lõpust-lõpuni testid, et tagada teie koodi õige toimimine ja rakenduse stabiilsus.
• Järgige järjekindlat kodeerimisstiili: kasutage koodiformaatorit nagu Prettier ja linterit nagu ESLint, et jõustada järjekindel kodeerimisstiil ja püüda potentsiaalsed vead. See on eriti oluline meeskonnaga töötamisel, et säilitada ühtlane koodibaas. ESLinti ja Prettieri jaoks on palju konfiguratsioonivalikuid, mida saab meeskonna vahel jagada.
• Kasuta sõltuvuse süstimist: sõltuvuse süstimine on disainimuster, mis võimaldab teil oma koodi lahti siduda ja muuta see testitavamaks. Sellised tööriistad nagu InversifyJS võivad aidata teil sõltuvuse süstimist oma TypeScript Node.js projektides rakendada.
• Rakenda õige veahaldus: rakendage tugev veahaldus, et erandeid elegantselt kinni püüda ja käsitleda. Kasutage proov-püüa-plokke ja vealogimist, et vältida rakenduse kokku kukkumist ja anda kasulikku silumisteavet.
• Kasuta moodulipaketti: kasutage moodulipaketti nagu Webpack või Parcel, et oma kood pakendada ja tootmiseks optimeerida. Kuigi sageli seostatakse seda esiotsa arendusega, võivad moodulipaketid olla kasulikud ka Node.js projektidele, eriti ES-moodulitega töötamisel.
• Kaaluge raamistiku kasutamist: uurige raamistikke nagu NestJS või AdonisJS, mis pakuvad struktuuri ja konventsioone skaleeritavate ja hooldatavate Node.js-rakenduste ehitamiseks TypeScriptiga. Need raamistikud sisaldavad sageli funktsioone, nagu sõltuvuse süstimine, marsruutimine ja vahevara tugi.

Juurutamise kaalutlused

TypeScript Node.js rakenduse juurutamine sarnaneb standardse Node.js rakenduse juurutamisega. Siiski on mõned lisakaalutlused:

• Kompileerimine: enne selle juurutamist peate oma TypeScripti koodi JavaScriptiks kompileerima. Seda saab teha osana teie ehitusprotsessist.
• Lähtekaardid: kaaluge lähtekaartide kaasamist oma juurutuspaketisse, et hõlbustada silumist tootmises.
• Keskkonnamuutujaid: kasutage keskkonnamuutujaid oma rakenduse konfigureerimiseks erinevate keskkondade jaoks (nt arendus, lavastus, tootmine). See on standardpraktika, kuid muutub veelgi olulisemaks kompileeritud koodiga tegelemisel.

Populaarsed juurutusplatvormid Node.js jaoks hõlmavad:

• AWS (Amazon Web Services): pakub erinevaid teenuseid Node.js rakenduste juurutamiseks, sealhulgas EC2, Elastic Beanstalk ja Lambda.
• Google Cloud Platform (GCP): pakub sarnaseid teenuseid AWS-iga, sealhulgas Compute Engine, App Engine ja Cloud Functions.
• Microsoft Azure: pakub selliseid teenuseid nagu Virtual Machines, App Service ja Azure Functions Node.js rakenduste juurutamiseks.
• Heroku: teenusplatvorm (PaaS), mis lihtsustab Node.js rakenduste juurutamist ja haldamist.
• DigitalOcean: pakub virtuaalseid privaatseid servereid (VPS), mida saate kasutada Node.js rakenduste juurutamiseks.
• Docker: konteineriseerimistehnoloogia, mis võimaldab teil oma rakenduse ja selle sõltuvused pakendada ühte konteinerisse. See hõlbustab rakenduse juurutamist mis tahes keskkonnas, mis toetab Dockerit.

Järeldus

TypeScript pakub märkimisväärset parendust traditsioonilise JavaScripti suhtes tugevate ja skaleeritavate serveripoolsete rakenduste ehitamiseks Node.js-iga. Kasutades tüübikindlust, täiustatud IDE tuge ja täpsemaid keeleomadusi, saate luua hooldatavamaid, usaldusväärsemaid ja tõhusamaid tagalasüsteeme. Kuigi TypeScripti kasutuselevõtmisega on seotud õppimiskõver, muudavad pikaajalised eelised koodi kvaliteedi ja arendaja tootlikkuse osas selle väärtuslikuks investeeringuks. Kuna nõudlus hästi struktureeritud ja hooldatavate rakenduste järele kasvab jätkuvalt, on TypeScriptil potentsiaal saada serveripoolsete arendajate jaoks üha olulisemaks tööriistaks kogu maailmas.