Ty­peSc­rip­til on mitmeid olulisi omadusi, mis pa­ran­da­vad oluliselt vee­bi­ra­ken­duste aren­da­mist. Käesolev Ty­peSc­ripti õpetus annab ülevaate prog­ram­mee­ri­mis­kee­lest ning selgitab selle olu­li­se­maid omadusi ja ka­su­tus­või­ma­lusi, samuti eeliseid ja puudusi.

Mis on Ty­peSc­ript?

Ty­peSc­ript on välja töötatud Mic­ro­softi poolt ja põhineb prog­ram­mee­ri­mis­kee­lel Ja­vaSc­ript, mida ka­su­ta­takse laial­da­selt vee­biaren­duses. Üks Ty­peSc­ripti sil­ma­pais­tev omadus on staa­ti­line tüüpimine. Erinevalt dü­naa­mi­li­selt tüüpivast Ja­vaSc­rip­tist võimaldab Ty­peSc­ript dek­la­ree­rida muutujate, funkt­sioo­nide ja pa­ra­meet­rite and­me­tüü­bid. See võimaldab varakult avastada ko­dee­ri­mis­vigu, mistõttu on võimalik tuvastada vead juba enne koodi täitmist. Staa­ti­line tüüpimine parandab oluliselt mitte ainult koodi kva­li­teeti, vaid ka koodi loetavust.

Ty­peSc­ripti süntaks on peaaegu identne Ja­vaSc­rip­tiga, mis muudab selle in­teg­ree­ri­mise ole­mas­ole­va­tesse Ja­vaSc­ripti pro­jek­ti­desse palju liht­sa­maks. Te­ge­li­kult on Ty­peSc­ript Ja­vaSc­ripti ülemhulk, mis tähendab, et iga korrektne Ja­vaSc­ripti kood on ka kehtiv Ty­peSc­ripti kood. See võimaldab teil järk-järgult üle minna Ty­peSc­rip­tile ja saada kasu staa­ti­lise tüüpimise ja muude funkt­sioo­nide eelistest, ilma et peaksite ole­mas­ole­vat koo­di­ba­asi täie­li­kult ümber kirjutama.

Siin on lihtne Ja­vaSc­ripti näide:

function greet(name) {
    return "Hello, " + name;
}
console.log(greet(123)); // Output: "Hello, 123"
ja­vasc­ript

Eespool toodud koodis ei ole funkt­sioon greet piiratud konk­reetse and­me­tüü­biga pa­ra­meetri name jaoks. See tähendab, et funkt­sioon töötab ka siis, kui me edastame ar­gu­men­dina numbri.

Ty­peSc­rip­tis võib kood välja näha järgmine:

function greet(name: string): string {
    return "Hello, " + name;
}
console.log(greet(123)); // Error in TypeScript
ty­pesc­ript

Siin oleme dek­la­ree­ri­nud pa­ra­meetri name stringina. Kui proovime funkt­siooni kasutada numbriga, kuvab Ty­peSc­ript vea, kuna edastatud andmetüüp ei vasta ooda­ta­vale and­me­tüü­bile.

See näide näitab, kuidas Ty­peSc­ript aitab varakult vigu avastada, pa­ran­da­des koodi kva­li­teeti ja vältides and­me­tüü­pide väär­ka­su­tust. Oluline on märkida, et Ty­peSc­ript kom­pi­lee­ri­takse lõpuks Ja­vaSc­rip­tiks, mis võimaldab seda käitada mis tahes Ja­vaSc­ripti kesk­kon­nas. See tähendab aga, et tüü­bi­kind­luse eeliseid saab kasutada ainult aren­dus­faa­sis.

Milleks ka­su­ta­takse Ty­peSc­ripti?

Ty­peSc­ript on oluline mit­me­su­gus­tes tark­va­raa­ren­duse vald­kon­da­des, eriti olu­kor­da­des, kus tüü­bi­kind­lus ja koodi kvaliteet on otsustava täht­su­sega.

