Կոդի ցուցադրում. Ruby vs Javascript

Ruby- ն և JavaScript- ը պատրաստվում են գլուխը գլուխ առնել: Գրությունների այս երկու լեզուներն էլ դինամիկ տպագրվում են և աջակցում են օբյեկտի վրա հիմնված ծրագրավորմանը: Մենք կուսումնասիրենք դրանց տարբերությունները կամ նմանությունները նրանց ավելի տարածված առանձնահատկությունների միջև:

Հրաժարում. Մենք միայն այստեղ ենք նայում JavaScript ES6- ի ժամանակակից շարահյուսությանը:

Լուսանկարը ՝ Pramote Polyamate- ի վրա, 500 px

Լարային միջնորդություն

Համակարգչային ծրագրավորման մեջ լարային միջանձնացումը տողի բառացի արժեքով փոփոխականի կամ արտահայտության արժեքը ներարկելու գործընթաց է:

Ռուբիում սա կոչվում է, դուք կռահեցիք դա ՝ լարային միջնորդություն:

Ռուբին.

first_name = "Մարտին"
last_name = "Riggs"
դնում է «Ողջույն, ես # {first_name} # {վերջին_անունն եմ»:

Javascript- ում նույն բանը կարելի է հասնել կաղապարային տառերով:

JavaScript:

const firstName = 'Martin';
const lastName = 'Riggs';
console.log ('Ողջույն, ես $ {firstName} $ {lastName `.`);

Մեթոդներ և գործառույթներ

Վիքիպեդիան բացատրում է, որ համակարգչային ծրագրավորման մեջ ենթածրագիրը ծրագրային ցուցումների հաջորդականություն է, որը կատարում է հատուկ առաջադրանք, փաթեթավորված որպես միավոր: Այնուհետև այս միավորը կարող է օգտագործվել ծրագրերում, որտեղ այդ հատուկ առաջադրանքը պետք է կատարվի:

Ծրագրավորման տարբեր լեզուներում ենթածրագիրը կարող է կոչվել կարգ, գործառույթ, ռեժիմ, մեթոդ կամ ենթածրագիր:

Օգտագործման համար անհրաժեշտ է, որ այս ենթածրագրերը նախ սահմանվեն, ապա կոչվեն: Ռուբիում դրանք հայտնի են որպես մեթոդներ և JavaScript- ում դրանք կոչվում են գործառույթներ:

Ռուբին.

def full_name (first_name, last_name)
  "# {first_name.capitalize} # {last_name.capitalize}"
վերջ
դնում է full_name ("beatrix", "kiddo")

JavaScript:

գործառույթի ամբողջական անուն (անունը, ազգանուն) {
  վերադարձ `` $ {firstName.capitalize () $ {lastName.capitalize () `;
;
console.log (fullName ("beatrix", "kiddo"));

Եթե ​​դուք վերը նշված օրինակներն եք վարում, հավանաբար նկատել եք, որ JavaScript- ի օրինակը չի գործում, բայց սխալ է նետում. Uncaught TypeError: firstName.capitalize- ը գործառույթ չէ:

Դա այն է, որ JavaScript- ը բնութագրում է ոչ թե կապիտալիզացիայի գործառույթ: Ռուբին ունի # հարմարավետ և կոկիկ իդիոմատիկ մեթոդներ, ինչպիսիք են #cital- ը, որոնք իսկապես հարմար են: Վերոնշյալ օրինակը դարձնելու համար հարկավոր է օգտագործել JavaScript String օբյեկտի նախատիպի ցանցը (կապիկների կարկատում).

String.prototype.capitalize = գործառույթ ()
  վերադարձնել this.charAt (0) .toUpperCase () + this.slice (1);
}

Բլոկներ

Ռուբիում բլոկները հիմնականում կոդերի անանուն կտորներ են, որոնք կարող են փոխանցվել և կոչվել ներսից եղած մեթոդներից: Ռուբիի ներկառուցված օբյեկտի մեթոդներից շատերն ընդունում են բլոկներ, և դրանք հարմար եղանակ են ՝ վարվելով այդպիսի մեթոդների վարվելաձևից:

Ռուբին.

Def ժամանակաչափ
  start_time = Ժամանակը `հիմա
  դնում է «Running block ...»
  
  բերքատվություն
  դնում է «Ավարտվեց»:
  end_time = Time.now - start_time
  "Կատարման ժամանակը. # {End_time}"
վերջ
դնում է ժմչփ {(0..10000000): տեսակավորել

Հե ,յ, JavaScript- ը չունի բլոկներ, այնպես որ վերը նշված իրականացումը հնարավոր չէ, և համեմատությունը հիմար է: Թե՞ դա JavaScript- ի գործառույթները կարող են որպես փաստարկ ընդունել հետադարձ կապի գործառույթները, և եթե մենք կարծում ենք, որ Ռուբիի բլոկները շատ նման են անանուն մեթոդներին, մենք կարող ենք հասնել նման արդյունքի:

JavaScript:

գործառույթի ժամանակաչափ (հետադարձ կապ) {
  const startTime = new Date (). getTime ();
  console.log («Գործարկում է պատասխանը ...»);
  
  ետ Զանգիր();
  console.log («Ավարտվեց!»);
  const endTime = new Date (). getTime ();
  վերադարձ `կատարման ժամանակը. $ {endTime - startTime}`;
;
ժմչփ (() => Array.from (Array (10000000) .keys ()). տեսակ ());

Նշում. Ի տարբերություն Ruby- ի, JavaScript- ը ներկառուցված Range օբյեկտ չունի: Վերևում գտնվող Array.from (Number) .key- ները () վերադարձնում են զանգվածը 0-ից համարին:

Իդիոմատիկ կրկնություններ

Ռուբին հայտնի է նրանով, որ ունի շատ գեղեցիկ իդիոմատիկ iterators ՝ օղակների միջով անցնելու համար (և այլ թվարկված թվեր կամ կրկնող կառույցներ):

Ռուբին.

names = ["Tango", "Cash", "Dalton", "Riggs"]
names.each do | անվանումը |
  անուն է դնում
վերջ

ES6- ի օգնությամբ JavaScript- ի միջոցով զանգվածի միջոցով այն դառնում է քամի:

JavaScript:

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

Նշում. Javascript for Յուրաքանչյուր գործառույթը կարող է մուտք ունենալ նաև տարրերի ինդեքս: Ռուբիում մենք կօգտագործեինք տարբեր կրկնողներ, որոնք կոչվում են յուրաքանչյուր_բեռն_ինդեքս:

Դասեր և դասակարգային ժառանգություն

Օբեկտների վրա հիմնված ծրագրավորման մեջ դասերը առարկաների ձևավորման, պետության արժեքների ապահովման (օբյեկտի հատկությունների կամ հատկանիշների) արժեքների ապահովման և վարքագծի իրականացման (օրինակ, ստացողներն ու կարգավորիչները են կարդալու և գրել այդպիսի հատկությունները կամ ատրիբուտները):

Ռուբին.

դասի մեքենա
  նախնական նախնական ձևավորում (անուն, տիպ)
    @name = անուն
    @type = տիպը
  վերջ
  դեֆ անուն
    @Անուն
  վերջ
  դեֆի տեսակը
    @տիպ
  վերջ
վերջ
դասի մեքենա <Տրանսպորտ
  def սկզբնավորել (անունը)
   սուպեր (անունը ՝ «մեքենա»)
  վերջ
վերջ
diablo = Car.new ("Lamborghini")
դնում diablo.name- ն
դնում diablo.type- ն

JavaScript:

դասի մեքենա {
 
  կոնստրուկտոր (անուն, տիպ) {
    this.name = անուն;
    this.type = տիպ;
  }
 
  getName ()
    վերադարձնել this.name;
  }
 
  getType ()
    վերադարձնել this.type;
  }
 
}
դասի մեքենան երկարացնում է ավտոմեքենան
 
  կոնստրուկտոր (անուն) {
    սուպեր (անունը ՝ «մեքենա»);
  }
}
const diablo = new Car ('Lamborghini');
console.log (diablo.getName ());
console.log (diablo.getType ());

Նշում. Վերոնշյալ օրինակում, Ruby Vehicle դասը, որպես կանոն, իրականացվում է ատրիբուտային ընթերցողի միջոցով `օրինակելի փոփոխականների համար ստացվող մեթոդներ ստեղծելու համար: Ես որոշեցի չօգտագործել ատրիբուտների ընթերցող, որպեսզի ավելի նման տեսք ունենա JavaScript- ի իրականացմանը:

Կործանում

Ժամանակակից JavaScript- ը ներկայացրեց այս իսկապես զով բանը, որը կոչվում է կործանում, որտեղ կարող եք տարրեր ներդիրների կամ առարկաների մեջ զետեղել համառոտ շարահյուսության փոփոխականներին:

JavaScript:

firstName, lastName = 'James Bond'.split ();
console.log (`Իմ անունն է $ {ազգանուն}, $ {firstName} $ {ազգանուն}`);

Իհարկե, դուք չեք կարող անել դա Ruby- ում:

Ռուբին.

first_name, last_name = "James Bond" .split
դնում է «Իմ անունը # {վերջին_անուն} է, # {առաջին_անունը} # {վերջին_անունը}»:

Նշում. Թեև մենք Ռուբիում կարող ենք զանգահարել զանգվածներ, ինչպես դա անում է JavaScript- ում, չկա Ruby- ի համարժեք ուղղակիորեն ապակառուցողական խցանումներին:

Spread Operator- ը

Ժամանակակից JavaScript- ը ներդրել է նաև տարածման օպերատորը, որը թույլ է տալիս ընդլայնել կրկնվող արտահայտությունները, որտեղ ակնկալվում են զրո կամ ավելի շատ փաստարկներ կամ տարրեր:

JavaScript:

գործառույթի գումար (x, y, z)
  վերադարձ x + y + z;
;
const համարները = [1, 2, 3];
console.log (գումար (... համարներ);
[a, b, ... rest] = [10, 20, 30, 40, 50];
console.log (ա);
console.log (բ);
console.log (հանգիստ); // հանգիստը զանգված է:

Ռուբիում մենք դրա համար ունենք splat օպերատոր:

Ռուբին.

դեֆիցիտ (x, y, z)
  x + y + z
վերջ
համարներ = [1, 2, 3]
գումար է դնում (* համարներ)
ա, * հանգիստ, բ = [10, 20, 30, 40, 50]
դնում ա
դնում բ
դնում հանգստի # հանգիստը Array!

Նշում. Դուք երևի նկատել եք, որ Ռուբիում * հանգիստը գտնվում է մյուս փոփոխականների միջև: Դա splat օպերատորն է, որը կարող է տեղակայվել փոփոխականների ամենուր: JavaScript- ում տարածման օպերատորը պետք է վերջապես գա:

Ruby- ն ունի նաև կրկնակի splat օպերատոր ** ՝ նույն բանը կատարելու համար: JavaScript ES2018 ճշգրտումը տարածման օպերատորին է ներկայացնում նաև օբյեկտների վրա:

Վերջնական խոսք

Ինչպես երևի հասկացել եք, ի վերջո երկու լեզուներն էլ այդքան էլ տարբեր չեն, և, ES6- ի հետ միասին, JavaScript- ը ավելի ու ավելի հաճելի է դարձել գրել: Իհարկե, JavaScript- ը զննարկչի լեզու է, և նրա իրադարձությունների հանգույցը ապահովում է ասինխրոն վարք: Մյուս կողմից, Ռուբին ունի շատ հզոր գործիքներ `մետրապրոգրամինգը կատարելու համար և սիրված է իր իդիոմատիկ շարահյուսության համար: Վերջում, կարծում եմ, որ ձեռնտու է սովորել և իմանալ ինչպես օգտակար, այնպես էլ հաճախ, քան մեկ ծրագրավորման լեզուի իմացությունը ձեզ գաղափարներ կտա, թե ինչպես կարելի է մեկ այլ ծրագրում ծածկագրել կամ լուծել: