Koodi tutvustus: Ruby vs Javascript

Rubiin ja JavaScript lähevad peaga pähe. Mõlemad skriptikeeled on dünaamiliselt trükitud ja toetavad objektorienteeritud programmeerimist. Uurime nende erinevusi või sarnasusi nende mõne tavalisema funktsiooni osas.

Kohustustest loobumine: vaatame siin ainult moodsa JavaScripti ES6 süntaksi.

Foto autor Pramote Polyamate, 500 pikslit

Stringide interpoleerimine

Programmeerimisel on stringi interpoleerimine muutuja või avaldise väärtuse sisestamine stringi sõnasse.

Ruby keeles nimetatakse seda, nagu arvasite, stringide interpolatsiooniks.

Rubiin:

eesnimi = "Martin"
last_name = "Riggs"
paneb kirja "Tere, ma olen # {first_name} # {last_name}".

Javascriptis on sama võimalik saavutada ka malli litraatidega.

JavaScript:

const firstName = 'Martin';
const lastName = 'Riggs';
console.log (`Tere, ma olen $ {eesnimi} $ {perenimi}. ');

Meetodid ja funktsioonid

Vikipeedia selgitab, et arvutiprogrammeerimisel on alamprogramm konkreetsete toimingute jaoks ette nähtud programmijuhiste jada, mis on pakitud ühikuna. Seda ühikut saab seejärel kasutada programmides, kus iganes seda konkreetset ülesannet tuleks täita.

Erinevates programmeerimiskeeltes võib alamprogrammi nimetada protseduuriks, funktsiooniks, rutiiniks, meetodiks või alamprogrammiks.

Kasutamiseks tuleb need alamprogrammid kõigepealt määratleda ja seejärel välja kutsuda. Ruby's nimetatakse neid meetoditeks ja JavaScriptis nimetatakse neid funktsioonideks.

Rubiin:

def täisnimi (eesnimi, perekonnanimi)
  "# {first_name.capitalize} # {last_name.capitalize}"
lõpp
paneb täisnime ("beatrix", "kiddo")

JavaScript:

funktsioon täisnimi (eesnimi, perekonnanimi) {
  tagasta `$ {firstName.capitalize ()} $ {lastName.capitalize ()}`;
};
console.log (fullName ("beatrix", "kiddo"));

Kui käitate ülaltoodud näiteid, olete ilmselt märganud, et JavaScripti näide ei tööta, kuid tekitab tõrke: Tabamata TypeError: firstName.capitalize ei ole funktsioon!

Seda seetõttu, et JavaScript ei määratle suurtähtede funktsiooni natiivselt. Rubiinil on palju käepäraseid ja korralikke idioomaatilisi meetodeid, näiteks #kapitaliseerimine, mis on tõesti mugavad. Ülaltoodud näite toimimiseks peame JavaScripti stringi objektil kasutama prototüübi ahelat (ahviplaastrit):

String.prototype.capitalize = function () {
  tagastage see.charAt (0) .toUpperCase () + see.silss (1);
}

Plokid

Ruby keeles on plokid põhimõtteliselt nimetud kooditükid, mida saab edastada ja seestpoolt kutsuda. Paljud Ruby sisseehitatud objektimeetodid aktsepteerivad plokke ja need on mugav viis nende meetodite käitumise muutmiseks.

Rubiin:

def taimer
  algusaeg = aeg.tea
  paneb "Jooksuplokk ..."
  
  saagikus
  paneb "Valmis!"
  lõpp_aeg = aeg.nu - algusaeg
  "Täitmise aeg: # {end_time}"
lõpp
paneb taimeri {(0..10000000) .sort}

Hei, JavaScriptil pole blokke, nii et ülaltoodud rakendamine pole võimalik ja võrdlus on rumal! Või on? JavaScripti funktsioonid võivad tagasihelistamise funktsioone aktsepteerida argumentidena ja kui arvame, et Ruby plokid on väga sarnased anonüümsete meetoditega, võime saavutada sarnase tulemuse.

JavaScript:

funktsiooni taimer (tagasihelistamine) {
  const startTime = uus kuupäev (). getTime ();
  console.log ("Tagasihelistamise käitamine ...");
  
  helista tagasi();
  console.log ("Valmis!");
  const endTime = uus kuupäev (). getTime ();
  return `Täitmise aeg: $ {endTime - startTime}`;
};
taimer (() => Array.from (Array (10000000) .key ()). sort ());

Märkus: erinevalt Ruby'st pole JavaScriptil sisseehitatud vahemiku objekti. Ülaltoodud massiiv.nupud (arv) .klahvid () tagastab massiivi 0-st numbrini.

Idiomaatilised iteratsioonid

Rubiin on tuntud selle poolest, et sellel on väga toredad idioomaatsed iteraatorid massiivide (ja muude loendatavate või iteratiivsete struktuuride) kaudu silmuseks.

Rubiin:

nimed = ["Tango", "Cash", "Dalton", "Riggs"]
nimed.ja kõik tegema | nimi |
  paneb nime
lõpp

ES6-ga muutub JavaScripti massiivi kaudu iteratsioon imelihtne:

JavaScript:

const nimed = ['Tango', 'Cash', 'Dalton', 'Riggs'];
names.forEach (nimi => console.log (nimi));

Märkus: funktsioon Javascript forEach pääseb juurde ka elemendi registrile. Ruby puhul kasutaksime erinevat iteraatorit, mida kutsutaks igaks koos_in_indexiga.

Klassid ja klassipärand

Objektorienteeritud programmeerimisel on klassid koodimallid objektide loomiseks, oleku väärtuste pakkumiseks (objekti atribuudid või atribuudid) ja käitumisviisi rakendamiseks (näiteks getterid ja setterid selliste omaduste või atribuutide lugemiseks ja kirjutamiseks).

Rubiin:

klassi sõiduk
  def initsialiseerimine (nimi, tüüp)
    @ nimi = nimi
    @ tüüp = tüüp
  lõpp
  def nimi
    @nimi
  lõpp
  def tüüp
    @ tüüp
  lõpp
lõpp
klassi auto 
diablo = Car.new ("Lamborghini")
paneb diablo.name
paneb diablo.type

JavaScript:

klassi sõiduk {
 
  ehitaja (nimi, tüüp) {
    see.nimi = nimi;
    this.type = tüüp;
  }
 
  getName () {
    tagasta see nimi;
  }
 
  getType () {
    tagasta see tüüp;
  }
 
}
klassi auto laiendab sõidukit {
 
  ehitaja (nimi) {
    super (nimi, 'auto');
  }
}
const diablo = uus auto ('Lamborghini');
console.log (diablo.getName ());
console.log (diablo.getType ());

Märkus. Ülaltoodud näites rakendatakse Ruby Vehicle klassi tavaliselt atribuudilugejaga, et luua esinemismuutujate gettermeetodeid. Otsustasin atribuudilugejat mitte kasutada, et saada JavaScripti rakendusega sarnanevam välimus.

Destruktureerimine

Kaasaegne JavaScript tutvustas seda tõeliselt lahedat asja, mida nimetatakse hävitamiseks, kus massiivi sisemisi elemente või objekte saab muutujatele määrata lühikese süntaksi abil.

JavaScript:

eesnimi, perekonnanimi = 'James Bond'.split ();
console.log (`Minu nimi on $ {perenimi}, $ {eesnimi} $ {perenimi}");

Kindlasti ei saa te seda Ruby'is teha!

Rubiin:

eesnimi, perekonnanimi = "James Bond" .split
paneb sõna "Minu nimi on # {last_name}, # {first_name} # {last_name}"

Märkus. Ehkki me võime Ruby massiive destruktureerida samamoodi nagu JavaScriptis, pole Ruby ekvivalenti otseselt destruktureerivatele räsidele.

Hinnaoperaator

Kaasaegne JavaScript on kasutusele võtnud ka hajutusoperaatori, mis lubab laiendada korratavaid avaldisi seal, kus eeldatakse nulli või enamat argumenti või elementi.

JavaScript:

funktsioonide summa (x, y, z) {
  tagasi x + y + z;
};
konstandenumbrid = [1, 2, 3];
console.log (summa (... numbrid);
[a, b, ... puhata] = [10, 20, 30, 40, 50];
console.log (a);
console.log (b);
console.log (ülejäänud); // ülejäänud on massiiv!

Ruby's on meil selleks splat-operaator.

Rubiin:

def summa (x, y, z)
  x + y + z
lõpp
arv = [1, 2, 3]
paneb summa (* numbrid)
a, * puhata, b = [10, 20, 30, 40, 50]
paneb a
paneb b
paneb puhata # puhkus on massiiv!

Märkus: olete ilmselt märganud, et Ruby * -s on puhkus muude muutujate vahel. See tähendab, et plaadioperaatori saab paigutada muutujate vahele. JavaScriptis peab hajutatud operaator jääma viimaseks.

Rubyl on ka topeltplaat-operaator **, et seda sama teha räsides. JavaScripti ES2018 spetsifikatsioon tutvustab ka hajutamisoperaatorit objektidel.

Lõppsõna

Nagu olete juba aru saanud, ei ole mõlemad keeled lõppude lõpuks nii erinevad ja ES6-ga on JavaScripti kirjutamine muutunud üha meeldivamaks. Muidugi, JavaScript on brauseri keel ja selle sündmussilm pakub asünkroonset käitumist. Teisest küljest on Rubyl väga võimsad tööriistad metaprogrammeerimiseks ja ta on oma idioomaatilise süntaksi poolest väga armastatud. Lõppkokkuvõttes on minu arvates kasulik õppida ja osata mõlemaid, kuna ühe programmeerimiskeele oskus annab teile ideid, kuidas mõnda teist probleemi kodeerida või sellega lahendada.