Code Showdown: Rubin vs Javascript

Rubin an JavaScript sinn amgaange mam Kapp un de Kapp ze goen. Béid vun dëse Skriptsproochen si dynamesch typéiert an ënnerstëtzen objektorientéiert Programméierung. Mir wäerten hir Differenzen oder Ähnlechkeeten iwwer e puer vun hire méi allgemengen Features ënnersichen.

Verzichterklärung: Mir kucken hei nëmmen op modern JavaScript ES6 Syntax.

Foto vum Pramote Polyamate op 500px

String Interpolatioun

Bei Computerprogrammatioun ass Stringinterpolatioun de Prozess vum Injektioun vum Wäert vun enger Variabel oder engem Ausdrock an engem String literal.

An Rubin gëtt dëst genannt, Dir hutt et gewonnert, String Interpolatioun.

Rubin:

first_name = "Martin"
last_name = "Riggs"
setzt "Hallo, ech sinn # {first_name} # {last_name}."

Am Javascript kann déiselwecht Saach mat Template Literal erreecht ginn.

JavaScript:

const firstName = 'Martin';
const lastName = 'Riggs';
console.log (`Hallo, ech sinn $ {firstName} $ {lastName} .`);

Methoden a Funktiounen

Wikipedia erkläert datt am Computerprogramméierung eng Subroutine eng Sequenz vu Programminstruktiounen ass déi eng spezifesch Aufgab ausféiert, gepackt als Eenheet. Dës Eenheet kann dann a Programmer benotzt ginn, egal wou déi speziell Aufgab sollt ausgefouert ginn.

A verschiddene Programméierungssprooche kann eng Subroutine eng Prozedur genannt ginn, eng Funktioun, eng Routine, eng Method oder e Subprogramm.

Fir benotzt ze ginn, musse dës Subroutinen als éischt definéiert ginn an dann opgeruff ginn. An Rubin si si Methoden bekannt an an JavaScript, ginn se Funktiounen genannt.

Rubin:

def full_name (first_name, last_name)
  "# {first_name.capitalize} # {last_name.capitalize}"
Enn
setzt Full_name ("Beatrix", "Kiddo")

JavaScript:

Funktioun FullName (FirstName, LastName) {
  return `$ {firstName.capitalize ()} $ {lastName.capitalize ()}`;
};
console.log (fullName ("beatrix", "kiddo"));

Wann Dir d'Beispiller hei uewen leeft, hutt Dir wahrscheinlech gemierkt datt de JavaScript Beispill net funktionnéiert, awer e Feeler werfen: Unctained TypeError: firstName.capitalize ass keng Funktioun!

Dëst ass well JavaScript keng Kapitaliséierungsfunktioun natiirlech definéiert. Ruby huet vill praktesch an netzlech idiomatesch Methoden wéi #capitaliséieren déi wierklech praktesch sinn. Fir dat uewe genannte Beispill ze maachen, musse mir de Prototyp Kette (Monkey Patch) am JavaScript String Objet benotzen:

String.prototype.capitalize = Funktioun () {
  return this.charAt (0) .toUpperCase () + this.slice (1);
}

Blockéieren

An Ruby sinn d'Blécke meeschtens onbenannt Stécker vum Code, deen op banne Methoden weiderginn an opgeruff kënne ginn. Vill vun den agebauten Objetmethoden a Rubin akzeptéiere Blocken an dës sinn e praktesche Wee fir wéi esou Methoden sech behuelen.

Rubin:

def Timer
  start_time = Time.now
  setzt "Running Block ..."
  
  nozeginn
  setzt "Fäerdeg!"
  end_time = Time.now - start_time
  "Ausféierungszäit: # {end_time}"
Enn
stellt Timer {(0..10000000) .sort}

Hey, JavaScript huet keng Blocken, sou datt déi uewen implementéiert ass net méiglech an de Verglach ass domm! Oder ass et? JavaScript-Funktiounen kënnen Callback-Funktiounen als Argumenter akzeptéieren a wa mir u Rubinblocken als ganz ähnlech anonyme Methoden denken, kënne mir e ähnlecht Resultat erreechen.

JavaScript:

Funktiounstimer (Callback) {
  const startTime = neien Datum (). getTime ();
  console.log ("Callback lafen ...");
  
  zeréckruffen();
  console.log ("fäerdeg!");
  const endTime = neien Datum (). getTime ();
  zréck `Ausféierung Zäit: $ {endTime - startTime}`;
};
timer (() => Array.from (Array (10000000) .keys ()). sort ());

Notiz: Am Géigesaz zum Rubin huet JavaScript keen agebauten Range Objet. The Array.from (Number) .keys () uewen gëtt eng Array vun 0 op Number zréck.

Idiomatesch Iteratiounen

Ruby ass bekannt fir ganz léif idiomatesch Iteratoren ze hunn duerch Arrays (an aner Enumerables oder iterative Strukturen) ze loopen.

Rubin:

names = ["Tango", "Cash", "Dalton", "Riggs"]
names.each do | Numm |
  stellt Numm
Enn

Mat ES6, iteréieren duerch eng Array vu JavaScript gëtt e Loft:

JavaScript:

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

Notiz: D'Funktioun Javascript forEach kann och Zougang zum Element vum Element kréien. An Rubin benotze mir en aneren Iterator fir dee genannt each_with_index.

Klassen a Klass Ierfschaft

An Objektorientéiert Programméierung sinn Klassen Code Templates fir Objekter ze kreéieren, Wäerter fir Staat ze bidden (d'Eegeschafte vum Objet oder Attributer) a Verhalen implementéieren (wéi Getteren an Setzer fir sou Eegeschaften oder Attributer ze liesen an ze schreiwen).

Rubin:

Klass Gefier
  def initialiséieren (Numm, Typ)
    @name = Numm
    @type = Typ
  Enn
  def Numm
    @name
  Enn
  def Typ
    @type
  Enn
Enn
Klass Auto 
diablo = Car.new ("Lamborghini")
setzt diablo.name
setzt Diablo.type

JavaScript:

klass Gefier {
 
  constructor (Numm, Typ) {
    this.name = Numm;
    this.type = Typ;
  }
 
  getName () {
    return this.name;
  }
 
  getType () {
    return this.type;
  }
 
}
Klass Auto verlängert Gefier {
 
  constructor (Numm) {
    super (Numm, 'Auto');
  }
}
const diablo = neien Auto ('Lamborghini');
console.log (diablo.getName ());
console.log (diablo.getType ());

Notiz: Am uewe genannte Beispill géif d'Rubin Vehicle Class typesch mat engem Attributer Lieser ëmgesat ginn fir d'Gettermethoden fir d'Instanzvariabelen ze kreéieren. Ech hu gewielt en Attributer Lieser net ze benotzen fir e méi ähnleche Look zu der JavaScript Implementatioun ze hunn.

Zerstéierung

Modern JavaScript huet dës wierklech cool Saach genannt Zerstéierung agefouert, wou Dir Elementer bannent Arrays oder Objete mat Variabele mat enger präziser Syntax kënnt.

JavaScript:

firstName, lastName = 'James Bond'.split ();
console.log (`Mäi Numm ass $ {lastName}, $ {firstName} $ {lastName}`);

Dir kënnt dëst am Rubin net maachen!

Rubin:

first_name, last_name = "James Bond" .split
setzt "Mäi Numm ass # {last_name}, # {first_name} # {last_name}"

Notiz: Während mir a Ruby Arrays zerstéiere kënne wéi mir am JavaScript maachen, gëtt et kee Rubin gläichwäerteg fir direkt Schüchteren ze zerstéieren.

Verbreed Operator

Modern JavaScript huet och de Verbreedungsbetreiber agefouert deen et erméiglecht Ausdréck erweidert ze ginn, wou Null oder méi Argumenter oder Elementer erwaart ginn.

JavaScript:

Funktiounsum (x, y, z) {
  zréck x + y + z;
};
const Zuelen = [1, 2, 3];
console.log (Zomm (... Zuelen);
[a, b, ... Rescht] = [10, 20, 30, 40, 50];
console.log (a);
konsole.log (b);
console.log (Rescht); // Rescht ass eng Array!

An Rubin hu mir de Splattbetreiber fir dëst.

Rubin:

def sum (x, y, z)
  x + y + z
Enn
Zuelen = [1, 2, 3]
stellt Zomm (* Zuelen)
a, * Rescht, b = [10, 20, 30, 40, 50]
stellt eng
setzt b
setzt Rescht # Rou ass eng Array!

Notiz: Dir hutt wahrscheinlech gemierkt datt am Rubin * Rescht tëscht den aneren Variablen ass. Dat ass de Splattbetreiber kann iwwerall tëscht de Variablen plazéiert ginn. Am JavaScript muss de Spreader Bedreiwer kommen.

Rubin huet och den Duebelsplattbetrib ** fir datselwecht ze maachen op Hashes. D'Javascript ES2018 Spezifikatioun féiert och de Verbreedungsbetreiber op Objete vir.

Finale Wuert

Wéi Dir Iech sécherlech scho realiséiert hutt, béid Sprooche sinn no allem net sou ënnerschiddlech, an mat ES6 gouf JavaScript ëmmer méi agreabel ze schreiwen. Sécher, JavaScript ass d'Sprooch vum Browser a seng Event Loop liwwert asynchrone Verhalen. Op der anerer Säit huet Ruby ganz mächteg Tools fir Metaprogramméierung ze maachen an ass beléift fir seng idiomatesch Syntax. Zum Schluss mengen ech, ass et derwäert et ze léieren a béid sou dacks Kenntnisser vun enger Programméierungssprooch ze ginn Iech Iddien ginn, wéi een e bestëmmte Problem an engem aneren kodéiert oder unzitt.