Ty­peSc­rip­til­la on useita keskeisiä omi­nai­suuk­sia, jotka pa­ran­ta­vat mer­kit­tä­väs­ti web-so­vel­lus­ten ke­hit­tä­mis­tä. Tämä Ty­peSc­ript-opas tarjoaa johdannon oh­jel­moin­ti­kie­leen ja selittää sen tär­keim­piä omi­nai­suuk­sia ja käyt­tö­tar­koi­tuk­sia sekä sen etuja ja haittoja.

Mikä on Ty­peSc­ript?

Ty­peSc­ript on Mic­ro­sof­tin kehittämä oh­jel­moin­ti­kie­li, joka perustuu web-ke­hi­tyk­ses­sä laajasti käy­tet­tyyn Ja­vaSc­ript-kieliin. Yksi Ty­peSc­rip­tin erottuva omi­nai­suus on staat­ti­nen tyypitys. Toisin kuin dy­naa­mi­sen tyy­pi­tyk­sen käyttävä Ja­vaSc­ript, Ty­peSc­ript mah­dol­lis­taa muut­tu­jien, funk­tioi­den ja pa­ra­met­rien tie­to­tyyp­pien mää­rit­te­lyn. Tämä mah­dol­lis­taa koo­daus­vir­hei­den varhaisen ha­vait­se­mi­sen, jolloin virheet voidaan tunnistaa jo ennen koodin suo­rit­ta­mis­ta. Staat­ti­nen tyypitys parantaa mer­kit­tä­väs­ti koodin laatua ja luet­ta­vuut­ta.

Ty­peSc­rip­tin syntaksi on lähes ident­ti­nen Ja­vaSc­rip­tin kanssa, mikä helpottaa sen in­tegroin­tia olemassa oleviin Ja­vaSc­ript-pro­jek­tei­hin. Itse asiassa Ty­peSc­ript on Ja­vaSc­rip­tin yläjoukko, mikä tar­koit­taa, että kaikki oikea Ja­vaSc­ript-koodi on myös kel­vol­lis­ta Ty­peSc­ript-koodia. Tämä mah­dol­lis­taa as­teit­tai­sen siir­ty­mi­sen Ty­peSc­rip­tiin ja staat­ti­sen tyy­pi­tyk­sen sekä muiden omi­nai­suuk­sien hyö­dyn­tä­mi­sen ilman, että olemassa olevaa koo­di­poh­jaa tarvitsee kir­joit­taa kokonaan uudelleen.

Tässä on yk­sin­ker­tai­nen Ja­vaSc­ript-esimerkki:

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

Yllä olevassa koodissa funktio greet ei ole ra­joi­tet­tu tiettyyn tie­to­tyyp­piin pa­ra­met­rin name osalta. Tämä tar­koit­taa, että funktio toimii edelleen, vaikka välitämme ar­gu­ment­ti­na numeron.

Ty­peSc­rip­tis­sä koodi voi näyttää tältä:

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

Tässä olemme mää­rit­tä­neet pa­ra­met­rin name merk­ki­jo­nok­si. Jos yritämme käyttää funktiota numeron kanssa, Ty­peSc­ript näyttää vir­heil­moi­tuk­sen, koska välitetty tie­to­tyyp­pi ei vastaa odotettua tie­to­tyyp­piä.

Tämä esimerkki osoittaa, kuinka Ty­peSc­ript auttaa ha­vait­se­maan virheet var­hai­ses­sa vaiheessa ja parantaa koodin laatua estämällä tie­to­tyyp­pien vir­heel­li­sen käytön. On tärkeää huomata, että Ty­peSc­ript kään­ne­tään lopulta Ja­vaSc­rip­tik­si, jolloin sitä voidaan käyttää missä tahansa Ja­vaSc­ript-ym­pä­ris­tös­sä. Tämä tar­koit­taa kuitenkin, että tyyp­pi­tur­val­li­suu­den edut ovat käy­tet­tä­vis­sä vain ke­hi­tys­vai­hees­sa.

Mihin Ty­peSc­rip­tia käytetään?