Ty­peSc­ripti üks sil­ma­pais­tev ka­su­tus­ala on vee­biaren­dus. Siin tagab Ty­peSc­ript, et Ja­vaSc­ripti kood on kir­ju­ta­tud viisil, mis muudab selle tur­va­li­se­maks ja hool­duseks liht­sa­maks. See on kasulik ula­tus­li­kes frontend-pro­jek­ti­des, kus on kee­ru­li­sed koo­di­baasid. Ty­peSc­ripti saab aga rakendada ka serveri poolel (backend) Node.js-ra­ken­dus­tes, et pakkuda täien­da­vat tur­va­ta­san­dit. Serverita ar­hi­tek­tuu­ri­des, nagu AWS Lambda ja Azure Functions, aitab Ty­peSc­ript vähendada vigu ja tagada usal­dus­väärse täitmise.

Plat­vor­mi­ülene arendus on veel üks valdkond, kus Ty­peSc­ript näitab oma tugevusi. See võib oluliselt op­ti­mee­rida plat­vor­mi­üle­seid rakendusi ja mo­bii­li­ra­ken­duste aren­da­mist. Raa­mis­ti­kud nagu Na­ti­veSc­ript ja React Native pakuvad Ty­peSc­ripti tuge erinevate plat­vormide mo­bii­li­ra­ken­duste prog­ram­mee­ri­misel. Mängude aren­da­misel ka­su­ta­takse Ty­peSc­ripti pro­jek­ti­des, mis kasutavad WebGL-i või män­gu­moo­to­reid nagu Phaser või Babylon.js. Ty­peSc­ripti tüü­bi­kind­lus aitab parandada mängude kva­li­teeti ja hool­da­ta­vust.

Ty­peSc­ripti ka­su­ta­takse ka andmete vi­sua­li­see­ri­mise ja analüüsi pro­jek­ti­des. Raa­ma­tu­ko­gud nagu D3.js pakuvad Ty­peSc­ripti jaoks tuge ning või­mal­da­vad luua keerukaid juht­pa­neele ja vi­sua­li­see­rin­guid.

Kuidas ins­tal­lida Ty­peSc­ript

Ty­peSc­ripti ins­tal­li­mine on lihtne ja võtab vaid paar sammu. Kui teie arvutis on Node.js, saate Ty­peSc­ripti ins­tal­lida npm (Node Package Manager) abil.

1. samm: Lae alla Node.js

Kont­rol­lige, kas teie arvutisse on ins­tal­li­tud Node.js. Kui te pole Node.js veel ins­tal­li­nud, saate selle alla laadida ja ins­tal­lida amet­li­kult vee­bi­sai­dilt.

2. samm: Paigalda Ty­peSc­ript terminali

Ava kä­su­reaaken (nt kä­su­reaaken Windowsis või terminal macOS-is või Linuxis) ja sisesta järgmine käsk, et ins­tal­lida Ty­peSc­ript glo­baal­selt:

npm install -g typescript
bash

-g (globaalne) lipuke installib Ty­peSc­ripti kogu süsteemi, nii et saate seda kasutada kõikjal.

3. samm: Kont­rol­lige ins­tal­li­tud versiooni

Saate kont­rol­lida, kas ins­tal­li­mine õnnestus, käi­vi­ta­des järgmise käsu:

tsc -v
bash

See käsk näitab, milline Ty­peSc­ripti versioon on ins­tal­li­tud. Kui versiooni number kuvatakse, tähendab see, et ins­tal­li­mine õnnestus.

Pärast ins­tal­li­mist saate luua Ja­vaSc­ript-faile, luues Ty­peSc­ript-faile (laiendiga .ts) ja kom­pi­lee­ri­des need Ty­peSc­ript-kom­pi­laa­toriga tsc.

4. samm: Loo Ty­peSc­ript-fail

Loo Ty­peSc­ript-fail, nt app.ts, ja sisesta sinna oma Ty­peSc­ript-kood.

