Dart vs Swift: vertailu

Dart-logo on lisensoitu Creative Commons Attribution 3.0 Unported -lisenssillä.

Dart ja Swift ovat kaksi suosikkiohjelmointikieltäni. Olen käyttänyt niitä laajasti kaupallisissa ja avoimen lähdekoodin koodeissa.

Tämä artikkeli tarjoaa vertailun Dartin ja Swiftin välillä, ja sen tavoitteena on:

  • Korosta näiden kahden erot.
  • Ole referenssi kehittäjille, jotka siirtyvät kieleltä toiselle (tai käyttävät molempia).

Jotkut asiayhteydet:

  • Dart käyttää Flutteria, Googlen kehystä rakentaa kauniita natiivisovelluksia yhdestä koodipohjasta.
  • Swift käyttää Applen SDK-tiedostoja iOS-, macOS-, tvOS- ja watchOS-järjestelmissä.

Seuraava vertailu tehdään kummankin kielen pääominaisuuksista (Dart 2.1 ja Swift 4.2). Koska kunkin ominaisuuden perusteellinen keskustelu ei kuulu tämän artikkelin piiriin, sisällyyn tarvittaessa viitteitä lisälukemiseen.

Sisällysluettelo

  • Vertailu Taulukko
  • muuttujat
  • Kirjoita päätelmä
  • Muutettavat / muuttumattomat muuttujat
  • tehtävät
  • Nimetyt ja nimeämättömät parametrit
  • Valinnaiset ja oletusparametrit
  • sulkemiset
  • tuples
  • Säätövirtaus
  • Kokoelmat (taulukot, sarjat, kartat)
  • Nollability & Optional
  • Luokat
  • perintö
  • ominaisuudet
  • Protokollat ​​/ Tiivistelmäluokat
  • Mixins
  • laajennukset
  • enums
  • structs
  • Virheiden käsittely
  • Generics
  • Kulunvalvonta
  • Asynkroninen ohjelmointi: Tulevaisuudet
  • Asynkroninen ohjelmointi: virrat
  • Muistin hallinta
  • Kokoonpano ja toteutus
  • Muut ominaisuudet eivät kuulu
  • Suosikki Swift-ominaisuuksiani puuttuvat Dartilta
  • Suosikki tikkaominaisuuksistani puuttuu Swift
  • johtopäätös
  • Viitteet ja hyvitykset

Vertailu Taulukko

muuttujat

Muuttuvan ilmoituksen syntaksi näyttää tältä Dart:

Merkkijono nimi;
int ikä;
kaksinkertainen korkeus;

Ja näin Swiftissä:

var nimi: merkkijono
ikä: Int
var korkeus: Tupla

Muuttuva alustus näyttää tältä Dart:

var nimi = 'Andrea';
var ikä = 34;
var korkeus = 1,84;

Ja näin Swiftissä:

var name = "Andrea"
var ikä = 34
var korkeus = 1,84

Tässä esimerkissä tyyppihuomautuksia ei tarvita. Tämä johtuu siitä, että molemmat kielet voivat päätellä tyyppejä tehtävän oikealla puolella olevasta lausekkeesta.

Siitä puhuen…

Kirjoita päätelmä

Tyyppi päättely tarkoittaa, että voimme kirjoittaa seuraavat Dart:

var argumentit = {'argA': 'hello', 'argB': 42}; // Kartta 

Ja kääntäjä ratkaisee argumenttityypin automaattisesti.

Swift-versiossa voidaan kirjoittaa sama kuin:

var argument = = "" argA ":" hello "," argB ": 42] // [merkkijono: mikä tahansa]

Jotkut lisätiedot

Dart-dokumentin lainaaminen:

Analysaattori voi päätellä tyyppejä kenttiä, menetelmiä, paikallisia muuttujia ja yleisimpiä tyyppiargumentteja varten. Kun analysaattorilla ei ole tarpeeksi tietoa päätellä tiettyä tyyppiä, se käyttää dynaamista tyyppiä.

Ja Swift:

Swift käyttää tyypin päättelyä laajasti, jolloin voit jättää pois koodin monien muuttujien ja lausekkeiden tyypin tai osan tyypistä. Esimerkiksi, var x: n kirjoittamisen sijasta: Int = 0, voit kirjoittaa var x = 0, jättämättä tyyppi kokonaan pois - kääntäjä päättelee oikein, että x nimittää tyypin Int arvon.

Dynaamiset tyypit

Muuttuja, joka voi olla mitä tahansa tyyppiä, ilmoitetaan dynaamisella avainsanalla Dart-muodossa ja millä tahansa avainsanalla Swift-muodossa.

Dynaamisia tyyppejä käytetään yleisesti luettaessa tietoja, kuten JSON.

Muutettavat / muuttumattomat muuttujat

Muuttujat voidaan julistaa muuttuviksi tai muuttumattomiksi.

Muuttuvien muuttujien ilmoittamiseksi molemmat kielet käyttävät var-avainsanaa.

var a = 10; // int (tikka)
a = 20; // ok
var a = 10 // Int (Swift)
a = 20 // ok

Dart käyttää lopullista ja Swift laskee muuttumattomia muuttujia.

lopullinen a = 10;
a = 20; // 'a': lopullinen muuttuja, voidaan asettaa vain kerran.
olkoon a = 10
a = 20 // arvoa ei voida antaa: 'a' on 'anna' vakio

Huomaa: Dart-dokumentaatio määrittelee kaksi avainsanaa, lopullisen ja constin, jotka toimivat seuraavasti:

Jos et koskaan aio muuttaa muuttujaa, käytä lopullista tai constia joko varin sijasta tai tyypin lisäksi. Lopullinen muuttuja voidaan asettaa vain kerran; const-muuttuja on käännösaikavakio. (Const-muuttujat ovat epäsuorasti lopulliset.) Lopullinen ylimmän tason tai luokan muuttuja alustetaan ensimmäisen kerran, kun sitä käytetään.

Lisäselvityksiä löytyy Dart-verkkosivuston tästä viestistä:

lopullinen tarkoittaa yhden tehtävän suorittamista. Viimeisellä muuttujalla tai kentällä on oltava alustaja. Kun lopullinen muuttujan arvo on määritetty, sitä ei voida muuttaa. lopullinen muuttaa muuttujia.

TL; DR: Käytä loppua määritelläksesi muuttumattomat muuttujat Dart-muodossa.

Swiftissa julistamme vakioita let: llä. lainaten:

Vakioilmoitus tuo vakiona nimetyn arvon ohjelmaan. Vakioilmoitukset ilmoitetaan käyttämällä avainsanaa, ja niiden muoto on seuraava:
anna vakio nimi: type = lauseke
Vakioilmoitus määrittelee muuttumattoman sidoksen vakionimen ja alustuslausekkeen arvon välillä; sen jälkeen kun vakion arvo on asetettu, sitä ei voi muuttaa.