Ty­peSc­ript on vält­tä­mä­tön monilla oh­jel­mis­to­ke­hi­tyk­sen alueilla, eri­tyi­ses­ti ti­lan­teis­sa, joissa tyyp­pi­tur­val­li­suus ja koodin laatu ovat rat­kai­se­van tärkeitä.

Ty­peSc­rip­tin mer­kit­tä­vä käyt­tö­ta­paus on web-kehitys. Tässä Ty­peSc­ript varmistaa, että Ja­vaSc­ript-koodi on kir­joi­tet­tu tavalla, joka tekee siitä tur­val­li­sem­man ja helpommin yl­lä­pi­det­tä­vän. Tämä on hyö­dyl­lis­tä laajoissa frontend-pro­jek­teis­sa, joissa on mo­ni­mut­kai­sia koo­di­poh­jia. Ty­peSc­rip­tia voidaan kuitenkin toteuttaa myös pal­ve­lin­puo­lel­la (backend) Node.js-so­vel­luk­sis­sa, jolloin se tarjoaa li­sä­ker­rok­sen tur­val­li­suut­ta. Pal­ve­li­met­to­mis­sa ark­ki­teh­tuu­reis­sa, kuten AWS Lambda ja Azure Functions, Ty­peSc­ript auttaa mi­ni­moi­maan virheet ja var­mis­ta­maan luo­tet­ta­van suo­ri­tuk­sen.

Mo­nia­lus­tai­nen kehitys on toinen alue, jolla Ty­peSc­ript osoittaa vah­vuu­ten­sa. Se voi mer­kit­tä­väs­ti optimoida mo­nia­lus­tai­sia so­vel­luk­sia ja mo­bii­li­so­vel­lus­ten ke­hit­tä­mis­tä. Kehykset, kuten Na­ti­veSc­ript ja React Native, tarjoavat tukea Ty­peSc­rip­til­le, kun kyse on mo­bii­li­so­vel­lus­ten oh­jel­moin­nis­ta eri alus­toil­le. Pe­li­ke­hi­tyk­ses­sä Ty­peSc­rip­tia hyö­dyn­ne­tään pro­jek­teis­sa, joissa käytetään WebGL:ää tai pe­li­moot­to­rei­ta, kuten Phaser tai Babylon.js. Ty­peSc­rip­tin tyyp­pi­tur­val­li­suus auttaa pa­ran­ta­maan pelien laatua ja yl­lä­pi­det­tä­vyyt­tä.

Ty­peSc­rip­tia käytetään myös datan vi­sua­li­soin­tiin ja ana­ly­soin­tiin. Kirjastot kuten D3.js tukevat Ty­peSc­rip­tia ja mah­dol­lis­ta­vat ke­hit­ty­nei­den hal­lin­ta­pa­nee­lien ja vi­sua­li­soin­tien luomisen.

Ty­peSc­rip­tin asen­ta­mi­nen

Ty­peSc­rip­tin asen­ta­mi­nen on helppoa ja vaatii vain muutaman vaiheen. Jos tie­to­ko­neel­la­si on Node.js, voit asentaa Ty­peSc­rip­tin npm lla (Node Package Manager).

Vaihe 1: Lataa Node.js

Tarkista, onko Node.js asennettu tie­to­ko­neel­le­si. Jos et ole vielä asentanut Node.js:ää, voit ladata ja asentaa sen vi­ral­li­sel­ta verk­ko­si­vus­tol­ta.

Vaihe 2: Asenna Ty­peSc­ript ter­mi­naa­lis­sa

Avaa ko­men­to­ke­ho­te (esim. ko­men­to­ke­ho­te Win­dow­sis­sa tai ter­mi­naa­li macOS- tai Linux-käyt­tö­jär­jes­tel­mäs­sä) ja kirjoita seuraava komento asen­taak­se­si Ty­peSc­rip­tin glo­baa­lis­ti:

npm install -g typescript
bash

-g (globaali) lippu asentaa Ty­peSc­rip­tin koko jär­jes­tel­mään, jotta voit käyttää sitä mistä tahansa.

Vaihe 3: Tarkista asennettu versio

Voit testata, onko asennus on­nis­tu­nut, suo­rit­ta­mal­la seuraavan komennon:

tsc -v
bash

