ລະຫັດ Showdown: Ruby vs Javascript

Ruby ແລະ JavaScript ກຳ ລັງຈະໄປຫາຫົວ. ທັງສອງພາສາສະຄິບນີ້ແມ່ນການພິມແບບເຄື່ອນໄຫວແລະສະ ໜັບ ສະ ໜູນ ການຂຽນໂປແກຼມທີ່ເນັ້ນໃສ່ວັດຖຸ. ພວກເຮົາຈະກວດເບິ່ງຄວາມແຕກຕ່າງຫຼືຄວາມຄ້າຍຄືກັນຂອງພວກມັນໃນບາງລັກສະນະທົ່ວໄປຂອງພວກມັນ.

ການປະຕິເສດ: ພວກເຮົາ ກຳ ລັງຊອກຫາ syntax JavaScript ES6 ທີ່ທັນສະ ໄໝ ຢູ່ນີ້.

ຮູບພາບໂດຍ Pramote Polyamate ຂະ ໜາດ 500px

interpolation ຊ່ອຍແນ່

ໃນການຂຽນໂປຼແກຼມຄອມພິວເຕີ້, ການຕີຄວາມ ໝາຍ ຂອງເຊືອກແມ່ນຂັ້ນຕອນຂອງການໃສ່ຄຸນຄ່າຂອງຕົວແປຫລືການສະແດງອອກໃນຕົວ ໜັງ ສື.

ໃນ Ruby, ນີ້ແມ່ນເອີ້ນວ່າ, ທ່ານໄດ້ຄາດເດົາມັນ, ການຕີຄວາມຫມາຍຊ່ອຍແນ່.

Ruby:

first_name = "ມາຕິນ"
last_name = "Riggs"
ເອົາ "ສະບາຍດີ, ຂ້ອຍ # {ຊື່ ທຳ ອິດ} # {ນາມສະກຸນຊື່}."

ໃນ Javascript, ສິ່ງດຽວກັນສາມາດບັນລຸໄດ້ດ້ວຍການຮູ້ຫນັງສືແມ່ແບບ.

JavaScript:

const firstName = 'ມາຕິນ';
const lastName = 'Riggs';
console.log (`ສະບາຍດີ, ຂ້ອຍ $ {ຊື່ ທຳ ອິດ} $ {lastName} .`);

ວິທີການແລະ ໜ້າ ທີ່

ວິກິພີເດຍອະທິບາຍວ່າ, ໃນການຂຽນໂປແກຼມຄອມພິວເຕີ້, subroutine ແມ່ນ ລຳ ດັບ ຄຳ ແນະ ນຳ ຂອງໂປແກຼມທີ່ປະຕິບັດວຽກງານສະເພາະ, ຖືກຫຸ້ມຫໍ່ເປັນຫົວ ໜ່ວຍ. ໜ່ວຍ ງານນີ້ສາມາດ ນຳ ໃຊ້ເຂົ້າໃນໂປແກຼມໄດ້ທຸກບ່ອນທີ່ ໜ້າ ວຽກສະເພາະໃດ ໜຶ່ງ.

ໃນພາສາການຂຽນໂປແກຼມທີ່ແຕກຕ່າງກັນ, subroutine ອາດຈະຖືກເອີ້ນວ່າຂັ້ນຕອນ, ໜ້າ ທີ່, ແບບປົກກະຕິ, ວິທີການຫຼືແບບແຜນຍ່ອຍ.

ເພື່ອຈະໄດ້ ນຳ ໃຊ້, subroutines ເຫຼົ່ານີ້ ຈຳ ເປັນຕ້ອງໄດ້ ກຳ ນົດກ່ອນແລະຫຼັງຈາກນັ້ນກໍ່ຖືກເອີ້ນ. ໃນ Ruby, ພວກເຂົາຖືກເອີ້ນວ່າວິທີການແລະໃນ JavaScript, ພວກມັນຖືກເອີ້ນວ່າ ໜ້າ ທີ່.