Lue lisää: Swift-ilmoitukset.

tehtävät

Toiminnot ovat Swift- ja Dart-luokan ensimmäisen luokan kansalaisia.

Tämä tarkoittaa, että kuten objektitkin, funktiot voidaan siirtää argumentteina, tallentaa ominaisuuksiksi tai palauttaa seurauksena.

Alkuvertailuna voimme nähdä, kuinka ilmoittaa toiminnot, jotka eivät ota argumentteja käyttöön.

Dart-versiossa paluutapa edeltää menetelmän nimeä:

tyhjä foo ();
int bar ();

Swiftissä käytämme -> T-merkintää jälkiliitteenä. Tätä ei tarvita, jos palautusarvoa ei ole (Void):

func foo ()
func bar () -> Int

Lue lisää:

  • Dart-toiminnot
  • Swift-toiminnot

Nimetyt ja nimeämättömät parametrit

Molemmat kielet tukevat nimettyjä ja un-nimettyjä parametreja.

Swift-sovelluksessa parametrit nimetään oletuksena:

func foo (nimi: kieli, ikä: keski, korkeus: tupla)
foo (nimi: "Andrea", ikä: 34, korkeus: 1,84)

Dart-ohjelmassa määrittelemme nimetyt parametrit kiharatuilla ({}):

void foo ({merkkijonon nimi, int ikä, kaksinkertainen korkeus});
foo (nimi: 'Andrea', ikä: 34, korkeus: 1,84);

Swift määrittelee nimeämättömät parametrit käyttämällä alaviivaa (_) ulkoisena parametrina:

func foo (_ nimi: merkkijono, _ ikä: keskinäinen, _ korkeus: tupla)
foo ("Andrea", 34, 1.84)

Dart-ohjelmassa määrittelemme nimeämättömät parametrit jättämällä kiharanauhat ({}):

tyhjä foo (merkkijonon nimi, int ikä, kaksinkertainen korkeus);
foo ('Andrea', 34, 1,84);

Lue lisää: Toimintoperustemerkinnät ja parametrien nimet Swift-muodossa.

Valinnaiset ja oletusparametrit

Molemmat kielet tukevat oletusparametreja.

Swift-sovelluksessa voit määrittää oletusarvon mille tahansa toiminnon parametrille määrittämällä arvo parametrille parametrityypin jälkeen. Jos oletusarvo on määritetty, voit jättää sen pois, kun kutsut toimintoa.
func foo (nimi: merkkijono, ikä: int = 0, korkeus: tupla = 0,0)
foo (nimi: "Andrea", ikä: 34) // nimi: "Andrea", ikä: 34, korkeus: 0.0

Lue lisää: Parametrien oletusarvot Swiftissä.

Dart-sovelluksessa valinnaiset parametrit voivat olla joko sijainti- tai nimettyjä, mutta eivät molemmat.

// valinnaiset sijaintiparametrit
tyhjä foo (merkkijonon nimi, [keski-ikä = 0, kaksinkertainen korkeus = 0,0]);
foo ('Andrea', 34); // nimi: 'Andrea', ikä: 34, korkeus: 0.0
// nimeltään valinnaiset parametrit
tyhjä foo ({merkkijonon nimi, int ikä = 0, kaksinkertainen korkeus = 0,0});
foo (nimi: 'Andrea', ikä: 34); // nimi: 'Andrea', ikä: 34, korkeus: 0.0

Lue lisää: Valinnaiset parametrit Dart-kappaleessa.

sulkemiset

Ensiluokkaisina objekteina funktiot voidaan siirtää argumentteina muille funktioille tai osoittaa muuttujille.

Tässä yhteydessä toimintoja kutsutaan myös sulkemisiksi.

Tässä on Dart-esimerkki toiminnosta, joka iteroi esineiden luettelon kohdalla käyttämällä tulostinta tulostamalla kunkin kohteen hakemisto ja sisältö:

lopullinen luettelo = ['omenat', 'banaanit', 'appelsiinit'];
list.forEach ((item) => print ('$ {list.indexOf (item)}: $ item'));

Sulkeminen vie yhden argumentin (kohteen), tulostaa kohteen indeksin ja arvon, eikä palauta arvoa.

Huomaa nuolimerkinnän (=>) käyttö. Tätä voidaan käyttää yhden palautuslausunnon sijasta kiharanauhojen sisällä:

list.forEach ((tuote) {tulosta ('$ {list.indexOf (item)}: $ item');});

Sama koodi Swiftissä näyttää tältä:

let list = ["omenat", "banaanit", "appelsiinit"]
list.forEach ({print ("\ (merkkijono (kuvaa: list.firstIndex (of: 0 dollaria)))) \ ($ 0)")}))

Tässä tapauksessa emme määrittele nimeä sulkemiselle siirretylle argumentille ja tarkoitamme ensimmäisen väitteen sijasta 0 dollaria. Tämä on täysin vapaaehtoista, ja voimme käyttää nimettyä parametria, jos haluamme:

list.forEach ({tuote painettuna ("\ (merkkijono (kuvaa: list.firstIndex (of: item)))) \ (item)")})

Sulkemisia käytetään usein asynkronisen koodin viimeistelylohkoina Swiftissä (katso asynkronisen ohjelmoinnin alla oleva kappale).

Lue lisää:

  • Dart anonyymit toiminnot
  • Nopeat sulkemiset

tuples

Swift Docsista:

Tuples ryhmittelee useita arvoja yhdeksi yhdistearvoksi. Ryhmän arvot voivat olla mitä tahansa tyyppiä, ja niiden ei tarvitse olla samantyyppisiä kuin toiset.

Niitä voidaan käyttää pieninä kevyinä tyypeinä ja ne ovat hyödyllisiä määriteltäessä toimintoja, joilla on useita paluuarvoja.

Näin voit käyttää tuppeja Swiftissä:

olkoon t = ("Andrea", 34, 1,84)
tulosta (t.0) // tulostaa "Andrea"
tulosta (t.1) // tulostaa 34
tulosta (t.2) // tulostaa 1.84

Tupleja tuetaan erillisellä paketilla Dart:

const t = const Tuple3  ('Andrea', 34, 1,84);
tulosta (t.item1); // tulostaa 'Andrea'
tulosta (t.item2); // tulostaa 34
tulosta (t.item3); // tulostaa 1,84

Säätövirtaus

Molemmat kielet tarjoavat erilaisia ​​ohjausvirtalausekkeita.