Tämä komento näyttää, mikä Ty­peSc­ript-versio on asennettu. Jos versio numero näkyy, asennus on on­nis­tu­nut.

Asen­nuk­sen jälkeen voit luoda Ja­vaSc­ript-tie­dos­to­ja luomalla Ty­peSc­ript-tie­dos­to­ja (tie­dos­to­tun­nis­te .ts) ja kään­tä­mäl­lä ne Ty­peSc­ript-kään­tä­jäl­lä tsc.

Vaihe 4: Luo Ty­peSc­ript-tiedosto

Luo Ty­peSc­ript-tiedosto, esi­mer­kik­si app.ts, ja lisää siihen Ty­peSc­ript-koodisi.

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

Vaihe 5: Käännä tiedosto

Käännä Ty­peSc­ript-tiedosto antamalla seuraava komento:

tsc app.ts
bash

Tämä kom­pi­loi­da app.ts Ja­vaSc­ript-tie­dos­tok­si nimeltä app.js. Sen jälkeen voit suorittaa Ja­vaSc­ript-tiedoston.

Mitä omi­nai­suuk­sia Ty­peSc­rip­til­la on?

Verk­ko­ke­hi­tys on edistynyt mer­kit­tä­väs­ti viime vuosina, ja Ty­peSc­ript on noussut erittäin te­hok­kaak­si vaih­toeh­dok­si Ja­vaSc­rip­til­le. Alla olemme koonneet tämän kielen tär­keim­mät omi­nai­suu­det.

Staat­ti­nen tyypitys

Staat­ti­nen tyypitys on Ty­peSc­rip­tin olen­nai­nen omi­nai­suus, jonka avulla voit määrittää muut­tu­jien, pa­ra­met­rien, funk­tioi­den ja muiden ele­ment­tien tie­to­tyy­pit koo­dis­sa­si. Toisin kuin Ja­vaSc­rip­tin dy­naa­mi­ses­sa tyy­pi­tyk­ses­sä, jossa tie­to­tyy­pit mää­ri­te­tään suo­ri­tuk­sen aikana, Ty­peSc­rip­tis­sä tie­to­tyy­pit mää­ri­te­tään ke­hi­tys­vai­hees­sa ennen koodin suo­rit­ta­mis­ta. Tämä menetelmä auttaa tun­nis­ta­maan virheet ja loogiset ongelmat var­hai­ses­sa vaiheessa.

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

Tässä esi­mer­kis­sä käytimme staat­tis­ta tyy­pi­tys­tä funk­tios­sa add. Kaksi pa­ra­met­ria a ja b on mää­ri­tel­ty nu­me­roik­si (number) ja funktio palauttaa tyypin number arvon. Mikä tahansa yritys käyttää tätä funktiota eri tie­to­tyy­pil­lä aiheuttaa Ty­peSc­rip­tin tun­nis­ta­maan sen virheeksi.

Va­lin­nai­nen kir­joit­ta­mi­nen

Va­lin­nai­sel­la tyy­pi­tyk­sel­lä voit määrittää tie­to­tyy­pit tietyille muut­tu­jil­le ja pa­ra­met­reil­le, mutta jättää toiset ilman mää­ri­tel­tyä tie­to­tyyp­piä.

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

Toiminto sayHello mää­ri­tel­lään pa­ra­met­reil­la name ja age. Merkintä any osoittaa, että parametri age voi olla mikä tahansa tie­to­tyyp­pi.

ES6+ -omi­nai­suu­det

Ty­peSc­ript tukee moderneja Ja­vaSc­ript-omi­nai­suuk­sia, mukaan lukien ES6 ja uudemmat omi­nai­suu­det, kuten nuo­li­päät­tei­set funktiot ja mal­li­merk­ki­jo­not.

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

Nuo­li­pai­nik­keet johtavat ly­hyem­pään ja tii­viim­pään syn­tak­siin.

Koodin or­ga­ni­soin­ti

Ty­peSc­ript tarjoaa paremman koodin or­ga­ni­soin­nin ja varmistaa, että koodi on jaettu uudelleen käy­tet­tä­viin osiin. Tämä on mah­dol­lis­ta moduulien ja ni­mi­ti­lo­jen ansiosta.