Ruby:

def ຊື່ເຕັມ (First_name, ນາມສະກຸນສຸດທ້າຍ)
  "# {first_name.capitalize} # {last_name.capitalize}"
ສິ້ນສຸດ
ໃສ່ຊື່ເຕັມ ("beatrix", "kiddo")

JavaScript:

function fullName (firstName, lastName) {
  ກັບມາ `$ {firstName.capitalize ()} $ {lastName.capitalize ()}`;
};
console.log (fullName ("beatrix", "kiddo"));

ຖ້າທ່ານ ກຳ ລັງ ດຳ ເນີນການຕົວຢ່າງຂ້າງເທິງ, ທ່ານອາດຈະໄດ້ສັງເກດເຫັນວ່າຕົວຢ່າງຂອງ JavaScript ບໍ່ເຮັດວຽກ, ແຕ່ມີຂໍ້ຜິດພາດ: Uncaught TypeError: firstName.capitalize ບໍ່ແມ່ນ ໜ້າ ທີ່!

ນີ້ແມ່ນຍ້ອນວ່າ JavaScript ບໍ່ໄດ້ ກຳ ນົດ ຕຳ ລາການ ນຳ ໃຊ້ຕົ້ນທຶນແບບດັ້ງເດີມ. Ruby ມີຫຼາຍວິທີທີ່ໃຊ້ງ່າຍແລະສະອາດເຊັ່ນ #capitalize ທີ່ສະດວກສະບາຍແທ້ໆ. ເພື່ອເຮັດໃຫ້ຕົວຢ່າງຂ້າງເທິງເຮັດວຽກ, ພວກເຮົາຈະຕ້ອງໃຊ້ລະບົບຕ່ອງໂສ້ຕົ້ນແບບ (ແບບລິງ) ໃນຈຸດປະສົງ JavaScript String:

String.prototype.capitalize = ໜ້າ ທີ່ () {
  ກັບຄືນ this.charAt (0) .toUpperCase () + this.slice (1);
}

ທ່ອນໄມ້

ໃນ Ruby, ບັນດາທ່ອນໄມ້ແມ່ນພື້ນຖານຂອງລະຫັດທີ່ບໍ່ມີການລະບຸຊື່ທີ່ສາມາດຖືກສົ່ງຜ່ານແລະຮຽກຈາກວິທີການພາຍໃນ. ຫລາຍໆວິທີທາງດ້ານວັດຖຸທີ່ຖືກສ້າງຂື້ນໃນ Ruby ຍອມຮັບທ່ອນໄມ້ແລະເຫຼົ່ານີ້ແມ່ນວິທີທີ່ສະດວກໃນການປັບແຕ່ງວິທີການດັ່ງກ່າວ.

Ruby:

def timer
  start_time = Time.now
  ເອົາ "ແລ່ນຕັນ ... "
  
  ຜົນຜະລິດ
  ເອົາ "ສຳ ເລັດແລ້ວ!"
  end_time = Time.now - ເວລາເລີ່ມຕົ້ນ
  "ເວລາການປະຕິບັດ: # {end_time}"
ສິ້ນສຸດ
ໃສ່ເຄື່ອງຈັບເວລາ {(0..10000000) .sort}

Hey, JavaScript ບໍ່ມີທ່ອນໄມ້, ດັ່ງນັ້ນການປະຕິບັດຂ້າງເທິງນີ້ແມ່ນບໍ່ເປັນໄປໄດ້ແລະການປຽບທຽບແມ່ນໂງ່! ຫລືມັນແມ່ນບໍ? ຟັງຊັນ JavaScript ສາມາດຍອມຮັບຟັງການເອີ້ນຄືນເປັນການໂຕ້ຖຽງແລະຖ້າພວກເຮົາຄິດວ່າທ່ອນໄມ້ Ruby ເປັນຄືກັນກັບວິທີການທີ່ບໍ່ລະບຸຊື່ພວກເຮົາສາມາດບັນລຸຜົນທີ່ຄ້າຍຄືກັນ.

