הצגת קוד: רובי לעומת ג'אווה סקריפט

רובי ו- JavaScript עומדים ללכת ראש בראש. שתי שפות הסקריפט הללו מוקודדות באופן דינאמי ותומכות בתכנות מונחה עצמים. אנו נבדוק את ההבדלים או הדמיון שלהם בין חלק מהתכונות הנפוצות יותר שלהם.

הצהרת אחריות: אנו בודקים כאן רק תחביר מודרני של JavaScript ES6.

תצלום של Pramote Polyamate על 500 פיקסלים

אינטרפולציה מחרוזת

בתכנות מחשב, אינטרפולציה של מחרוזות היא תהליך של הזרקת ערך של משתנה או ביטוי במילולית מילולית.

ברובי זה נקרא, ניחשתם נכון, אינטרפולציה מחרוזת.

רובי:

first_name = "מרטין"
last_name = "Riggs"
מציב "היי, אני # {first_name} # {last_name}."

ב- Javascript, ניתן להשיג את אותו הדבר בעזרת אותיות מילולית.

JavaScript:

const firstName = 'מרטין';
const lastName = 'Riggs';
console.log (`היי, אני $ {firstName} $ {lastName}. ');

שיטות ופונקציות

ויקיפדיה מסבירה כי בתכנות מחשבים, תת-רוטינה היא רצף של הוראות תוכנה המבצעת משימה ספציפית, הארוזת כיחידה. לאחר מכן ניתן להשתמש ביחידה זו בתוכניות בכל מקום שיש לבצע את אותה משימה מסוימת.

בשפות תכנות שונות תתכנות תת-נקרא עשויה להיקרא נוהל, פונקציה, שגרה, שיטה או תוכנית משנה.

על מנת להשתמש בהם, יש צורך להגדיר תחילה את תת-השורות הללו ואז להתקשר אליו. ברובי הם ידועים כשיטות וב- JavaScript הם נקראים פונקציות.

רובי:

def full_name (שם פרטי, שם משפחה)
  "# {first_name.capitalize} # {last_name.capitalize}"
סוף
מכניס שם מלא ("ביטריקס", "קידו")

JavaScript:

פונקציה fullName (firstName, lastName) {
  להחזיר '$ {firstName.capitalize ()} $ {lastName.capitalize ()}';
};
console.log (fullName ("beatrix", "kiddo"));

אם אתה מריץ את הדוגמאות שלמעלה, בטח שמת לב שדוגמת JavaScript אינה פועלת, אך זורקת שגיאה: סוג לא טרח-סוג: טרור: firstName.capitalize אינה פונקציה!

הסיבה לכך היא ש- JavaScript לא מגדיר פונקציה של שימוש באותיות רישיות. לרובי יש הרבה שיטות אידיומטיות שימושיות ומסודרות כמו #capitalize שהן ממש נוחות. כדי שהדוגמה לעיל תעבוד, עלינו להשתמש בשרשרת האב-טיפוס (תיקון הקופים) באובייקט מחרוזת JavaScript:

String.prototype.capitalize = פונקציה () {
  להחזיר את זה. charAt (0) .toUpperCase () + this.slice (1);
}

חסימות

ברובי, בלוקים הם בעצם נתחי קוד שלא שמו עליהם שניתן להעביר אליהם וקוראים להם שיטות מבפנים. רבות משיטות האובייקט המובנות ברובי מקבלות בלוקים ואלה דרך נוחה לצבוט את אופן התנהגותם של שיטות כאלה.

רובי:

טיימר def
  start_time = Time.now
  מכניס "בלוק ריצה ..."
  
  תשואה
  מכניס "סיים!"
  end_time = Time.now - start_time
  "זמן ביצוע: # {end_time}"
סוף
מכניס טיימר {(0..10000000) .sort}

היי, ל- JavaScript אין חסימות, לכן היישום לעיל אינו אפשרי והשוואה מטופשת! או שזה? פונקציות JavaScript יכולות לקבל פונקציות התקשרות חוזרות כוויכוחים, ואם אנו חושבים שבלוקים של רובי דומים מאוד לשיטות אנונימיות אנו יכולים להשיג תוצאה דומה.

JavaScript:

טיימר פונקציות (התקשרות חוזרת) {
  const startTime = תאריך חדש (). getTime ();
  console.log ("הפעלת התקשרות חוזרת ...");
  
  התקשר חזרה();
  console.log ("סיים!");
  const endTime = תאריך חדש (). getTime ();
  להחזיר 'זמן ביצוע: $ {endTime - startTime}';
};
טיימר (() => Array.from (מערך (10000000). מפתחות ()). sort ());

הערה: בניגוד לרובי, ל- JavaScript אין אובייקט טווח מובנה. מקשי Array.from (Number). מקשי () למעלה מחזירים מערך מ- 0 למספר.

איטרציות אידיומטיות

רובי ידוע כמי שיש לו איטרטורים אידיומטיים נחמדים מאוד לעבור דרך מערכים (ועוד מבנים רבים מספור או איטרטיבי).

רובי:

names = ["טנגו", "מזומן", "דלתון", "ריגס"]
names.each do | name |
  שם שם
סוף

עם ES6, איטרציה דרך מערך ב- JavaScript הופכת לרוח:

JavaScript:

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

הערה: הפונקציה Javascript forEach יכולה גם לגשת לאינדקס האלמנט. ברובי היינו משתמשים באיטטור אחר לזה שנקרא each_with_index.

שיעורים וירושה כיתתית

בתכנות מונחה עצמים, המחלקות הינן תבניות קוד ליצירת אובייקטים, מתן ערכים למצב (תכונות או תכונות של האובייקט) ויישום התנהגות (כמו Getters and seters לקריאה וכתיבה של מאפיינים או תכונות כאלה).

רובי:

רכב בכיתה
  def אתחל (שם, סוג)
    @name = שם
    @type = סוג
  סוף
  שם def
    @name
  סוף
  סוג def
    @ סוג
  סוף
סוף
class רכב <רכב
  def אתחל (שם)
   סופר (שם, 'מכונית')
  סוף
סוף
דיאבלו = Car.new ("למבורגיני")
מכניס diablo.name
מכניס את הדיאבלו

JavaScript:

רכב בכיתה {
 
  בנאי (שם, סוג) {
    this.name = שם;
    this.type = type;
  }
 
  getName () {
    להחזיר את זה .name;
  }
 
  getType () {
    להחזיר את זה.
  }
 
}
class רכב מרחיב את הרכב {
 
  בנאי (שם) {
    סופר (שם, 'מכונית');
  }
}
const diablo = מכונית חדשה ('למבורגיני');
console.log (diablo.getName ());
console.log (diablo.getType ());

הערה: בדוגמה לעיל, המחלקה לרכב רובי תושם בדרך כלל באמצעות קורא תכונות כדי ליצור את שיטות הגטרה עבור משתני המופע. בחרתי לא להשתמש בקורא מאפיינים כדי שייראה יותר דומה ליישום JavaScript.

הרס

JavaScript מודרני הציג את הדבר המגניב הזה באמת שנקרא הרס, בו ניתן להקצות אלמנטים בתוך מערכים או חפצים למשתנים עם תחביר תמציתי.

JavaScript:

firstName, lastName = 'ג'יימס בונד'. ספליט ();
console.log (`שמי $ {lastName}, $ {firstName} $ {lastName}`);

בטח אי אפשר לעשות זאת ברובי!

רובי:

first_name, last_name = "ג'יימס בונד" .split
מציב "שמי הוא # {שם משפחה}, # {שם פרטי} # {שם משפחה}"

הערה: אמנם אנו יכולים להרוס מערכים ברובי ממש כמו שאנו עושים ב- JavaScript, אך אין רובי המקבילה לחיפושי הרס ישירים.

מפעיל מורח

JavaScript מודרני הציג גם את מפעיל התפוצה המאפשר להרחיב ביטויים חיבורים היכן שצפויים טיעונים או אלמנטים אפסיים או יותר.

JavaScript:

סכום פונקציה (x, y, z) {
  להחזיר x + y + z;
};
const numbers = [1, 2, 3];
console.log (סכום (... מספרים);
[a, b, ... rest] = [10, 20, 30, 40, 50];
console.log (א);
console.log (ב);
console.log (מנוחה); // מנוחה היא מערך!

ברובי, יש לנו את מפעיל הספלט לזה.

רובי:

סכום מוגדר (x, y, z)
  x + y + z
סוף
מספרים = [1, 2, 3]
מכניס סכום (* מספרים)
a, * מנוחה, b = [10, 20, 30, 40, 50]
מכניס א
מציב ב
מכניס מנוחה # מנוחה היא מערך!

הערה: בטח שמתם לב כי ברובי * המנוחה היא בין המשתנים האחרים. זה ניתן למקם את מפעיל הפיצול בכל מקום בין המשתנים. ב- JavaScript, מפעיל התפוצה חייב לבוא אחרון.

לרובי יש גם מפעיל הפיצול הכפול ** שיעשה את אותו הדבר על חשיש. מפרט ה- JavaScript ES2018 מציג גם את מפעיל הפיזור על עצמים.

מילה אחרונה

כפי שבטח הבנתם, שתי השפות אינן שונות כל כך, ועם ES6 JavaScript הפך נעים יותר ויותר לכתיבה. בטח, JavaScript היא שפת הדפדפן ולולאת האירועים שלו מספקת התנהגות אסינכרונית. מצד שני, לרובי יש כלים חזקים מאוד לביצוע תכנות מטא-אפ והוא אהוב על התחביר האידיוטי שלו. בסוף הסוף, אני חושב שמועיל ללמוד ולהכיר את שניהם כשלעיתים קרובות ידיעה בשפת תכנות אחת תתן לך רעיונות כיצד לתקן או לטפל בבעיה מסוימת בשפה אחרת.