Esimerkkejä tästä on, jos ehdolliset vaihtavat lausekkeita silmukoiden aikana ja silmukkien aikana.

Näiden kattaminen täällä olisi melko kauan, joten viittaan virallisiin asiakirjoihin:

  • Nopea ohjausvirta
  • Dart Control -virtauslaskelmat

Kokoelmat (taulukot, sarjat, kartat)

Ryhmät / luettelot

Taulukot ovat tilattuja objektiryhmiä.

Taulukot voidaan luoda Dart-luetteloina:

var tyhjäLista =  []; // tyhjä luettelo
var-luettelo = [1, 2, 3]; // kirjaimellinen luettelo
list.length; // 3
lista [1]; // 2

Ryhmillä on sisäänrakennettu tyyppi Swiftissä:

var emptyArray = [Int] () // tyhjä taulukko
var array = [1, 2, 3] // taulukon kirjaimellinen
array.count // 3
taulukko [1] // 2

sarjat

Lainaa Swift-dokumentteja:

Sarja tallentaa samantyyppiset erilliset arvot kokoelmaan ilman määriteltyä tilausta. Voit käyttää joukkoa taulukon sijasta, kun esineiden järjestys ei ole tärkeä tai kun sinun on varmistettava, että kohde näkyy vain kerran.

Tämä määritetään Dart-sarjan Set-luokalla.

var tyhjäFruits =  {}; // tyhjä asetettu kirjaimellinen
var hedelmät = {'omena', 'banaani'}; // aseta kirjaimellinen

Samoin Swiftissä:

var emptyFruits = Aseta  ()
var hedelmät = Aseta  (["omena", "banaani"])

Kartat / Sanakirjat

Swift-dokumenteilla on hyvä määritelmä kartalle / sanakirjalle:

Sanakirja tallentaa yhdistelmät samantyyppisten avainten ja samantyyppisten arvojen välillä kokoelmassa ilman määriteltyä järjestystä. Jokainen arvo liittyy yksilöivään avaimeen, joka toimii tunnisteena kyseiselle arvolle sanakirjassa.

Kartat on määritelty kuten Dart-versiossa:

var namesOfIntegers = Kartta  (); // tyhjä kartta
var lentokentät = {'YYZ': 'Toronto Pearson', 'DUB': 'Dublin'}; // kirjaimellinen kartta

Karttoja kutsutaan sanakirjoiksi Swiftissä:

var namesOfIntegers = [Int: String] () // tyhjä sanakirja
var airport = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] // sanakirja kirjallinen

Lue lisää:

  • Dart-kokoelmat
  • Swift-kokoelmat (suosittelen erityisesti sarjaa).

Nollability & Optional

Dart-tilassa mikä tahansa esine voi olla tyhjä. Ja yritettäessä käyttää menetelmiä tai muuttujia nollaobjekteista saadaan nollaosoittimen poikkeus. Tämä on tietokoneohjelmien yleisin virheiden lähde (jos ei tavallisin).

Alusta lähtien Swiftilla oli valinnaisia ​​lisävarusteita, sisäänrakennettu kieliominaisuus ilmoittamaan, onko objekteilla arvo vai ei. Asiakirjojen lainaaminen:

Käytät lisävarusteita tilanteissa, joissa arvo saattaa puuttua. Valinnainen edustaa kahta mahdollisuutta: Joko arvo on olemassa, ja voit purkaa valinnaisen käyttääksesi tätä arvoa, tai arvoa ei ole ollenkaan.

Toisin kuin tämä, voimme käyttää ei-valinnaisia ​​muuttujia varmistaaksemme, että niillä on aina arvo:

var x: Int? // valinnainen
var y: Int = 1 // ei-valinnainen, on alustettava

Huomaa: sanonta, että Swift-muuttuja on valinnainen, on suunnilleen sama kuin väite, että Dart-muuttuja voi olla nolla.

Ilman valinnaisten kielitason tukea voimme tarkistaa suorituksen aikana vain, jos muuttuja on nolla.

Valinnaisilla lisäyksillä koodaamme nämä tiedot kokoamisaikana. Voimme purkaa valinnaisen valinnan tarkistaaksesi turvallisesti, onko niillä arvo:

func showValinnainen (x: Int?) {
  // Käytä "vartija anna" sijaan "jos antaa" parhaaksi käytännöksi
  jos anna x = x {// kääriä valinnainen
    print (x)
  } muuta {
    tulosta ("ei arvoa")
  }
}
showOptional (x: nolla) // tulostaa "ei arvoa"
showOptional (x: 5) // tulostaa "5"

Ja jos tiedämme, että muuttujalla on oltava arvo, voimme käyttää ei-valinnaista:

func showNonOptional (x: Int) {
  print (x)
}
showNonOptional (x: nolla) // [käännösvirhe] nolla ei ole yhteensopiva odotettavissa olevan argumenttityypin 'Int' kanssa
showNonOptional (x: 5) // tulostaa "5"

Ensimmäinen yllä oleva esimerkki voidaan toteuttaa tällä tavalla Dart:

tyhjä showValinnainen (int x) {
  if (x! = nolla) {
    tulosta (x);
  } muuta {
    tulosta ('ei arvoa');
  }
}
showOptional (null) // tulostaa "ei arvoa"
showOptional (5) // tulostaa "5"

Ja toinen tällainen:

tyhjä showNonOptio (int x) {
  väittä (x! = nolla);
  tulosta (x);
}
showNonOptional (null) // [ajonaikainen virhe] Ei pyydetty poikkeus: Vahvistus epäonnistui
showNonOptional (5) // tulostaa "5"

Lisävarusteiden käyttäminen tarkoittaa, että voimme saada salaisuuksia virheitä kokoamisaikana kuin käyttöaikana. Ja virheiden havaitseminen aikaisin johtaa turvallisempaan koodiin, jossa on vähemmän virheitä.

Dartin puute valinnaisille ei jotenkin lieventä väitteiden käyttöä (ja nimettyjen parametrien @ vaadittu merkintä).

Näitä käytetään laajasti Flutter SDK: ssa, mutta niiden tuloksena on lisäkattilakoodi.

Tietueelle on ehdotus ei-nollaamattomien tyyppien lisäämisestä Dartiin.

Valinnaisista on paljon enemmän kuin olen käsitellyt täällä. Katso hyvä katsaus: Vaihtoehdot Swiftissä.

Luokat

Luokat ovat tärkein rakennuspalikka ohjelmien kirjoittamiselle olosuhteisiin suuntautuneilla kielillä.

Dart ja Swift tukevat luokkia, joillakin eroilla.

Syntaksi

Tässä on luokka, jossa on alustaja ja kolme jäsenmuuttujaa Swiftissä:

luokan henkilö {
  anna nimi: String
  anna ikä: Int
  anna korkeus: Tupla
  init (nimi: merkkijono, ikä: keskikoko, korkeus: kaksinkertainen) {
    oma.nimi = nimi
    omakuva = ikä
    itse.korkeus = korkeus
  }
}

Ja sama Dart:

luokan henkilö {
  Henkilö ({tämä.nimi, tämä.age, tämä.korkeus});
  lopullinen merkkijono;
  lopullinen int ikä;
  lopullinen kaksinkertainen korkeus;
}

Huomaa tämän. [PropertyName] käyttö Dart-konstruktorissa. Tämä on syntaktinen sokeri, jolla voidaan asettaa ilmentymän jäsenmuuttujat ennen rakentajan suorittamista.

Tehtaanrakentajat

Dart-ohjelmassa on mahdollista luoda tehdasrakentajia. lainaten:

Käytä tehtaan avainsanaa toteuttaessasi rakentajaa, joka ei aina luo luokkaansa uutta esiintymää.

Yksi tehdasrakentajien käytännön käyttötapa on malliluokan luominen JSON: sta:

luokan henkilö {
  Henkilö ({tämä.nimi, tämä.age, tämä.korkeus});
  lopullinen merkkijono;
  lopullinen int ikä;
  lopullinen kaksinkertainen korkeus;
  tehdas Person.fromJSON (Kartta  json) {
    Merkkijono = json ['nimi'];
    int ikä = json ['ikä'];
    kaksinkertainen korkeus = json ['korkeus'];
    paluuhenkilö (nimi: nimi, ikä: ikä, korkeus: korkeus);
  }
}
var p = Henkilö.JOS ({
  'nimi': 'Andrea',
  'ikä': 34,
  'korkeus': 1,84,
});

Lue lisää:

  • Dart-luokat
  • Nopeat rakenteet ja luokat

perintö

Swift käyttää yhden perinnön mallia, mikä tarkoittaa, että millä tahansa luokalla voi olla vain yksi superluokka. Swift-luokat voivat toteuttaa useita rajapintoja (tunnetaan myös protokollina).

Tikanluokilla on miksiinipohjainen perintö. Asiakirjojen lainaaminen:

Jokainen objekti on luokan esimerkki ja kaikki luokat laskeutuvat objektista. Mixin-pohjainen perimä tarkoittaa, että vaikka jokaisella luokalla (paitsi Object) on tarkalleen yksi superluokka, luokkaosaa voidaan käyttää uudelleen useissa luokkahierarkioissa.

Tässä on yksi perintö toiminnassa Swiftissä:

luokan ajoneuvo {
  anna wheelCount: Int
  init (wheelCount: Int) {
    self.wheelCount = wheelCount
  }
}
luokan polkupyörä: Ajoneuvo {
  sen sisällä() {
    super.init (wheelCount: 2)
  }
}

Ja Dart:

luokan ajoneuvo {
  Ajoneuvon ({this.wheelCount});
  lopullinen int pyörälukema;
}
luokan polkupyörä laajentaa ajoneuvoa {
  Polkupyörä (): super (pyörämäärä: 2);
}

ominaisuudet

Näitä kutsutaan Dart-ilmentymän muuttujiksi ja yksinkertaisesti ominaisuuksia Swiftissä.

Swift-ohjelmassa on ero tallennettujen ja laskettujen ominaisuuksien välillä:

luokan ympyrä {
  init (säde: Tupla) {
    oma.radius = säde
  }
  anna säde: Tuplaa // tallennettu ominaisuus
  var halkaisija: Tupla {// vain luku -laskettu ominaisuus
    paluu säde * 2.0
  }
}

Dart-tapauksessa meillä on sama ero:

luokan ympyrä {
  Ympyrä ({this.radius});
  lopullinen kaksinkertainen säde; // tallennettu omaisuus
  kaksinkertainen läpimitta => säde * 2,0; // laskettu ominaisuus
}

Laskettujen ominaisuuksien getterien lisäksi voimme määritellä myös setterit.

Yllä olevan esimerkin avulla voimme kirjoittaa halkaisijan ominaisuuden uudelleen asettajan sisällyttämiseksi:

var halkaisija: Tupla {// laskettu ominaisuus
  saada {
    paluu säde * 2.0
  }
  asettaa {
    säde = uusi arvo / 2,0
  }
}

Dartiin voimme lisätä erillisen setterin kuten:

asetettu halkaisija (kaksinkertainen arvo) => säde = arvo / 2,0;

Kiinteistövälittäjät

Tämä on Swiftin erikoinen piirre. lainaten:

Kiinteistön tarkkailijat tarkkailevat kiinteistön arvon muutoksia ja vastaavat niihin. Kiinteistön tarkkailijoita kutsutaan joka kerta, kun kiinteistön arvo asetetaan, vaikka uusi arvo olisi sama kuin kiinteistön nykyinen arvo.

Niitä voidaan käyttää seuraavasti:

var halkaisija: Tupla {// vain luku -laskettu ominaisuus
  willSet (newDiameter) {
    tulosta ("vanha arvo: \ (halkaisija), uusi arvo: \ (uusi halkaisija)")
  }
  didSet {
    tulosta ("vanha arvo: \ (vanha arvo), uusi arvo: \ (halkaisija)")
  }
}

Lue lisää:

  • Dart-muuttujat, getterit ja setterit
  • Swift Ominaisuudet

Protokollat ​​/ Tiivistelmäluokat

Tässä puhutaan rakenteesta, jota käytetään menetelmien ja ominaisuuksien määrittelemiseen määrittelemättä niiden toteutustapaa. Tätä kutsutaan käyttöliittymäksi muilla kielillä.

Swift-sovelluksessa rajapintoja kutsutaan protokolliksi.

protokollamuoto {
  func-alue () -> kaksinkertainen
}
luokan aukio: muoto {
  anna puoli: Tupla
  init (puoli: tupla) {
    itse.puolella = puoli
  }
  func-alue () -> tupla {
    takaosa * puoli
  }
}

Dartilla on samanlainen rakenne, joka tunnetaan nimellä abstrakti luokka. Abstraktit luokat eivät voi hetkellistyä. He voivat kuitenkin määritellä menetelmiä, joilla on toteutustapa.

Yllä oleva esimerkki voidaan kirjoittaa tällä tavalla Dart:

abstrakti luokan muoto {
  kaksinkertainen alue ();
}
luokan aukio laajentaa muotoa {
  Neliö ({this.side});
  lopullinen kaksipuolinen puoli;
  kaksinkertainen alue () => puoli * puoli;
}

Lue lisää:

  • Swift-pöytäkirjat
  • Dart Abstraktit luokat

Mixins

Dartissa mixin on vain tavallinen luokka, jota voidaan käyttää uudelleen useissa luokkahierarkioissa.

Näin voimme pidentää aiemmin määrittelemämme Henkilöluokan NameExtension-sekoituksella:

abstrakti luokka NameExtension {
  Merkkijono saada nimi;
  Merkkijono get iso kirjainNimi => nimi.toUpperCase ();
  Merkkijono get smallcaseName => name.toLowerCase ();
}
luokan henkilö, jolla on NameExtension {
  Henkilö ({tämä.nimi, tämä.age, tämä.korkeus});
  lopullinen merkkijono;
  lopullinen int ikä;
  lopullinen kaksinkertainen korkeus;
}
var henkilö = henkilö (nimi: 'Andrea', ikä: 34, korkeus: 1,84);
tulosta (person.uppercaseName); // 'ANDREA'

Lue lisää: Dart Mixins

laajennukset

Laajennukset ovat Swift-kielen ominaisuus. Asiakirjojen lainaaminen:

Laajennukset lisäävät uusia toimintoja olemassa olevaan luokkaan, rakenteeseen, luetteloon tai protokollatyyppiin. Tähän sisältyy kyky laajentaa tyyppejä, joille sinulla ei ole pääsyä alkuperäiseen lähdekoodiin (tunnetaan takautuvana mallinnuksena).

Tämä ei ole mahdollista Dart-sekoituksissa.

Lainaamalla yllä olevaa esimerkkiä, voimme pidentää Henkilöluokkaa seuraavasti:

jatkohenkilö {
  var uppercaseName: merkkijono {
    paluunimi.supertasoitettu ()
  }
  var smallcaseName: merkkijono {
    paluunimi.loukutettu ()
  }
}
var henkilö = Henkilö (nimi: "Andrea", ikä: 34, korkeus: 1,84)
print (person.uppercaseName) // "ANDREA"

Laajennuksia on paljon enemmän kuin olen esittänyt täällä, varsinkin kun niitä käytetään yhdessä protokollien ja geneeristen lääkkeiden kanssa.

Yksi yleinen laajennusten käyttötapa on protokollan vaatimustenmukaisuuden lisääminen olemassa oleviin tyyppeihin. Voimme esimerkiksi käyttää laajennusta lisätäksesi sarjoittamisominaisuuksia olemassa olevaan malliluokkaan.

Lue lisää: Swift-laajennukset

enums

Dartilla on joitain hyvin perustietoja enumeista.

Swiftin enumit ovat erittäin voimakkaita, koska ne tukevat niihin liittyviä tyyppejä:

enum NetworkResponse {
  tapauksen onnistuminen (kappale: Data)
  tapausvirhe (virhe: virhe)
}

Tämä mahdollistaa logiikan kirjoittamisen näin:

kytkin (vastaus) {
  tapaus .menestys (anna tiedot):
    // tee jotain (ei-valinnaisen) datan kanssa
  case .failure (anna virhe):
    // tee jotain virheellisellä (ei-valinnaisella) virheellä
}

Huomaa, kuinka data- ja virheparametrit ovat toisiaan poissulkevia.

Dart-ohjelmassa emme voi liittää lisäarvoja enumeihin, ja yllä oleva koodi voidaan toteuttaa seuraavilla linjoilla:

luokka NetworkResponse {
  NetworkResponse ({tämä.data, tämä.virhe})
  // väite tietojen ja virheiden tekemiseksi toisistaan ​​poissulkeviksi
  : vakuuttaa (data! = nolla && virhe == nolla || data == nolla && virhe! = nolla);
  lopullinen Uint8List-data;
  lopullinen merkkijonovirhe;
}
var-vastaus = NetworkResponse (tiedot: Uint8List (0), virhe: nolla);
if (response.data! = nolla) {
  // käytä tietoja
} muuta {
  // käytä virhe
}

Pari muistiinpanoa:

  • Käytämme tässä väitteitä kompensoidakseen sitä tosiasiaa, että meillä ei ole vaihtoehtoja.
  • Kääntäjä ei voi auttaa meitä tarkistamaan kaikkia mahdollisia tapauksia. Tämä johtuu siitä, että emme käytä kytkintä prosessoimaan vastausta.

Yhteenvetona voidaan todeta, että Swift-enummit ovat paljon voimakkaampia ja ilmaisullisempia kuin Dart-ohjelmassa.

Kolmannen osapuolen kirjastot, kuten Dart Sealed Unions, tarjoavat samanlaisia ​​toimintoja kuin Swift-enumien tarjoamat ja voivat auttaa täyttämään aukon.

Lue lisää: Swift Enums.

structs

Swift-ohjelmassa voimme määritellä rakenteet ja luokat.

Molemmilla rakenteilla on monia yhteisiä asioita ja joitain eroja.

Tärkein ero on, että:

Luokat ovat viitetyyppejä, ja rakenteet ovat arvotyyppejä

Asiakirjojen lainaaminen:

Arvotyyppi on tyyppi, jonka arvo kopioidaan, kun se on määritetty muuttujalle tai vakiona tai kun se on siirretty funktiolle.
Kaikki rakenteet ja luettelot ovat Swift-arvotyyppejä. Tämä tarkoittaa, että kaikki luomasi rakenteet ja luettelonähteet - ja kaikki arvotyypit, jotka niillä on ominaisuuksina - kopioidaan aina, kun ne siirretään koodiin.
Toisin kuin arvotyyppejä, viitetyyppejä ei kopioida, kun ne on määritetty muuttujalle tai vakiona tai kun ne siirretään funktiolle. Kopion sijasta käytetään viittausta samaan olemassa olevaan ilmentymään.

Katso, mitä tämä tarkoittaa, harkitse seuraavaa esimerkkiä, jossa kohdistamme Henkilöluokka uudelleen sen muuttamiseksi:

luokan henkilö {
  var nimi: merkkijono
  ikä: Int
  var korkeus: Tupla
  init (nimi: merkkijono, ikä: keskikoko, korkeus: kaksinkertainen) {
    oma.nimi = nimi
    omakuva = ikä
    itse.korkeus = korkeus
  }
}
var a = Henkilö (nimi: "Andrea", ikä: 34, korkeus: 1,84)
var b = a
b.age = 35
tulosta (a.age) // tulostaa 35

Jos määrittelemme Henkilön uudelleen rakenteeksi, meillä on tämä:

struct Person {
  var nimi: merkkijono
  ikä: Int
  var korkeus: Tupla
  init (nimi: merkkijono, ikä: keskikoko, korkeus: kaksinkertainen) {
    oma.nimi = nimi
    omakuva = ikä
    itse.korkeus = korkeus
  }
}
var a = Henkilö (nimi: "Andrea", ikä: 34, korkeus: 1,84)
var b = a
b.age = 35
tulosta (a.age) // tulostaa 34

Rakenteita on paljon enemmän kuin olen käsitellyt täällä.

Raitoja voidaan käyttää tehokkaasti käsittelemään tietoja ja malleja Swiftissä, mikä johtaa vankkaan koodiin, jossa on vähemmän virheitä.

Saat paremman yleiskuvan lukemalla: Rakenteet ja luokat Swiftissä.

Virheiden käsittely

Swift-dokumenttien määritelmän käyttäminen:

Virheiden käsittely on prosessi, jolla vastataan ohjelmaan kuuluviin virhetilanteisiin ja palautetaan niistä.

Sekä Dart että Swift käyttävät try / catch-tekniikkaa virheiden käsittelemiseen, joissakin eroissa.

Dart-menetelmässä mikä tahansa menetelmä voi heittää minkä tahansa tyyppisen poikkeuksen.

luokka Pankkitili {
  BankAccount ({this.balance});
  kaksinkertainen tasapaino;
  mitätöi nosto (kaksinkertainen summa) {
    if (määrä> saldo) {
      heittää poikkeus ('riittämättömät varat');
    }
    saldo - = määrä;
  }
}

Poikkeukset voidaan saada kiinni kokeilu- / saalislohkosta:

var tili = pankkitili (saldo: 100);
yrittää {
  account.withdraw (50); // ok
  account.withdraw (200); // heittää
} saalis (e) {
  tulosta (e); // tulostaa "Poikkeus: riittämättömät varat"
}

Swiftissa ilmoitamme nimenomaisesti, milloin menetelmä voi heittää poikkeuksen. Tämä tehdään heittää avainsanalla, ja virheiden on oltava Virheprotokollan mukaisia:

enum AccountError: Virhe {
  tapaus riittämätönrahat
}
luokka Pankkitili {
  var tasapaino: Tupla
  init (saldo: Tupla) {
    oma tasapaino = tasapaino
  }
  func nostaa (määrä: Tupla) heittää {
    jos määrä> tasapaino {
      heitä AccountError.insufficientFunds
    }
    saldo - = määrä
  }
}

Käsitteleessämme virheitä käytämme kokeilu-avainsanaa do / catch-lohkon sisällä.

var tili = pankkitili (saldo: 100)
tee {
  kokeile account.withww (määrä: 50) // ok
  kokeile account.withdraw (määrä: 200) // heittää
} kiinni AccountError.insufficientFunds {
  tulosta ("riittämättömät varat")
}

Huomaa, kuinka kokeilusana on pakollinen, kun soitetaan menetelmille, jotka voivat heittää.

Ja itse virhe on tyypillisesti kirjoitettu, joten meillä voi olla useita saalislohkoja kattamaan kaikki mahdolliset tapaukset.

Kokeile, kokeile?, Kokeile!

Swift tarjoaa vähemmän sanallisia tapoja käsitellä virheitä.

Voimme käyttää kokeilla? ilman do / catch-estoa. Ja tämä johtaa siihen, että kaikki poikkeukset jätetään huomioimatta:

var tili = pankkitili (saldo: 100)
yrittää? tili.lähteenä (määrä: 50) // ok
yrittää? tili. nostaa (määrä: 200) // epäonnistuu hiljaa

Tai jos olemme varmoja siitä, että menetelmä ei heitä, voimme käyttää kokeilua !:

var tili = pankkitili (saldo: 100)
yrittää! tili.lähteenä (määrä: 50) // ok
yrittää! tili.lähteenä (määrä: 200) // kaatuminen

Yllä oleva esimerkki aiheuttaa ohjelman kaatumisen. Siksi, kokeile! ei suositella tuotekoodissa, ja se sopii paremmin testien kirjoittamiseen.

Kaiken kaikkiaan Swiftin virheidenkäsittelyn selkeä luonne on erittäin hyödyllinen API-suunnittelussa, koska sen avulla on helppo tietää, voiko menetelmä heittää.

Samoin kokeilun käyttö menetelmäkutsuissa kiinnittää huomiota koodiin, joka voi heittää, pakottaen meidät harkitsemaan virhetapauksia.

Tässä suhteessa virheiden käsittely tuntuu turvallisemmalta ja vankeammalta kuin Dart-järjestelmässä.

Lue lisää:

  • Dart-poikkeukset
  • Swift -virheiden käsittely

Generics

Lainaa Swift-dokumentteja:

Yleisen koodin avulla voit kirjoittaa joustavia, uudelleenkäytettäviä toimintoja ja tyyppejä, jotka voivat toimia minkä tahansa tyypin kanssa, määriteltyjen vaatimusten mukaisesti. Voit kirjoittaa koodin, joka välttää päällekkäisyydet ja ilmaisee aikomuksensa selkeästi, tiivistetyllä tavalla.

Molemmat kielet tukevat geneerisiä tekniikoita.

Yksi yleisimmistä geneeristen tuotteiden käyttötapauksista on kokoelmat, kuten taulukot, sarjat ja kartat.

Ja voimme käyttää niitä määrittelemään omat tyyppimme. Näin määrittelemme yleisen pinotyypin Swiftissä:

struct Stack  {
  var items = [Element] ()
  mutaatio func push (_ esine: Elementti) {
    items.append (erä)
  }
  mutaatio func pop () -> Elementti {
    palauta items.removeLast ()
  }
}

Samoin Dartissa kirjoittaisimme:

luokan pino  {
  var items =  []
  tyhjä työntö (elementti) {
    items.add (erä)
  }
  tyhjä pop () -> Elementti {
    palauta items.removeLast ()
  }
}

Geneeriset tuotteet ovat erittäin hyödyllisiä ja tehokkaita Swiftissä, missä niitä voidaan käyttää tyyppirajoitusten ja niihin liittyvien tyyppien määrittelemiseen protokollissa.

Suosittelen lukemaan lisätietoja ohjeista:

  • Swift Generics
  • Dart Generics

Kulunvalvonta

Lainaa Swift-dokumentaatiota:

Kulunvalvonta rajoittaa pääsyä koodisi osiin muiden lähdetiedostojen ja moduulien koodista. Tämän ominaisuuden avulla voit piilottaa koodisi toteutustiedot ja määrittää ensisijaisen käyttöliittymän, jonka kautta kyseistä koodia voidaan käyttää ja käyttää.

Swiftillä on viisi käyttöoikeustasoa: avoin, julkinen, sisäinen, yksityinen tiedosto ja yksityinen.

Niitä käytetään moduulien ja lähdetiedostojen kanssa työskentelyssä. lainaten:

Moduuli on yksi koodijakaumayksikkö - kehys tai sovellus, joka on rakennettu ja toimitettu yhtenä yksikönä ja jonka voi tuoda toinen moduuli Swiftin tuontisanalla.

Avointa ja julkista pääsytasoa voidaan käyttää koodin saataville ulkopuolisten moduulien kautta.

Yksityistä ja tiedosto-yksityistä käyttöoikeustasoa voidaan käyttää koodin tekemiseen, jota ei voida käyttää sen tiedoston ulkopuolella, johon se on määritelty.

esimerkkejä:

julkinen luokka SomePublicClass {}
sisäinen luokka SomeInternalClass {}
tiedostosuojaluokka SomeFilePrivateClass {}
yksityisluokka SomePrivateClass {}

Dart-käyttöoikeustasot ovat yksinkertaisempia ja rajoittuvat julkisiin ja yksityisiin. lainaten:

Toisin kuin Java, Dartilla ei ole avainsanoja julkinen, suojattu ja yksityinen. Jos tunniste alkaa alaviivalla _, se on yksityinen kirjastoonsa.

esimerkkejä:

luokan HomePage laajentaa StatefulWidget {// public
  @ohittaa
  _HomePageState createState () => _HomePageState ();
}
luokka _HomePageState laajentaa tilaa  {...} // yksityinen

Kulunvalvonta suunniteltiin eri tavoin Dartille ja Swiftille. Ja seurauksena käyttöoikeustasot ovat hyvin erilaisia.

Lue lisää:

  • Nopea kulunvalvonta
  • Dart-kirjastot ja näkyvyys

Asynkroninen ohjelmointi: Tulevaisuudet

Asynkroninen ohjelmointi on alue, jossa tikka paistaa todella.

Tarvitaan jonkinlainen asynkroninen ohjelmointi, kun käsitellään käyttötapauksia, kuten:

  • Sisällön lataaminen verkosta
  • Puhuminen taustapalveluun
  • Suorita pitkä käynnissä olevat toimenpiteet

Näissä tapauksissa on parasta olla estämättä suorittamisen pääkierteitä, jotka voivat saada ohjelmat jäätymään.

Dart-dokumentin lainaaminen:

Asynkronisten toimintojen avulla ohjelmasi suorittaa muut työt odottaen toiminnon päättymistä. Dart käyttää tulevaisuuden objekteja (futuureja) edustamaan asynkronisten toimintojen tuloksia. Voit työskennellä futuurien kanssa käyttämällä joko asynciä ja odota tai Future API.

Katsotaan esimerkiksi, kuinka voimme käyttää asynkronista ohjelmointia:

  • todentaa käyttäjän palvelimella
  • tallenna käyttöoikeustunnus turvalliseen tallennukseen
  • hanki käyttäjäprofiilin tiedot

Dart-ohjelmassa tämä voidaan tehdä async: llä / odota yhdessä Futuurien kanssa:

Tuleva  getUserProfile (UserCredentials -tiedot) async {
  lopullinen accessToken = odota networkService.signIn (käyttöoikeustiedot);
  odota secureStorage.storeToken (accessToken, forUserCredentials: credentials);
  return odota networkService.getProfile (accessToken);
}

Swiftissä asyynille / odottamiselle ei ole tukea ja voimme saavuttaa tämän vain sulkemisilla (valmistumislohkot):

func getUserProfile (käyttöoikeustiedot: UserCredentials, valmistuminen: (_ tulos: UserProfile) -> Void) {
  networkService.signIn (käyttöoikeustiedot) {accessToken in
    secureStorage.storeToken (accessToken) {
      networkService.getProfile (accessToken, valmistuminen: valmistuminen)
    }
  }
}

Tämä johtaa ”tuomion pyramidiin” sisäkkäisten valmistuslohkojen takia. Ja virheiden käsittelystä tulee erittäin vaikeaa tässä tilanteessa.

Dart-ohjelmassa virheiden käsittely yllä olevassa koodissa tehdään yksinkertaisesti lisäämällä try / catch-lohko koodin ympärille getUserProfile-menetelmään.

Viitteenä on ehdotus lisätä asynkki / odottaa Swiftiä tulevaisuudessa. Tämä on dokumentoitu yksityiskohtaisesti täällä:

  • Async / Odota Swift-ehdotusta

Ennen kuin tämä on toteutettu, kehittäjät voivat käyttää kolmannen osapuolen kirjastoja, kuten tätä Googlen lupauskirjastoa.

Dartin osalta erinomainen dokumentaatio löytyy täältä:

  • Dart-asynkroninen ohjelmointi: tulevaisuudet

Asynkroninen ohjelmointi: virrat

Streams toteutetaan osana Dart-ydinkirjastoja, mutta ei Swiftissä.

Dart-dokumentin lainaaminen:

Virta on asynkronisten tapahtumien sarja.

Virrat ovat reaktiivisten sovellusten perusta, joissa niillä on tärkeä rooli valtionhallinnassa.

Esimerkiksi streamit ovat loistava valinta sisällön etsimiseen, jolloin uusi tulossarja lähetetään joka kerta, kun käyttäjä päivittää hakukentän tekstiä.

Streams ei sisälly Swift-ydinkirjastoihin. Kolmannen osapuolen kirjastot, kuten RxSwift, tarjoavat streamien tukea ja paljon muuta.

Virrat ovat laaja aihe, josta ei keskustella täällä.

Lue lisää: Dart-asynkroninen ohjelmointi: virrat

Muistin hallinta

Dart hallitsee muistia edistyneellä jätekeräysjärjestelmällä.

Swift hallitsee muistia automaattisen viitelaskennan (ARC) avulla.

Tämä takaa erinomaisen suorituskyvyn, koska muisti vapautetaan heti, kun sitä ei enää käytetä.

Se kuitenkin siirtää taakan osittain kääntäjästä kehittäjälle.

Swiftissä meidän on mietittävä esineiden elinkaaria ja omistamista ja käytettävä asianmukaisia ​​avainsanoja (heikko, vahva, tuntematon) oikein välttääksesi jaksot.

Lue lisää: Automaattinen Viitelaskenta.

Kokoonpano ja toteutus

Ensinnäkin, tärkeä erotus juuri oikeaan aikaan (JIT) ja ennen aikaa (AOT) kääntäjiin:

JIT-kääntäjät

JIT-kääntäjä toimii ohjelman suorituksen aikana, kääntäen lennossa.

JIT-kääntäjiä käytetään tyypillisesti dynaamisten kielten kanssa, joissa tyyppejä ei ole vahvistettu etukäteen. JIT-ohjelmat ajetaan tulkin tai virtuaalikoneen (VM) kautta.

AOT-kääntäjät

AOT-kääntäjä toimii ohjelman luomisen aikana, ennen ajonaikaa.

AOT-kääntäjiä käytetään yleensä staattisten kielten kanssa, jotka tietävät tietotyypit. AOT-ohjelmat kootaan alkuperäiseen konekoodiin, jonka laitteistot suorittavat suoraan suorituksen aikana.

Lainaamalla tätä Wm Lelerin hienoa artikkelia:

Kun AOT-kokoaminen tehdään kehityksen aikana, se johtaa aina paljon hitaampaan kehityssykliin (aika ohjelman muuttamisen ja ohjelman suorittamisen välillä, jotta muutoksen tulos saadaan näkyviin). Mutta AOT-kokoaminen johtaa ohjelmiin, jotka voivat suorittaa ennustettavammin ja ilman taukoa analyysille ja kokoamiselle suorituksen aikana. AOT: n kääntämät ohjelmat alkavat myös suorittaa nopeammin (koska ne on jo koottu).
Sitä vastoin JIT-kokoaminen tarjoaa paljon nopeampia kehityssyklejä, mutta voi johtaa hitaampaan tai äänekkäämpään suoritukseen. Erityisesti JIT-kääntäjillä on hitaammat käynnistysajat, koska ohjelman käynnistyessä JIT-kääntäjän on tehtävä analyysi ja käännös ennen koodin suorittamista. Tutkimukset ovat osoittaneet, että monet ihmiset hylkäävät sovelluksen, jos sen suorittaminen vie enemmän kuin muutama sekunti.

Staattisena kielenä Swift kootaan etukäteen.

Dart voidaan kääntää sekä AOT että JIT. Tämä tarjoaa merkittäviä etuja käytettäessä Flutter-valmistetta. Lainaan uudelleen:

JIT-kokoamista käytetään kehityksen aikana, käyttämällä erityisen nopeaa kääntäjää. Sitten, kun sovellus on valmis julkaistavaksi, se kootaan AOT: ksi. Näin ollen Dart pystyy toimittamaan edistyneiden työkalujen ja kääntäjien avulla molempien maailmojen parhaat puolet: erittäin nopeat kehityssyklit sekä nopeat suorittamis- ja käynnistysajat. - Wm Leler

Dart: n avulla saat parhaan molemmista maailmoista.

Swift kärsii AOT-kokoamisen päähaitoista. Toisin sanoen kokoamisaika kasvaa koodikantan koon myötä.

Keskikokoisessa sovelluksessa (10–100 kt riviä) sovelluksen kääntäminen voi kestää helposti minuutteja.

Ei niin Flutter-sovelluksissa, joissa saamme jatkuvasti toisen sekunnin kuumalatauksen riippumatta kooditietokannan koosta.

Muut ominaisuudet eivät kuulu

Seuraavia ominaisuuksia ei käsitelty, koska ne ovat melko samanlaisia ​​Dartissa ja Swiftissä:

  • Operaattorit (katso Swift- ja Dart-viite)
  • Jouset (katso Swift- ja Dart-viite)
  • Vaihtoehtoinen ketjutus Swiftissä (tunnetaan nimellä ehdolliset jäsenoikeudet Dartissa).

samanaikaisuuden

  • Samanaikainen ohjelmointi toimitetaan Dart-isolaatteilla.
  • Swift käyttää Grand Central Dispatchia (GCD) ja lähetysjonoja.

Suosikki Swift-ominaisuuksiani puuttuvat Dartilta

  • structs
  • Enums liittyviin tyyppeihin
  • Valinnaiset

Suosikki tikkaominaisuuksistani puuttuu Swift

  • Just-in-time-kääntäjä
  • Tulevaisuuden odotus / async (katso async / odottaa Chris Lattnerin ehdotusta)
  • Suorat / async-virrat * (RxSwift tarjoaa supersettivirrat reaktiivisiin sovelluksiin)

johtopäätös

Sekä Dart että Swift ovat erinomaisia ​​kieliä, jotka soveltuvat hyvin nykyaikaisten mobiilisovellusten rakentamiseen ja sen ulkopuolelle.

Kumpikaan kieli ei ole ylivoimainen, koska molemmilla on omat ainutlaatuiset vahvuutensa.

Kun katson mobiilisovellusten kehitystä ja näiden kahden kielen työkaluja, minusta tuntuu, että Dartilla on etusija. Tämä johtuu JIT-kääntäjästä, joka on Flutterin tilallisen kuumalatauksen perusta.

Ja kuumalataus tuottaa valtavan tuottavuuden voittoa sovelluksia rakennettaessa, koska se nopeuttaa kehitysjaksoa sekunneista tai minuutteista alle sekuntiin.

Kehittäjän aika on harvempi resurssi kuin laskenta-aika.

Joten kehittäjille suunnatun ajan optimointi on erittäin älykäs siirto.

Toisaalta minusta tuntuu, että Swiftilla on erittäin vahva tyyppinen järjestelmä. Tyyppiturvallisuus otetaan huomioon kaikissa kielitoiminnoissa, ja se johtaa luonnollisemmin vankkoihin ohjelmiin.

Kun olemme sivuuttaneet henkilökohtaiset mieltymykset, ohjelmointikielet ovat vain työkaluja. Ja kehittäjien tehtävämme on valita työlle sopivin työkalu.

Joka tapauksessa voimme toivoa, että molemmat kielet lainaavat parhaita ideoita toisiltaan niiden kehittyessä.

Viitteet ja hyvitykset

Sekä Dartilla että Swiftillä on laaja ominaisuusjoukko, eikä niitä ole käsitelty tässä täysin.

Valmistelin tämän artikkelin lainaustiedot virallisista Swift and Dart -asiakirjoista, jotka löytyvät täältä:

  • Swift-ohjelmointikieli
  • Retki tikan kielelle

Lisäksi JIT: n ja AOT: n kääntäjiä käsittelevä osa on voimakkaasti inspiroinut tätä suurta Wm Lelerin artikkelia:

  • Miksi räpytys käyttää tikkaa

Olenko kaivannut jotain? Kerro siitä kommentissa.

Hyvää koodausta!

PÄIVITYS: Minun Flutter & Firebase Udemy -kurssi on nyt saatavana varhaisessa vaiheessa. Käytä tätä linkkiä ilmoittautumiseen (alennuskoodi sisältyy hintaan):

  • Flutter & Firebase: Luo täydellinen sovellus iOS- ja Android-laitteille

Katso lisää artikkeleita ja video-oppaita kohdasta Coding With Flutter.

Olen @ biz84 Twitterissä. Voit nähdä myös GitHub-sivuni.