JavaScript:

ຫນ້າທີ່ຈັບເວລາ (callback) {
  const startTime = ວັນທີ ໃໝ່ (). getTime ();
  console.log ("ແລ່ນການເອີ້ນຄືນ ... ");
  
  ໂທ​ກັບ();
  console.log ("ສຳ ເລັດແລ້ວ!");
  const endTime = ວັນທີ ໃໝ່ (). getTime ();
  ກັບຄືນ `ເວລາການປະຕິບັດ: $ {endTime - startTime}`;
};
timer (() => Array.from (Array (10000000) .keys ()). sort ());

ໝາຍ ເຫດ: ບໍ່ຄືກັບ Ruby, JavaScript ບໍ່ມີວັດຖຸ Range ທີ່ຕິດຕັ້ງ. Array.from (ຈຳ ນວນ) .keys () ຂ້າງເທິງຈະສົ່ງ Array ຈາກ 0 ຫາ Number ໄປ.

iterations Idiomatic

Ruby ແມ່ນເປັນທີ່ຮູ້ຈັກວ່າມີຕົວລະອື້ນ idiomatic ງາມຫຼາຍເພື່ອຂື້ນຜ່ານ Arrays (ແລະ Enumerables ຫຼືໂຄງສ້າງອື່ນໆ).

Ruby:

names = ["Tango", "ເງິນສົດ", "Dalton", "Riggs"]
names.each ເຮັດ | ຊື່ |
  ໃສ່ຊື່
ສິ້ນສຸດ

ດ້ວຍ ES6, ການປ່ຽນແປງຜ່ານແຖວໃນ JavaScript ກາຍເປັນລົມ:

JavaScript:

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

ໝາຍ ເຫດ: ຟັງຊັນ Javascript forEach ຍັງສາມາດເຂົ້າເຖິງດັດສະນີຂອງອົງປະກອບ. ໃນ Ruby, ພວກເຮົາຈະໃຊ້ຕົວປ່ຽນທິດທາງທີ່ແຕກຕ່າງກັນ ສຳ ລັບສິ່ງທີ່ເອີ້ນວ່າແຕ່ລະອັນ.

ຫ້ອງຮຽນແລະມໍລະດົກຊັ້ນ

ໃນການຂຽນໂປແກຼມວັດຖຸປະສົງ, ຫ້ອງຮຽນແມ່ນແມ່ແບບລະຫັດ ສຳ ລັບການສ້າງວັດຖຸ, ໃຫ້ຄຸນຄ່າ ສຳ ລັບລັດ (ຄຸນລັກສະນະຫຼືຄຸນລັກສະນະຂອງວັດຖຸ) ແລະການປະຕິບັດພຶດຕິ ກຳ (ເຊັ່ນ: ເຄື່ອງຮັບແລະຜູ້ ກຳ ນົດເພື່ອອ່ານແລະຂຽນຄຸນລັກສະນະຫຼືຄຸນລັກສະນະດັ່ງກ່າວ).

Ruby:

ຍານພາຫະນະຫ້ອງຮຽນ
  def ເລີ່ມຕົ້ນ (ຊື່, ປະເພດ)
    @name = ຊື່
    @type = ປະເພດ
  ສິ້ນສຸດ
  def ຊື່
    @name
  ສິ້ນສຸດ
  ປະເພດ def
    @type
  ສິ້ນສຸດ
ສິ້ນສຸດ
ລົດຍົນປະເພດ <
  def ເລີ່ມຕົ້ນ (ຊື່)
   Super (ຊື່, 'ລົດ')
  ສິ້ນສຸດ
ສິ້ນສຸດ
diablo = Car.new ("Lamborghini")
ໃສ່ diablo.name
ເຮັດໃຫ້ diablo.type