type Person = { name: string, age: number };
const alice: Person = { name: "Alice", age: 30 };
console.log(`Hello, I am ${alice.name} and I am ${alice.age} years old.`);
ty­pesc­ript

5. samm: Kom­pi­leeri fail

Kom­pi­lee­rige Ty­peSc­ript-fail, si­ses­ta­des järgmise käsu:

tsc app.ts
bash

See kom­pi­lee­rib app.ts Ja­vaSc­ript-failiks nimega app.js. Seejärel saate Ja­vaSc­ript-faili käivitada.

Millised omadused on Ty­peSc­rip­til?

Vee­biaren­dus on viimastel aastatel teinud mär­ki­mis­väär­seid edusamme ja Ty­peSc­ript on kujunenud äärmiselt tõhusaks al­ter­na­tiiviks Ja­vaSc­rip­tile. Allpool oleme kokku võtnud selle keele olu­li­se­mad omadused.

Staa­ti­line tüüpimine

Staa­ti­line tüüpimine on Ty­peSc­ripti oluline omadus, mis võimaldab määrata muutujate, pa­ra­meet­rite, funkt­sioo­nide ja muude koo­di­ele­men­tide and­me­tüü­bid. Erinevalt Ja­vaSc­ripti dü­naa­mi­li­sest tüü­pi­mi­sest, kus and­me­tüü­bid mää­ra­takse kindlaks käi­vi­ta­mise ajal, mää­ra­takse Ty­peSc­rip­tis and­me­tüü­bid kindlaks aren­da­mise ajal enne koodi käi­vi­ta­mist. See meetod aitab varakult tuvastada vigu ja loogilisi probleeme.

function add(a: number, b: number): number {
    return a + b;
}
const result = add(5, 3); // valid
const result = add(5, "3"); // Type Error
ty­pesc­ript

Selles näites ka­su­ta­sime funkt­siooni add jaoks staa­ti­list tüüpimist. Kaks pa­ra­meet­rit a ja b on dek­la­ree­ri­tud numb­ri­tena (number) ja funkt­sioon tagastab tüübi number väärtuse. Iga katse kasutada seda funkt­siooni teise and­me­tüü­biga põhjustab Ty­peSc­rip­tis vea.

Va­li­ku­line kir­ju­ta­mine

Va­li­ku­lise tüüpimise abil on teil võimalik määrata teatud muutujate ja pa­ra­meet­rite and­me­tüü­bid, jättes teised mää­rat­le­mata and­me­tüü­biga.

function sayHello(name: string, age: any): string {
    if (age) {
        return `Hello, ${name}, you are ${age} years old.`;
    } else {
        return `Hello, ${name}.`;
    }
}
ty­pesc­ript

Funkt­sioon sayHello on de­fi­nee­ri­tud pa­ra­meet­ri­tega name ja age. Märge any näitab, et pa­ra­mee­ter age võib olla mis tahes andmetüüp.

ES6+ funkt­sioo­nid

Ty­peSc­ript toetab kaas­aeg­seid Ja­vaSc­ripti funkt­sioone, seal­hul­gas ES6 ja uuemaid funkt­sioone, nagu noo­le­funkt­sioo­nid ja mal­list­rin­gid.

const multiply = (a: number, b: number): number => a * b;
const greeting = (name: string) => `Hello, ${name}!`;
ty­pesc­ript

Noo­le­funkt­sioo­nid muudavad süntaksi lühemaks ja la­koo­ni­li­se­maks.

Koodi korraldus

Ty­peSc­ript pakub paremat koodi or­ga­ni­see­ri­mist ja tagab, et kood jaguneb taas­ka­su­ta­ta­va­teks osadeks. See on võimalik tänu moo­du­li­tele ja nimeruumi.

// Math.ts
export function add(a: number, b: number): number {
    return a + b;
}
// Main.ts
import { add } from './Math';
const result = add(5, 3);
ty­pesc­ript