// 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

Tässä näytämme, kuinka koodi voidaan jäsentää mo­duu­leil­la ja kuinka import ja export voidaan hyödyntää or­ga­ni­soin­nis­sa. Li­säys­toi­min­to on mää­ri­tel­ty eril­li­ses­sä mo­duu­lis­sa nimeltä Math.ts, ja se on sitten tuotu ja in­tegroi­tu toiseen moduuliin, Main.ts.

Olio-oh­jel­moin­ti (OOP)

Ty­peSc­ript helpottaa olio-oh­jel­moin­tia Ty­peSc­ript-luokkien, ra­ja­pin­to­jen ja perinnön avulla:

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

Tämä esimerkki osoittaa luokkien ja olio-oh­jel­moin­nin (OOP) käytön Ty­peSc­rip­tis­sä. Luokalla Person on omi­nai­suu­det name, age ja metodi greet, jota käytetään henkilön esit­te­le­mi­seen ja hänestä tietojen an­ta­mi­seen.

Laa­jen­net­tu tyyp­pi­jär­jes­tel­mä

Ty­peSc­ript-tyyp­pi­jär­jes­tel­mä on joustava ja kattava. Voit luoda käyttäjän mää­rit­tä­miä tyyppejä ja ra­ja­pin­to­ja ja jopa laajentaa olemassa olevia tyyppejä.

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

Rajapinta Animal mää­rit­te­lee omi­nai­suu­den name, kun taas rajapinta Dog perii omi­nai­suu­den Animal ja lisää siihen uuden omi­nai­suu­den breed. Objekti myDog sisältää molempien ra­ja­pin­to­jen omi­nai­suu­det.

Yh­teen­so­pi­vuus Ja­vaSc­rip­tin kanssa

Ty­peSc­ript on yh­teen­so­pi­va Ja­vaSc­rip­tin kanssa, joten se toimii missä tahansa Ja­vaSc­ript-ym­pä­ris­tös­sä. Tämän yh­teen­so­pi­vuu­den ansiosta Ty­peSc­rip­tia on helpompi si­säl­lyt­tää as­teit­tain nykyisiin Ja­vaSc­ript-pro­jek­tei­hin.

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

Yllä oleva Ja­vaSc­ript-koodi (ilman tyy­pi­tys­tä) voidaan käyttää Ty­peSc­ript-koodissa (tyy­pi­tyk­sel­lä) ilman ongelmia.

Mitkä ovat Ty­peSc­rip­tin edut ja haitat?

Vaikka Ty­peSc­ript tarjoaa useita etuja, sillä on myös joitakin haittoja. Tässä on yleis­kat­saus:

Edut

Ty­peSc­rip­til­la on laaja tyyp­pi­mää­rit­te­ly­jen eko­sys­tee­mi monille Ja­vaSc­ript-kir­jas­toil­le ja -ke­hyk­sil­le. Tämä tekee kolmannen osapuolen koodin in­tegroi­mi­ses­ta Ty­peSc­ript-pro­jek­tei­hin sau­ma­ton­ta ja suo­ra­vii­vais­ta. Tämä on hyö­dyl­lis­tä ny­ky­päi­vän verk­ko­poh­jai­sis­sa so­vel­luk­sis­sa, jotka usein pe­rus­tu­vat useisiin kir­jas­toi­hin ja kehyksiin.

Staat­ti­sen tyy­pi­tyk­sen lisäksi Ty­peSc­ript tarjoaa runsaasti ke­hi­ty­so­mi­nai­suuk­sia, kuten ra­ja­pin­nat, luokat, moduulit ja tuen ny­kyi­sil­le EC­MASc­ript-stan­dar­deil­le. Nämä omi­nai­suu­det pa­ran­ta­vat koodin ra­ken­net­ta, hel­pot­ta­vat pro­jek­tien yl­lä­pi­det­tä­vyyt­tä ja skaa­lau­tu­vuut­ta sekä edistävät ke­hi­tys­työn tuot­ta­vuut­ta. Monet in­tegroi­dut ke­hi­ty­sym­pä­ris­töt (IDE), kuten Visual Studio Code, tarjoavat erin­omai­sen tuen Ty­peSc­rip­til­le.

