TechCodeview

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

מהו משתנה?

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

אנו יכולים לבחור כל שם עבור המשתנה, אך עליו לעקוב אחר סמנטיקה של התכנות. כזה שיכול להיות , a, b, x, y, z, sub, div, total, avg וכו' .

נניח שיש שני ערכים, 10 ו-20, שאנו רוצים לאחסן ולהשתמש בתוכנית שלנו. לשם כך, עלינו להשתמש במשתנה, ונבצע את השלבים הבאים:

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

כפי שאנו יכולים לראות בתמונה שלמעלה, ישנם שני חריצי זיכרון, 001 ו-002, ונתנו שמות למיקומים אלה כ-A ו-B. A מכיל 10, ו-B מכיל 20.

לשפות תכנות שונות יש דרכים שונות להכריז על המשתנה. לדוגמה, בשפת C, אנו יכולים להכריז על המשתנה באופן הבא:

תחביר: (תחביר הצהרת משתנה בשפת C)

 datatype v1, v2, v3,....; 

דוגמא:

שיטת תת מחרוזת java

 #include void main(){ int a; int b; int sum; } 

היקף המשתנה

כל משתנה מוגדר וניתן להשתמש בו במסגרתו וקובע שבו התוכנית משתנה זה זמין לשימוש. המשמעות של ההיקף היא משך החיים של המשתנה הזה. המשמעות היא שניתן לגשת למשתנה או לגשת למשתנה רק במסגרתו.

ניתן להגדיר את היקף המשתנים בהצהרתם, ומשתנים מוצהרים בעיקר בשתי דרכים:

גובה kat timpf

משתנה גלובלי:מחוץ לכל הפונקציותמשתנה מקומי:בתוך בלוק פונקציות:

מהו משתנה גלובלי?

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

דוגמא:

 #include int a=50, b=40; void main() { printf('a = %d and b=%d',a,b); } 

בדוגמה שלמעלה, a ו-b הם המשתנים הגלובליים.

היתרונות של משתנה גלובלי

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

חסרונות של משתנה גלובלי

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

מהו משתנה מקומי?

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

דוגמא:

 #include void main() { int x=50, y=40; printf('x = %d and y=%d',x, y); } 

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

היתרונות של משתנה מקומי

• ניתן להשתמש באותו שם של משתנה מקומי בפונקציות שונות מכיוון שהוא מזוהה רק על ידי הפונקציה שבה הוא מוצהר.
• משתנים מקומיים משתמשים בזיכרון רק לזמן המוגבל שבו הפונקציה מבוצעת; לאחר אותו מיקום זיכרון ניתן לעשות שימוש חוזר.

חסרונות של משתנים מקומיים

• היקף המשתנה המקומי מוגבל לתפקוד שלו בלבד ולא ניתן להשתמש בו על ידי פונקציות אחרות.
• שיתוף נתונים על ידי המשתנה המקומי אינו מותר.

תרשים השוואה בין משתנה גלובלי למשתנה מקומי

דוגמאות להבנת ההבדלים בין משתנה מקומי לגלובלי

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

מקומי מול גלובלי ב-C

דוגמה-1:

 #include // Global variables int a; int b; int Add() { return a + b; } int Mul() { int c=10; //Local Variable int d=20; ////Local Variable return c*d; } void main() { int Ans1, Ans2, c=30;// Local variable a = 50; b = 70; Ans1 = Add(); Ans2= Mul(); printf('The addition result is: %d
',Ans1); printf('The Multiplication result is: %d
',Ans2); printf('%d
', c); } 

תְפוּקָה:

 The addition result is: 120 The Multiplication result is: 200 30 

כפי שאנו יכולים לראות בתוכנית לעיל, לקחנו א ו ב משתנים גלובליים שניגשים אליהם בפונקציות שונות כגון Add() ו-main(). ואילו ישנם גם משתנים מקומיים כגון c, d, Ans1 ו-Ans2, שאליהם נגישות הפונקציות רק בהן הם מוכרזים.

אם ננסה להשתמש במשתנים c ו-d מחוץ לפונקציה Mul() הם ישמשו כמשתנים חדשים. כפי שהראינו על ידי נטילת c בפונקציה main() גם, הוא מטופל כמשתנה חדש.

מקומי לעומת גלובלי בפייתון

דוגמה-1:

 v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) func1() #calling func1 def func2(): print(v1) func2() #callin func2 

תְפוּקָה:

שעועית ג'אווה

 Hey, I am a Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program. 

בתוכנית לעיל, לקחנו משתנה גלובלי אחד v1 ומשתנה מקומי אחד v2. מכיוון ש-v1 הוא גלובלי, ניתן לגשת אליו בקלות בכל פונקציה, ו-v2 הוא מקומי; הוא משמש רק במסגרת הפונקציה המוצהרת שלו. אבל אם ננסה להשתמש ב-v1 ב-func1, זה ייתן שגיאה. בוא נראה את הדוגמה הבאה:

דוגמה-2

 v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) print(v1) func1() #calling func1 def func2(): print(v1) print(v2) func2() #callin func2 

אם ננסה לגשת ל-v1, ניתן לגשת אליו בקלות ב-fun1 וב-func2. אבל אם ננסה לגשת ל-v2 מחוץ לפונקציה שלו, כלומר ב-func2, זה ייתן את שגיאת זמן הריצה. נקבל את הפלט שלהלן לאחר ביצוע הקוד לעיל:

שגיאת זמן ריצה:

 NameError: global name 'v2' is not defined 

תְפוּקָה:

 Hey, I am Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program. Hey, I am Global Variable!, I can be used everywhere in the program. 

מקומי לעומת משתנה גלובלי ב-Java

ב-Java, אין מושג של משתנים גלובליים; מכיוון ש-Java היא שפת תכנות מונחה עצמים, הכל הוא חלק מהכיתה. אבל אם אנחנו רוצים להפוך משתנה לנגיש גלובלית, אנחנו יכולים להפוך אותו לסטטי באמצעות a סטָטִי מילת מפתח.

 class Demo { // static variable static int a = 10; // non-static or local variable int b = 20; } public class Main { public static void main(String[] args) { Demo obj = new Demo(); // accessing the non-static variable System.out.println('Value of non-static variable is: ' + (obj.b)); // accessing the static variable System.out.println('Value of static variable is:' + (Demo.a)); } } 

תְפוּקָה:

 Value of non-static variable is: 20 Value of static variable is:10 

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