ויקיפדיה

אייפל (שפת תכנות) – הבדלי גרסאות

עיון אינטראקטיבי בהיסטוריה
→ העריכה הקודמתהעריכה הבאה ←
תוכן שנמחק תוכן שנוסף
חזותיקוד ויקי
מ הגהה
הגהה, ניסוח, הרחבה, עריכה, עדכון, תקלדה, ויקיזציה, עיצוב. הערך עבר תיקונים באופן מקיף. הוא היה במצב רע מאוד עם שגיאות כתיב ודקדוק. כעת הוא קריא ומובן יותר.
שורה 1:
{{שפת תכנות
| שם =אייפל
| שם בשפת המקור = Eiffel
}}
'''אייפל''' (במקור: '''Eiffel''') היא שפת [[תכנות מונחה עצמים]]. שפה זו נוצרה בידי [[ברטראנד מאייר]], (שהיהחלוץ חסיד של תכנותבתכנות מונחה עצמים) , ועל ידי חברת Eiffel Software ב-ב־[[1985]]. ונקראה על שם [[גוסטב אייפל]], המהנדס שתכנן את [[מגדל אייפל]].
 
השפה נועדהבאה לשפרלענות על חסרונותיהן של שפות OOPתכנות מונחות עצמים קודמות לה. כתיבת השפה הושפעה מהשפות [[פסקל (שפת תכנות)|פסקל]], [[Simula]], {{כ}}[[Ada]]{{כ}}, [[Z (שפת תכנות)|Z]] ושימשה השראה לשפות פופולריות כמו: [[C sharp|C#]]{{D}},{{כ}} [[Java]]{{כ}}, [[Ruby]]{{כ}}, [[D (שפת תכנות)|D]], ועוד. מושגים רבים שהוצגו לראשונה על ידי אייפל, לאחר מכן מצאו את דרכם לשפות תכנות מודרניות כ-Javaכ־Java,{{כ}} C#{{D}} ושפות אחרות.
 
מאייר כתב ספר על תכנות מונחה עצמים (''Object-Oriented Software Construction''), בספר ניסח כללים לפרידגמהל[[פרדיגמת תכנות|פרדיגמה]], שלבסוף הפכו לשפה עצמה.
 
== מאפיינים עיקריים ==
* '''יבילות[[חוצה-פלטפורמות|חוצה פלטפורמות]]''' - רץרצה על פלטפורמות שונות.
* '''Meltingהידור בזמן iceריצה''' - שילוב של הידור ומפרש שרץ ב-Byte Codeב־[[בייטקוד]].
* '''Design[[חוזה by(תכנות)|תכנון contractלפי חוזה]]''' - יצירת [[חוזה (תכנות)|חוזה]] בעבודה עם קטעי קוד.
* '''[[מערכת טיפוסים|טיפוסיות]] חזקה''' (Strong type)- ללא המרות מרומזות.
* '''טיפוסיות קבועה''' - דורשת הגדרה והתאמת טיפוסיות בזמן הידור.
* '''קישור דינמי''' (Dynamic bounding) בזמן ריצה. מאפשר [[פולימורפיזם (מדעי המחשב)|פולימורפיזם]].
* '''[[קישור דינמי]]''' - קישור בזמן ריצה. מאפשר [[פולימורפיזם (מדעי המחשב)|פולימורפיזם]].
* '''קריאות''' - מנגנונים ללוגיקה, מבניות בקוד ותיעוד.
* '''קריאות''' - מנגנונים ללוגיקה, מבניות בקוד ותיעוד.
* '''Statically typed''' - מצריכה הגדרה בזמן הידור.
* '''תיעוד אוטומטי'''.
* '''מחלקות [[תכנות גנרי|גנריות]]''' - מאפשרת שימוש במחלקות גנריות.
* '''העמסת שיטותמתודות''' (Method overloading) - ניתן לבצע חפיפת מתודות של השפה.
* '''העמסת אופרטורים''' (Operators overloading) - ניתן לבצע חפיפת אופרטורים של השפה.
* Pointerחשבון Arithmetic[[מצביע|מצביעים]] לא קיים בשפה.
* [[ביטוי רגולרי|ביטויים רגולריים]] לא קיימים בשפה.
 
==עקרונות עיקריים==
===designתכנות byלפי contractחוזה===
{{הפניה לערך מורחב|חוזה (תכנות)}}
"[[חוזה (תכנות)|חוזה]]" הן למעשה קבוצה של התניות שמוגדרות על ידי המתכנת, המגדיר את כל הממשק וההשפעות של התוכנית על סביבתה, בכך ניתן להקל על כל מי שרוצה להשתמש בצורה הכי בטוחה והכי יעילה. העיקרון הומצא על ידי ממציא השפה וזאת אחת התכונות החשובות של השפה.
חוזה הוא קובץ אילוצים המוגדר על ידי המתכנת על מנת להבטיח את אמינות הקוד. העיקרון הומצא על ידי ממציא השפה וזאת אחת התכונות החשובות של השפה. בשפות תכנות עכשוויות נעשה שימוש ב[[פיתוח מונחה-בדיקות|פיתוח מונחה בדיקות]] כתחליף לתכנות מונחה חוזים.
לכל פונקציה ניתן להצהיר:
לכל פונקציה ניתן להצהיר את האילוצים הבאים.
*תנאים לפני הרצת הפונקציה (Pre Conditions)
*תנאים לאחרלפני הרצתביצוע הפונקציה (Post Conditionspre-conditions).
*תנאים לאחר ביצוע הפונקציה (post-conditions).
*מגבלות לגבי תוכן הפרמטרים שהפונקציה מקבלת.
*מגבלות לגבי התוכן שהפונקציה מחזירה.
*מגבלות לגבי תוכן [[חריגה|החריגות ]] שהפונקציה יכולה לזרוק (Exception).
*תופעות לוואי של הרצת הפונקציה (לדוגמה, שימוש בלולאה לצורך השהייה).
*נתונים על הביצועים שלה (זיכרון, זמן ריצה).
*ביטויים קבועים לאורך התוכנית (Invariantinvariant).
 
"''Design by contractContract''" הוא סימן רשום של [[Eiffel softwareSoftware]], והמונח הוטמע והומצא על ידי ד"ר ברנרד מאייר, יוצר השפה. ולכןעובדה "החוזה"זאת הואמאוששת חלקאת מאודחשיבות החוזה כמרכיב מרכזי בשפת התכנות אייפל.
 
==== דוגמה ל-Designלשימוש by contract class DATEבחוזה ====
<syntaxhighlight lang="eiffel">
create
שורה 80 ⟵ 81:
</syntaxhighlight>
 
===עקרון פתיחות/סגירות===
===Open Closed principle===
{{הפניה לערך מורחב|עקרון פתיחות/סגירות}}
קוד צריך להיות פתוח להרחבה וסגור לשינויים, והדבר יכול להתבטא בשתי צורות:
הקוד הקיים (מתוך [[ספרייה (תכנות)|ספריות]]) צריך להיות פתוח להרחבה, אך סגור לשינויים, והדבר יכול להתבטא בשתי צורות הבאות.
#בצורה שהדבר מתבטא בשפת אייפל - כותבים מחלקה בצורה רגילה, ואם מתגלה באג בתוכנה, במקום לשנות את המחלקה המקורית, יוצרים מחלקה חדשה שמשתמשת במחלקה הקודמת ועושה את השינויים שנצרכים, או שיוצרים מחלקה שיורשת מהמחלקה המקורית שבה עושים את השינויים.
#כפי שהעיקרון מתבטא בשפת אייפל - כותבים מחלקה בצורה רגילה, ואם נתפס [[באג]] בתוכנה, אז במקום לשנות את המחלקה המקורית, יוצרים מחלקה חדשה שמשתמשת במחלקה הקודמת ועושה את השינויים הדרושים, או שיוצרים מחלקה שיורשת מהמחלקה המקורית שבה עושים את השינויים.
#בצורה הרגילה שימוש במחלקה אבסטרקטית, וירושות ממנה בצורה כזאת שכולם צריכים להיות באותה התבנית, ואז מקשרים את כולם בפולימורפיזם.
#בצורה הרגילה. שימוש במחלקה מופשטת, וירושה המאלצת הלימה לממשק ההפשטה. מכאן עקרון הפולימורפיזם בתכנות מונחה עצמים יאפשר שימוש עם תאימות לאחור בקוד הקיים.
 
===עקרון הגישה האחידה===
===Uniform access principle===
כיוון שיש שינויים ותוספות של אובייקטים חדשים לשפה, דאגו לעשות שכל הפניות יהיו באותה צורה כדי לחסוך תקלות. ולכן יש מנגנון גישה זהה לכל הפונקציות והמחלקות. לדוגמה הסימון <code>Foo.Bar(5)</code> יכול לשמש בתור קריאה לפונקציה ושליחת הערך 5 כפרמטר, ויכול גם לשמש לאתחול מחלקה שהמשתנה שלה יקבל את הערך 5.
לדוגמה:
 
===עקרון הפרדת פקודות משאילתות===
([[Foobar|Foo.bar]] (5
הפרדה מוחלטת בין פונקציה שמחזירה ערך, כלומר בקשת מידע ואשר אינה יכולה בשום אופן לעדכן מידע, לבין פרוצדורה המעדכנת או מבצעת פעולה, אך אינה מחזירה מידע. עקרון זה ידוע יותר ב[[תכנות פונקציונלי]] באופן מקובל יותר כהפרדת פונקציות ''פונקציונליות גרידא'' מפונקציות שאינן פונקציונליות גרידא ולהן ''תוצאות לוואי''. מעצב השפה כינה פונקציות עם תוצאות לוואי כ־"פקודות", ופונקציות פונקציונליות גרידא כ־"שאילתות", אך המינוח הזה אינו נהוג בשפות אחרות.
 
יכול לשמש בתור פונקציה שמקבלת את הערך 5 ויכול גם לשמש בתור מחלקה שהמשתנה שלה יקבל את הערך 5.
 
===Command Quiery seperetion===
הפרדה מוחלטת בין פונקציה שמחזירה ערך, כלומר בקשת מידע ואשר אינה יכולה בשום אופן לעדכן מידע, לבין פרוצדורה המעדכנת או מבצעת פעולה, אך אינה מחזירה מידע. וזאת על מנת לא ליצור Side effects שלא שהמתכנת לא התכוון אליהם.
 
===תאימות לשפות אחרות===
השפה בנויה כך שתוכל להתממשק בקלות עם מגוון שפות (בדגש על שפת [[C (שפת תכנות)|C]], ושפות התכנות מבוססות ו[[.NET|דוט נט]]). אפשרהשפה אפילומאפשרת לכתוב קוד בשפת C הישר בגוף הפונקציה של Eiffel, ובכך להשלים כל חיסרון שעלול להיות בשפה עם הספריות של שפת C.{{דרוש מקור|סיבה=}}
 
==ניהול זיכרון==
ניהול זיכרון של תוכנית בשפת Eiffel היא משימה לאהוא קלהמאתגר בגללכהשלכה שלושמהנסיבות סיבות:הבאות.
# תוכנית בשפת Eiffel יכולה לקרוא לפונקציות בשפת C, לכן צריך להתחשב בכך שיכולותשיכולים להיות בתוכנית 2שני סוגי זיכרון: זיכרון ל-Eiffelל־Eiffel וזיכרון ל-Cל־C.
# צריך להבחין בין אובייקטים רגילים - אובייקטים בעלי גודל קבוע שנקבע באופן סטטי (בזמן ההידור) על פי מספר תכונות האובייקט -, לבין אובייקטים מיוחדים - אובייקטים בעלי גודל משתנה (מערכים, מחרוזות ועוד).
# לא מספיק לשחרר זיכרון רק לשם שימוש חוזר בתוכניות בשפת Eiffel, אלא אנו מעוניינים שניתן יהיה להחזיר את הזיכרון אל מערכת ההפעלה לשימוש חוזר גם באפליקציות אחרות.
 
מסיבות אלה, Eiffel אינה מסתפקת ב-ב־<code>syscall malloc()</code>{{D}} (שכן <code>malloc()</code>{{D}} לא יכול להחזיר את הזיכרון אל מערכת ההפעלה), אלא יש לה מנגנון לניהול זיכרון משלה.
 
כמו כן, על מנת לפתור את בעיית ה-[[איסוף זבל (מדעי המחשב)|Garbageאיסוף Collectionהזבל]], השפה אינה מסתפקת באלגוריתם מוכןיחיד לביצועלאיסוף Garbage Collectionזבל, אלא היא משתמשת בכמה אלגוריתמים בסיסיים, ובכל פעם שיש צורך ב-GC, בחירת האלגוריתם נקבעהמיטבי נקבעת לפי הנסיבות ורמת הדחיפות.
 
שני האלגוריתמים העיקריים לאיסוף זבל בשפת Eiffel, הם '''mark & sweep''', ו־'''memory compaction'''. כברירת מחדל, כל יישום בשפת Eiffel כולל איסוף זבל אוטומטי. אבל בכל אופן ניתן לשלוט על מנגנון ניהול זיכרון ולכוון אותו כך שיתאים לצרכים הספציפיים של המתכנת באמצעות פונקציות ופרוצדורות השייכות למחלקה <code>MEMORY</code>, המאפשרות למתג את תהליך איסוף הזבל האוטומטי.
שני האלגוריתמים העיקריים למימוש GC בשפת Eiffel, הם:
* Mark & Sweep
* Memory Compaction
כברירת מחדל, כל יישום בשפת Eiffel כולל GC אוטומטי. אבל בכל אופן ניתן לשלוט על מנגנון ניהול זיכרון ולכוון אותו כך שיתאים לצרכים הספציפיים של המתכנת באמצעות פונקציות ופרוצדורות השייכות למחלקה MEMORY, שמאפשרים "להדליק" או "לכבות" את ה-GC האוטומטי.
 
המאפיין הייחודי של ה-GCמאסף הזבל של Eiffel הוא שה-GC אינושאינו מבצע שחרור זיכרון רק עבור שימוש חוזר על ידי הקצאת אובייקטים נוספים לאותה תוכנית, אלא למעשה, מחזיר את הזיכרון למערכת ההפעלה ומשחרר אותו לשימוש חוזר על ידי תוכנית אחרת. למרות שקשה ליישם את המאפיין החשוב הזה, הוא הכרחי בעיקר למערכות שצריכות לרוץ במשך הרבהלאורך זמן, או אפילו באופן קבוע.
 
== מבנה השפה ==
=== משתנים פשוטים ===
נקראים גם <code>EXPANDED</code>
 
הגדרת משתנים נעשית בדרך דומה לשפת [[פסקל (שפת תכנות)|פסקל]]:, שם המשתנה נכתב מצד שמאל לאחריו נקודתיים ושם הטיפוס.
 
<syntaxhighlight lang="eiffel">
שורה 136 ⟵ 130:
</syntaxhighlight>
 
=== אובייקטיםעצמים ===
נקראים גם <code>REFERENCE</code> ומכילים [[אובייקט (מדעי המחשב)|אובייקטיםעצמים]] או מערכים. לדוגמה:,
 
<syntaxhighlight lang="eiffel">i: MYoBJ</syntaxhighlight>
שורה 144 ⟵ 138:
{| cellspacing="1" cellpadding="1" border="1" align="center" style="width: 284px; height: 200px;"
|-
! !! ערך !! משתנה טיפוס
|-
| 1 || align="center"| <code>0</code> || align="center" | <code>INTEGER </code>
|-
| 2 || align="center" | <code>0</code> || align="center" | <code>REAL </code>
|-
| 3 || align="center" | <code>0</code> || align="center" | <code>DOUBLE</code>
|-
| 4 || align="center" | <code>FALSE</code> || align="center" | <code>BOOLEAN</code>
|-
| 5 || align="center" | <code>NULL</code> || align="center" | <code>CHARACTER</code>
|-
| 6 || align="center" | <code>VOID REFERENCE</code> || align="center" | <code>REFERENCE TYPE</code>
|}
 
=== מערכים - ARRAY ===
נקראים <code>ARRAY</code>. הכרזה לדוגמה,<syntaxhighlight lang="eiffel">keywords : ARRAY[STRING]
הצהרה:
 
<syntaxhighlight lang="eiffel">keywords : ARRAY[STRING]
numbers: ARRAY[INTEGER]</syntaxhighlight>
 
יצירה (מערך מ-1 עד 100):.
 
<syntaxhighlight lang="eiffel">create keywords.make(1,100)</syntaxhighlight>
 
=== רשומה ===
נקראנקראת tuples<code>TUPLE</code>, מקבילה של struct<code>STRUCT</code> או class<code>CLASS</code> ללא פונקציות, רקאלא dataרק members:נתונים.
 
<syntaxhighlight lang="eiffel">
שורה 182 ⟵ 174:
</syntaxhighlight>
 
גישה: <syntaxhighlight lang="eiffel">
 
t.weight := t.weight + 0.5
שורה 201 ⟵ 193:
| 4 || שונה || align="center" | =/
|-
| 5 || גדול או שווה || align="center" | =<
|-
| 6 || קטן או שווה || align="center" | =>
|-
| 7 || השמההקצאה || align="center" | =:
|}
 
=== IFתנאי ===
'''if''' תנאי
'''then''' גוף
שורה 228 ⟵ 220:
</syntaxhighlight>
 
=== LOOPלולאה ===
'''from''' תנאי התחלה
'''until''' תנאי עצירה
שורה 243 ⟵ 235:
 
===פונקציות ופרוצדורות===
במינוח השפה ישנה הסכמה בשפה לגבי הפרדה גמורה בין פונקציות לביןללא תוצאות לוואי ופונקציות עם תוצאות פרוצדורותלוואי.
:פונקציות - עושות חישובים ומחזירות ערך, אבל לא יכולות לבצע שינויים במשתנים.
:פרוצדורות - עושות שינויים במשתנים, אבל לא מחזירות ערך.
בצורה כזאת, אפשר לשלוח פונקציה בלי לדאוג שישתנו דברים בתוכנית. אך בפועל בשפה הקומפיילר לא אוכף נושא זה.
שם הפונקציה בסוגרים פרמטרים ואחרי ערך מוחזר (אפשר להשמיט ערך מוחזר או פרמטרים או שניהם) ה-IS מכיל הערה שמתארת את הפונקציה.
 
'''פונצקיות''' - עושות חישובים ומחזירות ערך, אבל לא יכולות לבצע שינויים במשתנים.
=== CLASS ===
תוכנית אייפל ידועה כמערכת, ומרכיביה הם מחלקות. יכול להיות מספר כלשהו של מחלקות במערכת. רבות מהן מחלקות כלליות. וחלקן מחלקות השייכות למערכת. המערכת פיתוח אייפל מגיעה עם ספריות עם מחלקות מובנות בעלות יעוד. מחלקות בסיסיות רבות מוגדרות בשפה, והן חייבות להופיע.
 
'''פרוצדורות''' - עושות שינויים במשתנים, אבל לא מחזירות ערך.
*'''note''' - הערות המחלקה
 
*'''class''' - שם המחלקה
בצורה כזאת, אפשר לשלוח פונקציה בלי לדאוג שישתנו דברים בתוכנית. אך בפועל המהדר אינו אוכף נושא זה. אחרי שם הפונקציה באים הפרמטרים בסוגרים, ואחר כך הערך המוחזר (אפשר להשמיט את הערך המוחזר, את פרמטרים, או את שניהם) ה־<code>IS</code> מכיל הערה שמתארת את הפונקציה.
*'''inherit''' - ממי יורש (אופציונלי)
 
*'''create''' - פונקציות מאתחלות
=== מחלקות ===
*'''local''' - משתני מחלקה
כמו בשפות [[תכנות מונחה-עצמים|תכנות מונחות עצמים]] אחרות, ב־Eiffel מגדירים תבנית לעצמים בעזרת [[מחלקה (תכנות)|מחלקה]].
*'''do-end''' - גוף המחלקה
 
'''note''' - תיעוד המחלקה.
'''class''' - שם המחלקה.
'''inherit''' - ירושה (אפשרות).
'''create''' - פונקציות מאתחלות.
'''local''' - משתני מחלקה.
'''do'''...'''end''' - גוף המחלקה.
 
<syntaxhighlight lang="eiffel">note
שורה 286 ⟵ 280:
</syntaxhighlight>
 
== מנגנון ניהוללטיפול חריגותבחריגות ==
לשפה קיים מנגנון חזק ל[[טיפול בחריגות]] המבצע מספר נסיונות שהוגדרו לו מראש על מנת לטפל בחריגה בזמן הריצה. הגדרת ההצלחה לטיפול נעשת לפי בדיקת ה־post-condition של החוזה שהוגדר לו מראש.
לשפה יש מנגנון מאוד יעיל של ניהול חריגות שעובד בצורה כזאת שהוא משתמש בבדיקת ה-Post condition שלו, ובמקרה שזה לא עובר, הוא עושה את הפונקציה מחדש בשביל לנסות שוב לפי מספר הניסיונות שהוגדרו לו מראש.{{ש}}לדוגמה:
<syntaxhighlight lang="eiffel">
connect_to_server (server: SOCKET) -- Connect to a server or give up after 10 attempts.
שורה 307 ⟵ 301:
 
==אפשרויות שונות בשפה==
'''קריאות חד פעמיות''' - משמש לאיפוס ערכים באובייקטים ועובד בצורה קלה ונוחה.
 
'''מנגנון ניהול חריגות''' - לשפה יש מנגנון מאוד יעיל של ניהול חריגות שעובד בצורה כזאת שהוא משתמש בבדיקת ה-Post condition שלו, ובמקרה שזה לא עובר, הוא עושה את הפונקציה מחדש בשביל לנסות שוב לפי מספר הניסיונות שהוגדרו לו מראש.
 
'''השפה משלבת שתי גישות לתרגום''' – יש לה גם מפרש, וגם מהדר. קוד שלא נעשה בו שינוי מאז הפעם האחרונה, כולל ספריות מערכת, הוא קוד שעבר הידור – ולכן במינוח השפה הוא ''קפוא''. קוד ששונה ''הותך'', ועל ההרצה שלו מופקד המפרש של השפה.
קוד שלא נעשה בו שינוי מאז הפעם האחרונה, כולל ספריות מערכת, הוא קוד שעבר הידור – ולכן הוא "קפוא".
קוד ששונה "הותך", ועל ההרצה שלו מופקד המפרש של השפה.
 
היתרון של הטכנולוגיה, הוא שהיא נותנת לנו ליהנות מכל העולמות - מהירות הריצה שמספק קוד שכבר תורגם במלואו לשפת מכונה על ידי המהדר, ומהירות תגובה לשינויים בעזרת קוד מפורש.
 
== חווית מתכנת ==
השפה מתאימה למתכנתים שצריכים לתאם ביניהם ממשקים, או שהשימוש בקוד לא ידוע מראש (ירושה מבוקרת). הכתיבות (רמת הקושי בכתיבה) של השפה היא סבירה, דרוש זמן להתרגל אליה, וכן יש תיעוד מקיף על השפה, היתרנו שהוא מפורט היטב, אך חסרונו שהוא שהתיעוד היחיד של השפה.
 
==תרגום לשפת מכונה==
ב־Eiffel יש שני שלבי תרגום. החלק הראשון הוא הידור לקוד ביניים בעזרת מהדר, עליו רץ מפרש. אחר כך, הקוד מתורגם לשפת C, ובעזרת מהדר C הוא מהודר לשפת מכונה. לטענת מתכנני השפה, מטרת התרגום לשפת C כשפת ביניים, הוא ניצול שיטות הייעול הקיימות במהדרי שפת C. (לטענת מעצבי השפה, קוד בשפת Eiffel יכול להיות יעיל כאילו נכתב בשפת C עצמה או [[Fortran]]).
באייפל יש שני שלבי תרגום:
החלק הראשון הוא הידור לקוד ביניים בעזרת מהדר, עליו רץ מפרש.
אחר כך, הקוד מתורגם לשפת C, ובעזרת מהדר C הוא מהודר לשפת מכונה.
 
לפי מתכנני השפה, מטרת התרגום לשפת C כשפת ביניים, הוא ניצול שיטות הייעול הקיימות במהדרי שפת C. (לטענת מעצבי השפה, קוד בשפת Eiffel יכול להיות יעיל כאילו נכתב בשפת C עצמה או Fortran).
 
== חווית המשתמש ==
התוכנה מתאימה לכותבים שצריכים לתאם ביניהם ממשקים, או שהשימוש בקוד לא ידוע מראש (ירושה מבוקרת).
ה-Writeabilty (הכתיבות) סביר, דרוש מעט זמן להתרגל לשפה, וכן יש תיעוד רב על השפה. היתרון הוא שהוא מפורט והחיסרון שהוא כמעט היחיד (ראו למטה בקישורים).
 
==הערות כלליות==
*השפה היא Case insensitive - הקומפיילר אינו מבחין בין אותיות גדולות וקטנות, אבל מקובל להשתמש בסגנון כתיבה קבוע לשפה, כדי לעשות את הקוד קריא לכל מי שמכיר את השפה. ולכן נוהגים לכתוב: מחלקות - באותיות גדולות, פונקציות - באותיות קטנות, משתנים - אות ראשונה גדולה והשאר קטנות, מספר מילים - כותבים עם קו תחתון בין המילים.
* באייפל אין חובה להבדיל בין פקודות באמצעות נקודה פסיק (;) בסוף שורה.
* יש להבדיל בין אופרטור שוה (=) שמחזיר ערך בוליאני ואינו מבצע השמה לבין אופרטור השמה (=:)
* הסימן -- (מינוס כפול) מבטא הערה.
* פונקציות יצירה הם סוג של פונקציות בונות (אלא שקוראים להן אקטיבית) המשמשות לאתחול והגדרות המחלקה יש להגדיר פונקציות כאלה בחלק CREATE במחלקה ולממשן בחלק FEATURS כמו כל שאר הפונקציות.
* חלק IS בהגדרת הפונקציה מכיל הערה הממצה את מהות המחלקה ("מטפורה").
* פונקציות נקראות בדומה למשתנים ולכן המשתמש לא צריך לדעת את אופן המימוש.
* השפה מאד מבנית, משתמשת בבלוקים לכל קבוצת קוד. בדומה ל-ADA.
 
==בעיות ופתרונן==
*כאשר פונקציה מחזירה פרמטר יש להשתמש בפרמטר המובנה בשפה RESULT לצורך החזרה.
*אין נגישות למערך אחרי הגדרתו. יש לעשות CREATE לאובייקטים כגון מערכים, קבצים וכו'.
*בטיפוס מסוג אובייקט בברירת מחדל השמה מחזירה מצביע לאובייקט ולכן אם הוא נמחק קיים מצביע מתנדנד ולכן רצוי להשתמש ב-CLONE או COPY.
* קיים קושי במציאת מדריך שפשוט מראה פקודות ולא רק מדבר על תאוריה של השפה.
* פתיחת קבצים נעשית בצורה שונה מתוכניות אחרות, צריך להכניס את מיקום הקובץ למשתנה ורק אחרי זה להתחיל לפעול עליו.
* מערכת שונה של החזרת ערך מהפונקציה במקום לעשות return מכניסים את הערך שרוצים אל המשתנה result. (בדומה ל-PL/SQL)
 
==תחביר==
== פלטפורמות==
*המהדר אינו מבחין בין [[אותיות רישיות ואותיות קטנות|אותיות גדולות וקטנות]], אבל מקובל להשתמש בסגנון כתיבה קבוע לשפה כדי לשמור על הקוד קריא לכל מי שמכיר את השפה. נוהגים לכתוב שמות של מחלקות באותיות גדולות, שמות פונקציות באותיות קטנות, שמות משתנים עם אות ראשונה גדולה והשאר קטנות, צירוף מילים כותבים תמיד עם קו תחתון בין המילים.
אייפל רצה על הפלטפורמות הבאות: Windows,{{כ}} Linux,{{כ}} Unix,{{כ}} VMS.
* ב־Eiffel אין חובה להפריד בין פקודות באמצעות נקודה פסיק <code>;</code> בסוף שורה.
* יש להבדיל בין אופרטור הבדיקה <code>=</code> המחזיר ערך בוליאני (אמת או שקר) כתוצאה של הערכת תנאי, לבין אופרטור ההקצאה <code>=:</code>.
* הסימון <code>--</code> (מינוס כפול) פותח הערה באותה שורה.
* פונקציות יצירה הן סוג של פונקציות בונות (אלא שקוראים להן אקטיבית) המשמשות לאתחול והגדרות המחלקה. מגדירים פונקציות כאלה בחלק <code>CREATE</code> במחלקה, אך ממשים אותן בחלק <code>FEATURS</code> כמו כל שאר הפונקציות.
* החלק <code>IS</code> בהגדרת הפונקציה מכיל הערה הממצה את מהות המחלקה ("מטפורה").
* פונקציות נקראות באופן דומה למשתנים, ולכן המתכנת לא צריך לדעת את אופן המימוש.
* השפה [[תכנות מובנה|מבנית]], נכתבת בבלוקים לכל קבוצת קוד באופן דומה לשפת התכנות [[עדה (שפת תכנות)|עדה]].
* כאשר פונקציה מחזירה פרמטר, משתמשים בפרמטר המובנה בשפה <code>RESULT</code> לצורך החזרה. (בדומה ל-PL/SQL)
*אין נגישות למערך אחרי הגדרתו. לכן מאתחלים עצמים כגון מערכים, וקבצים בעזרת <code>CREATE</code>.
*בטיפוס מסוג עצם בברירת מחדל הקצאה מחזירה מצביע לעצם, ולכן אם הוא נמחק קיים מצביע מתנדנד ולכן רצוי להשתמש ב־<code>CLONE</code> או <code>COPY</code>.
 
== מהדריםיישומי השפה==
Eiffel רצה על [[Windows]], [[Linux]], [[Unix]], [[OpenBSD]], [[FreeBSD]], [[macOS]], ו־[[OpenVMS]].
*[http://smarteiffel.loria.fr/ smartEiffel - מהדר חינמי קוד פתוח מתאים לכל מחשב ANSI C]
*'''EiffelStudio''' - סביבת הפיתוח והמהדר העיקריים של השפה, פותחו ועוצבו על ידי מתכנני השפה. הסביבה חינמית אך ורק לפיתוח [[תוכנה חופשית]].<ref>{{קישור כללי|כתובת=https://www.eiffel.org/doc/eiffelstudio|כותרת=EiffelStudio|אתר=www.eiffel.org|תאריך=2020-05-22|תאריך_וידוא=2020-07-17}}</ref>
*[http://visual-eiffel.com visual eiffel - מסחרי IDE כולל GUI עובד על Win32,{{כ}} Linux]
*'''SmartEiffel''' - מהדר חינמי קוד פתוח מתאים לכל מעבד ANSI C.<ref>{{קישור כללי|כתובת=http://smarteiffel.loria.fr/|כותרת=SmartEiffel, the GNU Eiffel Compiler, Tools and Libraries|אתר=smarteiffel.loria.fr|תאריך_וידוא=2020-07-17}}</ref>
*[http://sourceforge.net/projects/eiffelstudio/?source=directory EiffelStudio - חינמי IDE מתקדם כולל GUI אחד העורכים המתקדמים], זוהי סביבת הפיתוח הכי עדכנית, כולל Debugger והשלמה אוטומטית. כמו כן, יש בו יוצר תיעוד ותרשים מערכת (class Diagram).
*'''Visual Eiffel''' - סביבת פיתוח מסחרית IDE כולל GUI עובד על Win32, Linux.<ref>{{קישור כללי|כתובת=http://visual-eiffel.com/|כותרת=Visual-Eiffel|אתר=visual-eiffel.com|תאריך_וידוא=2020-07-17}}</ref>
 
== הערות שוליים ==
{{הערות שוליים}}
[[קטגוריה:תכנות מונחה-עצמים]]
[[קטגוריה:שפות תכנות מונחות עצמים]]
אוחזר מתוך "https://he.wikipedia.org/wiki/אייפל_(שפת_תכנות)"