Haitat

Ty­peSc­rip­tiin totuttelu vie aikaa, etenkin ke­hit­tä­jil­le, jotka ovat ennen sitä työs­ken­nel­leet vain Ja­vaSc­rip­tin parissa. Ty­peSc­ript-koodi on kään­net­tä­vä Ja­vaSc­rip­tik­si, ennen kuin se voidaan suorittaa se­lai­mis­sa tai Node.js-ym­pä­ris­töis­sä. Tämä lisää yhden vaiheen ke­hi­tys­työ­hön.

Pie­nem­mis­sä pro­jek­teis­sa Ty­peSc­ript voi tuntua liian mo­ni­mut­kai­sel­ta, koska tyyp­pi­tur­val­li­suu­den edut eivät vält­tä­mät­tä ole niin ilmeisiä. Ty­peSc­ript-projektit voivat vaatia enemmän re­surs­se­ja li­sä­tyyp­pi­tie­to­jen ja kom­pi­loin­nin vaiheiden vuoksi.

Mitkä ovat Ty­peSc­rip­tin vaih­toeh­to­ja?

On olemassa useita web-oh­jel­moin­ti­kie­liä, jotka voivat olla hyvä vaih­toeh­to Ty­peSc­rip­til­le riippuen projektin eri­tyis­vaa­ti­muk­sis­ta ja ke­hit­tä­jän tai ke­hit­tä­jien miel­ty­myk­sis­tä.

  • Flow: Flow on Face­boo­kin kehittämä staat­ti­nen tyyp­pi­tar­kis­ta­ja Ja­vaSc­rip­til­le. Sen avulla voit lisätä tyyppejä Ja­vaSc­ript-koodiin ilman, että sinun tarvitsee siirtyä kokonaan Ty­peSc­rip­tiin. Flow on hyvä valinta, jos haluat in­tegroi­da tyy­pi­tyk­sen Ja­vaSc­ript-pro­jek­tei­hi­si as­teit­tain.
  • Dart: tämä on Googlen kehittämä oh­jel­moin­ti­kie­li, jota voidaan käyttää verk­ko­so­vel­lus­ten ja mo­bii­li­so­vel­lus­ten luomiseen. Se tarjoaa tyyp­pi­tur­val­li­suu­den ja hyvän suo­ri­tus­ky­vyn. Dartia käytetään usein yhdessä Flutter-kehyksen kanssa mo­bii­li­so­vel­lus­ten ke­hit­tä­mi­ses­sä.
  • Pu­reSc­ript: Pu­reSc­ript on vahvasti tyy­pi­tet­ty funk­tio­naa­li­nen oh­jel­moin­ti­kie­li, joka sisältää vahvan tyyp­pi­tur­val­li­suu­den ja puhtaasti funk­tio­naa­li­sen oh­jel­moin­ti­tyy­lin. Se mah­dol­lis­taa Ja­vaSc­ript-kir­jas­to­jen tuomisen.
  • Elm: Elm on funk­tio­naa­li­nen, vahvasti tyy­pi­tet­ty kieli, joka on suun­ni­tel­tu verk­ko­so­vel­lus­ten ke­hit­tä­mi­seen. Elm edistää Elm-ark­ki­teh­tuu­rin pe­ri­aa­tet­ta ja tarjoaa korkean tyyp­pi­tur­val­li­suu­den.
  • ReasonML (BuckleSc­ript): tämä kieli on kehitetty Face­boo­kis­sa ja perustuu OCaml-kieliin. BuckleSc­ript on kääntäjä, joka kääntää ReasonML:n Ja­vaSc­rip­tik­si. Se mah­dol­lis­taa myös tyyp­pi­tur­val­li­suu­den ja on helppo in­tegroi­da Reactiin frontend-kehitystä varten.
Vinkki

Sy­ven­näm­me muita aiheita, kuten Ty­peSc­ript-funktiot ja Ty­peSc­ript-taulukot, muissa ar­tik­ke­leis­sa di­gi­taa­li­ses­sa op­paas­sam­me.

998b2a2a674f9d40ad57cab09e239efe

Siirry pää­va­lik­koon