JavaScript:

ຍານພາຫະນະປະເພດ {
 
  ຜູ້ກໍ່ສ້າງ (ຊື່, ປະເພດ) {
    this.name = ຊື່;
    this.type = ປະເພດ;
  }
 
  getName () {
    ສົ່ງຄືນ this.name;
  }
 
  getType () {
    ກັບຄືນ this.type;
  }
 
}
class ລົດຂະຫຍາຍພາຫະນະ {
 
  ຜູ້ກໍ່ສ້າງ (ຊື່) {
    super (ຊື່, 'ລົດ');
  }
}
const diablo = ລົດ ໃໝ່ ('Lamborghini');
console.log (diablo.getName ());
console.log (diablo.getType ());

ໝາຍ ເຫດ: ໃນຕົວຢ່າງຂ້າງເທິງ, ຫ້ອງຮຽນ Ruby Vehicle ໂດຍປົກກະຕິຈະຖືກຈັດຕັ້ງປະຕິບັດກັບຜູ້ອ່ານຄຸນລັກສະນະເພື່ອສ້າງວິທີການທີ່ໄດ້ຮັບ ສຳ ລັບຕົວແປຕົວຢ່າງ. ຂ້ອຍເລືອກທີ່ຈະບໍ່ໃຊ້ຜູ້ອ່ານຄຸນລັກສະນະເພື່ອໃຫ້ມີລັກສະນະຄ້າຍຄືກັນກັບການຈັດຕັ້ງປະຕິບັດ JavaScript.

ການ ທຳ ລາຍ

JavaScript ທີ່ທັນສະ ໄໝ ໄດ້ ນຳ ສະ ເໜີ ສິ່ງທີ່ ໜ້າ ສົນໃຈແທ້ໆນີ້ທີ່ເອີ້ນວ່າການ ທຳ ລາຍ, ເຊິ່ງທ່ານສາມາດ ກຳ ຫນົດອົງປະກອບຕ່າງໆພາຍໃນຂບວນຫຼືວັດຖຸຕ່າງໆໃຫ້ກັບຕົວແປຕ່າງໆທີ່ມີ ຄຳ ສັບທີ່ຖືກຕ້ອງ.

JavaScript:

firstName, lastName = 'James Bond'.split ();
console.log (`ຂ້ອຍຊື່ $ {lastName}, $ {firstName} $ {lastName}`);

ແນ່ນອນວ່າທ່ານບໍ່ສາມາດເຮັດໄດ້ໃນ Ruby!

Ruby:

first_name, last_name = "James Bond" .split
ໃສ່ "ຊື່ຂອງຂ້ອຍແມ່ນ # {ນາມສະກຸນຊື່}, # {ຊື່ ທຳ ອິດ} # {ນາມສະກຸນຊື່}"

ໝາຍ ເຫດ: ໃນຂະນະທີ່ພວກເຮົາສາມາດ ທຳ ລາຍອາຄານໃນ Ruby ໄດ້ຫຼາຍເທົ່າທີ່ພວກເຮົາເຮັດໃນ JavaScript, ບໍ່ມີ Ruby ທຽບເທົ່າກັບ hashes ການ ທຳ ລາຍໂດຍກົງ.

ຜູ້ປະກອບການແຜ່ກະຈາຍ

JavaScript ທີ່ທັນສະ ໄໝ ຍັງໄດ້ແນະ ນຳ ຕົວປະຕິບັດການກະຈາຍທີ່ອະນຸຍາດໃຫ້ມີການຂະຫຍາຍການສະແດງອອກທີ່ມີການໂຕ້ຖຽງຫລືອົງປະກອບຂອງສູນຫຼືຫຼາຍກວ່ານັ້ນ.

JavaScript:

ຜົນບວກ (x, y, z) {
  ກັບຄືນ x + y + z;
};
const numbers = [1, 2, 3];
console.log (sum (... ຕົວເລກ);
[a, b, ... ສ່ວນທີ່ເຫຼືອ] = [10, 20, 30, 40, 50];
console.log (a);
console.log (b);
console.log (ສ່ວນທີ່ເຫຼືອ); // ສ່ວນທີ່ເຫຼືອແມ່ນ Array!

ໃນ Ruby, ພວກເຮົາມີຜູ້ປະຕິບັດການແບ່ງປັນ ສຳ ລັບສິ່ງນີ້.

Ruby:

def sum (x, y, z)
  x + y + z
ສິ້ນສຸດ
ຕົວເລກ = [1, 2, 3]
ເອົາ ຈຳ ນວນລວມ (* ຕົວເລກ)
a, * ສ່ວນທີ່ເຫຼືອ, ຂ = [10, 20, 30, 40, 50]
ເອົາ
ວາງຂ
puts rest # ສ່ວນທີ່ເຫຼືອແມ່ນ Array!

ໝາຍ ເຫດ: ທ່ານອາດຈະໄດ້ສັງເກດເຫັນວ່າໃນ Ruby * ສ່ວນທີ່ເຫຼືອແມ່ນຢູ່ລະຫວ່າງຕົວແປອື່ນໆ. ນັ້ນແມ່ນຕົວແຍກທີ່ສາມາດບັນຈຸທຸກບ່ອນໃນບັນດາຕົວແປຕ່າງໆ. ໃນ JavaScript, ຜູ້ປະຕິບັດການກະຈາຍຕ້ອງມາທີ່ສຸດ.

Ruby ຍັງມີຜູ້ປະຕິບັດການແບ່ງປັນສອງຊັ້ນ ** ເພື່ອເຮັດສິ່ງດຽວກັນໃນການເຮັດໃຫ້ເກີດຄວາມຫຍຸ້ງຍາກ. ສະເພາະຂອງ JavaScript ES2018 ແມ່ນແນະ ນຳ ຕົວປະຕິບັດການແຜ່ກະຈາຍຢູ່ເທິງວັດຖຸຕ່າງໆເຊັ່ນກັນ.

ຄຳ ສຸດທ້າຍ

ຕາມທີ່ທ່ານໄດ້ຮັບຮູ້ແລ້ວ, ທັງສອງພາສາບໍ່ແຕກຕ່າງກັນຫຼາຍຫຼັງຈາກທີ່ທັງ ໝົດ, ແລະດ້ວຍ ES6, ການຂຽນພາສາ JavaScript ໄດ້ກາຍເປັນສິ່ງທີ່ ໜ້າ ຍິນດີຫລາຍ. ໃຫ້ແນ່ໃຈວ່າ, JavaScript ແມ່ນພາສາຂອງຕົວທ່ອງເວັບແລະວົງຈອນເຫດການຂອງມັນສະ ໜອງ ພຶດຕິ ກຳ ທີ່ບໍ່ສະດວກ. ໃນທາງກົງກັນຂ້າມ, Ruby ມີເຄື່ອງມືທີ່ມີປະສິດທິພາບຫຼາຍໃນການເຮັດ metaprogramming ແລະເປັນທີ່ຮັກ ສຳ ລັບ syntax idiomatic. ໃນຕອນທ້າຍ, ຂ້ອຍຄິດວ່າມັນຈະເປັນປະໂຫຍດທີ່ຈະຮຽນຮູ້ແລະຮູ້ທັງສອງເລື້ອຍໆຍ້ອນວ່າຄວາມຮູ້ກ່ຽວກັບພາສາການຂຽນໂປແກຼມ ໜຶ່ງ ຈະຊ່ວຍໃຫ້ເຈົ້າມີຄວາມຄິດກ່ຽວກັບວິທີການລະຫັດຫຼືແກ້ໄຂບັນຫາໃດ ໜຶ່ງ ທີ່ແນ່ນອນໃນອີກດ້ານ ໜຶ່ງ.