Siin näitame, kuidas struk­tu­ree­rida koodi moo­du­li­tega ja kasutada import ja export or­ga­ni­see­ri­miseks. Lisamise funkt­sioon on de­fi­nee­ri­tud eraldi moodulis nimega Math.ts ja seejärel im­por­di­tud ja in­teg­ree­ri­tud teise moo­du­lisse, Main.ts.

Ob­jek­to­rien­tee­ri­tud prog­ram­mee­ri­mine (OOP)

Ty­peSc­ript hõlbustab ob­jek­to­rien­tee­ri­tud prog­ram­mee­ri­mist Ty­peSc­ripti klasside, liideste ja pärimise abil:

class Person {
    constructor(public name: string, public age: number) {}
    greet() {
        console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
    }
}
const person = new Person("Alice", 30);
person.greet();
ty­pesc­ript

See näide näitab klasside ja ob­jek­to­rien­tee­ri­tud prog­ram­mee­ri­mise (OOP) ka­su­ta­mist Ty­peSc­rip­tis. Klassil Person on omadused name, age ja meetod greet, mida ka­su­ta­takse isiku tut­vus­ta­miseks ja tema kohta teabe andmiseks.

Laien­da­tud tüü­bi­süs­teem

Ty­peSc­ripti tüü­bi­süs­teem on paindlik ja ulatuslik. Saate luua kasutaja määratud tüüpe ja liideseid ning isegi laiendada ole­mas­ole­vaid tüüpe.

interface Animal {
    name: string;
}
 
interface Dog extends Animal {
    breed: string;
}
const myDog: Dog = { name: "Buddy", breed: "Labrador" };
ty­pesc­ript

Liides Animal määratleb omaduse name, samas kui liides Dog pärineb liidesest Animal ja lisab täiendava omaduse breed. Objektil myDog on mõlema liidese omadused.

Ühilduvus Ja­vaSc­rip­tiga

Ty­peSc­ript on Ja­vaSc­rip­tiga ühilduv, mis võimaldab seda kasutada igas Ja­vaSc­ripti kesk­kon­nas. See ühilduvus muudab Ty­peSc­ripti järk­jär­gu­lise lisamise prae­gus­tesse Ja­vaSc­ripti pro­jek­ti­desse liht­sa­maks.

// JavaScript-Code
function greet(name) {
    return "Hello, " + name;
}
// TypeScript-Code
function greet(name: string): string {
    return "Hello, " + name;
}
ty­pesc­ript

Eespool toodud Ja­vaSc­ripti koodi (ilma tüüpide mää­rat­le­miseta) saab prob­leemi­deta kasutada Ty­peSc­ripti koodis (tüüpide mää­rat­le­mi­sega).

Millised on Ty­peSc­ripti eelised ja puudused?

Kuigi Ty­peSc­ript pakub mitmeid eeliseid, on sellel ka mõned puudused. Siin on ülevaade:

Eelised

Ty­peSc­rip­til on ulatuslik tüü­bi­de­fi­nit­sioo­nide öko­süs­teem paljude Ja­vaSc­ripti raa­ma­tu­ko­gude ja raa­mis­tike jaoks. See muudab kol­man­date osapoolte koodi in­teg­ree­ri­mise Ty­peSc­ripti pro­jek­ti­desse sujuvaks ja lihtsaks. See on kasulik tänapäeva vee­bi­põ­histe ra­ken­duste maailmas, mis tuginevad sageli mitmetele raa­ma­tu­ko­gu­dele ja raa­mis­ti­ku­tele.

Lisaks staa­ti­li­sele tüü­pi­misele pakub Ty­peSc­ript mitmeid aren­dus­funkt­sioone, seal­hul­gas liideseid, klasse, mooduleid ja toetust keh­ti­va­tele EC­MASc­ripti stan­dar­di­tele. Need funkt­sioo­nid pa­ran­da­vad koodi struk­tu­ree­ri­mist, hõl­bus­ta­vad pro­jek­tide hool­da­ta­vust ja ska­lee­ri­ta­vust ning edendavad aren­dus­töö pro­duk­tiiv­sust. Paljud in­teg­ree­ri­tud aren­dus­kesk­kon­dad (IDE), nagu Visual Studio Code, pakuvad Ty­peSc­rip­tile suu­re­pä­rast tuge.

Puudused

Ty­peSc­rip­tiga har­ju­miseks kulub aega, eriti aren­da­ja­tel, kes on enne seda kasutanud ainult Ja­vaSc­ripti. Ty­peSc­ripti kood tuleb enne brau­se­ri­tes või Node.js-kesk­kon­nas käi­vi­ta­mist kom­pi­lee­rida Ja­vaSc­rip­tiks. See lisab aren­dus­prot­sessi ühe lisasammu.

Väik­se­mate pro­jek­tide puhul võib Ty­peSc­ript tunduda liiga keeruline, kuna tüü­bi­kind­luse eelised ei pruugi olla nii ilmsed. Ty­peSc­ripti projektid võivad nõuda rohkem ressursse täiendava tüübiinfo ja kom­pi­lee­ri­mise­tap­pide tõttu.

Millised on Ty­peSc­ripti al­ter­na­tiivid?

Sõltuvalt projekti konk­reet­se­test nõuetest ja arendaja(te) eelis­tus­test on olemas mit­me­su­gu­seid vee­bi­prog­ram­mee­ri­mis­keeli, mis võivad olla heaks al­ter­na­tiiviks Ty­peSc­rip­tile.

  • Flow: Flow on Facebooki poolt arendatud Ja­vaSc­ripti staa­ti­line tüü­bi­kont­rol­lija. See võimaldab lisada Ja­vaSc­ripti koodile tüüpe, ilma et oleks vaja täie­li­kult üle minna Ty­peSc­rip­tile. Flow on hea valik, kui soovite tüüpimist järk-järgult oma Ja­vaSc­ripti pro­jek­ti­desse in­teg­ree­rida.
  • Dart: see on Google’i poolt arendatud prog­ram­mee­ri­mis­keel, mida saab kasutada vee­bi­ra­ken­duste ja mo­bii­li­ra­ken­duste loomiseks. See pakub tüü­bi­kind­lust ja head jõudlust. Dart’i ka­su­ta­takse sageli koos Flutteri raa­mis­ti­kuga mo­bii­li­ra­ken­duste aren­da­miseks.
  • Pu­reSc­ript: Pu­reSc­ript on tugevalt tüübitav funkt­sio­naalne prog­ram­mee­ri­mis­keel, mis pakub tugevat tüü­bi­kind­lust ja puhtalt funkt­sio­naal­set prog­ram­mee­ri­misstiili. See võimaldab importida Ja­vaSc­ripti raa­ma­tu­ko­gusid.
  • Elm: Elm on funkt­sio­naalne, tugevalt tüü­bi­tur­va­line keel, mis on loodud vee­bi­ra­ken­duste aren­da­miseks. Elm edendab Elm Arc­hi­tec­ture põhimõtet ja pakub kõrget tüü­bi­tur­va­li­sust.
  • ReasonML (Buck­leSc­ript): see keel on arendatud Facebooki poolt ja põhineb OCaml-il. Buck­leSc­ript on kom­pi­laa­tor, mis kom­pi­lee­rib ReasonML-i Ja­vaSc­rip­tiks. See võimaldab ka tüü­bi­kind­lust ja on lihtne in­teg­ree­rida Reactiga frontend-aren­da­miseks.
Tip

Meie di­gi­taal­ses juhendis kä­sit­le­takse põh­ja­li­ku­malt muid teemasid, nagu Ty­peSc­ripti funkt­sioo­nid ja Ty­peSc­ripti massiivid.

e75cdbdbe04a7c169f7217c3d8777f68

Go to Main Menu