نوشته های سعید فراهانی

ثابت ها (Constants) در زبان برنامه نویسی Go

سعید فراهانی — Tue, 26 Sep 2023 17:21:02 +0330

ثابت (Constant) چیزی است که مقدار آن تغییر نمیکند. یک ثابت در زبان برنامه نویسی Go می تواند از نوع رشته، عددی، بولی و کاراکتر باشد.یک ثابت را می توان با استفاده از کلمه کلیدی const اعلام کرد. نکته مهمی که باید به آن توجه داشت این است که مقدار باید در حین اعلام یک ثابت تخصیص داده شود. بر خلاف متغیرهایی است که می توان بعداً مقدار را به آن اختصاص داد.اعلام یک ثابت همراه با تعیین نوع: با یک کلمه کلیدی const شروع می شود، سپس نام و سپس نوع. مقدار نیز باید تخصیص داده شود:const c string = "circle"اعلام یک ثابت بدون تعیین نوع: یک ثابت تعریف شده بدون اینکه نوع آن مشخص شود، یک ثابت بدون نوع (untyped) است. در ادامه بیشتر با ثابت دارای نوع و بدون نوع آشنا خواهیم شد. در حال حاضر، مهم است بدانید که ثابت بدون نوع اعلام شده دارای یک نوع پنهان پیش فرض است. زمانی که به هر طریقی به متغیری اختصاص داده شود، با توجه به مقدار آن یک نوع داده به آن اختصاص می یابد (مقدار دهی اولیه مستقیم، ارسال به یک تابع و غیره).const c = "circle"اعلان چند ثابت با هم:const ( c = "circle" s = "square" )نکات مهمیک ثابت پس از اعلان، مجددا قابل تخصیص نیست. به عنوان مثال کد زیر یک خطای کامپایل ایجاد می کندpackage main func main() { const a int = 8 a = 9 }خطا:main.go:5:4: cannot assign to aمقدار ثابت باید در زمان کامپایل حتما مشخص باشد. بنابراین نمی توان به یک ثابت، یک مقدار حاصل از فراخوانی تابع (که در زمان اجرا ارزیابی می شود) را اختصاص داد. همانطور که در برنامه زیر a یک ثابت است و مقدار آن باید در زمان کامپایل در دسترس باشد، اما تابع getValue فقط در زمان اجرا فراخوانی می‌شود، بنابراین در حین کامپایل خطا ایجاد می‌کند.package main const name = "test" func main() { const a = getValue() } func getValue() int { return 1 }خطا:const initializer getValue() is not a constantیک ثابت اعلام شده در یک محدوده (scope) داخلی که نامی مشابه با ثابت اعلام شده در محدوده بیرونی دارد، ثابت در محدوده بیرونی را تحت الشعاع قرار می دهد.package main import "fmt" const a = 123 func main() { const a = 456 fmt.Println(a) }خروجی:456ثابت های دارای نوع (typed) و بدون نوع (untyped)در Go با ثابت ها به روشی متفاوت از هر زبان دیگری رفتار می شود. GO یک سیستم نوع بسیار قوی دارد که اجازه تبدیل ضمنی بین هیچ یک از انواع را نمی دهد. حتی با انواع عددی یکسان، هیچ عملیاتی بدون تبدیل صریح مجاز نیست. به عنوان مثال شما نمی توانید مقدار int32 و int64 را جمع (+) کنید. برای جمع کردن آن‌ها، باید int32 به طور صریح به int64 تبدیل شود یا برعکس. به هر حال ثابت های بدون نوع دارای انعطاف پذیری موقت هستند که در این مقاله خواهیم دید.ثابت های دارای نوعیک ثابت که نوع آن در اعلان مشخص شده است یک ثابت دارای نوع است. به عنوان مثال در زیر ما یک ثابت از نوع int32 را اعلام می کنیمconst num int32 = 8ثابت num را فقط می توان به متغیری از نوع int32 نسبت داد. اگر آن را به متغیری از هر نوع دیگری اختصاص دهید، یک خطا ایجاد می کند. برای تصویر برنامه زیر را ببینید.package main func main() { const a int32 = 8 var i1 int32 var i2 int64 i1 = a i2 = a }خروجی:cannot use a (type int32) as type int64 in assignmentثابت های بدون نوعثابت بدون نوع ثابتی است که نوع آن مشخص نشده باشد. یک ثابت بدون نوع در GO می تواند با نام یا بدون نام باشد. در هر دو حالت هیچ نوع مرتبطی با آن وجود ندارد.نمونه هایی از ثابت بی نام و بدون نوع123 //Default hidden type is int "circle" //Default hidden type is string 5.6. //Default hidden type is float64 true //Default hidden type is bool 'a' //Default hidden type is rune 3+5i //Default hidden type is complex128نمونه هایی از ثابت دارای نام ولی بدون نوعconst a = 123 //Default hidden type is int const b = "circle" //Default hidden type is string const c = 5.6 //Default hidden type is float64 const d = true //Default hidden type is bool const e = 'a' //Default hidden type is rune const f = 3+5i //Default hidden type is complex128ثابت بدون نوع، یک نوع پنهان پیش فرض دارد. به عنوان مثال جدول زیر انواع پیش فرض پنهان برای اعداد، رشته ها، کاراکترها و بولی را نشان می دهد.وقتی هر ثابت بدون نوع را با استفاده از fmt.Printf چاپ می کنید، نوع پنهان پیش فرض را چاپ می کند. برنامه و خروجی زیر را برای ثابت بی نام و بدون نام مشاهده کنید.package main import "fmt" func main() { //Unanamed untyped constant fmt.Printf("Type: %T Value: %v\n", 123, 123) fmt.Printf("Type: %T Value: %v\n", "circle", "circle") fmt.Printf("Type: %T Value: %v\n", 5.6, 5.6) fmt.Printf("Type: %T Value: %v\n", true, true) fmt.Printf("Type: %T Value: %v\n", 'a', 'a') fmt.Printf("Type: %T Value: %v\n", 3+5i, 3+5i) //Named untyped constant const a = 123 //Default hidden type is int const b = "circle" //Default hidden type is string const c = 5.6 //Default hidden type is float64 const d = true //Default hidden type is bool const e = 'a' //Default hidden type is rune const f = 3 + 5i //Default hidden type is complex128 fmt.Println("") fmt.Printf("Type: %T Value: %v\n", a, a) fmt.Printf("Type: %T Value: %v\n", b, b) fmt.Printf("Type: %T Value: %v\n", c, c) fmt.Printf("Type: %T Value: %v\n", d, d) fmt.Printf("Type: %T Value: %v\n", e, e) fmt.Printf("Type: %T Value: %v\n", f, f) }خروجی:Type: int Value: 123 Type: string Value: circle Type: float64 Value: 5.6 Type: bool Value: true Type: int32 Value: 97 Type: complex128 Value: (3+5i) Type: int Value: 123 Type: string Value: circle Type: float64 Value: 5.6 Type: bool Value: true Type: int32 Value: 97 Type: complex128 Value: (3+5i)برنامه فوق int32 را به جای Rune چاپ می کند زیرا Rune نام مستعار int32 استنوع پیش‌فرض یک نوع ثابت با نام یا بدون نام، به نوع متغیری تبدیل می‌شود که به آن اختصاص داده می‌شود. به عنوان مثال در متغیر کد زیر a نوع خود را از نوع پیش فرض ثابت بی نام 123 دریافت می کند که int است.var a = 123بیایید برنامه ای را ببینیم که همه ثابت های نوع بی نام نشان می دهد:package main import "fmt" func main() { //Untyped var u = 123 //Default hidden type is int var v = "circle" //Default hidden type is string var w = 5.6 //Default hidden type is float64 var x = true //Default hidden type is bool var y = 'a' //Default hidden type is rune var z = 3 + 5i //Default hidden type is complex128 fmt.Printf("Type: %T Value: %v\n", u, u) fmt.Printf("Type: %T Value: %v\n", v, v) fmt.Printf("Type: %T Value: %v\n", w, w) fmt.Printf("Type: %T Value: %v\n", x, x) fmt.Printf("Type: %T Value: %v\n", y, y) fmt.Printf("Type: %T Value: %v\n", z, z) }خروجی:Type: int Value: 123 Type: string Value: circle Type: float64 Value: 5.6 Type: bool Value: true Type: int32 Value: 97 Type: complex128 Value: (3+5i)حال سوالی که به ذهن خطور می کند این است که ثابت بدون نوع چه کاربردی دارد. استفاده از ثابت بدون نوع این است که نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود. گیج کننده به نظر می رسد؟ با یک مثال ببینیم :مقدار ثابت عدد پی (Pi) در پکیج math به صورت زیر اعلام شده است.const Pi = 3.14159265358979323846264338327950288419716939937510582097494459توجه داشته باشید که نوع آن مشخص نشده است و فقط یک نوع پیش فرض پنهان دارد (که در اینجا float64 است). بیایید یک کد ببینیمpackage main import ( "fmt" "math" ) func main() { var f1 float32 var f2 float64 f1 = math.Pi f2 = math.Pi fmt.Printf("Type: %T Value: %v\n", math.Pi, math.Pi) fmt.Printf("Type: %T Value: %v\n", f1, f1) fmt.Printf("Type: %T Value: %v\n", f2, f2) }خروجی: Type: float64 Value: 3.141592653589793 Type: float32 Value: 3.1415927 Type: float64 Value: 3.141592653589793به برنامه بالا توجه کنید.با توجه به ماهیت نامشخص ثابت math.Pi می توان آن را به متغیری از نوع float32 و همچنین float64 نسبت داد. در غیر این صورت انجام این کار در GO ممکن نیست.وقتی نوع math.Pi را چاپ می کنیم، نوع پیش فرض را که float64 است چاپ می کندبسته به مورد استفاده، یک ثابت بدون نوع را می توان به یک نوع با دقت کم (float32) یا یک نوع با دقت بالا (float64) اختصاص داد.قراردادهای نامگذاریقراردادهای نامگذاری برای یک ثابت مانند قراردادهای نامگذاری برای متغیرها است.یک نام ثابت فقط می تواند با یک حرف یا زیرخط شروع شود. بعد از آن می توان هر تعداد حروف، اعداد یا زیرخط را دنبال کردثابت سراسریمانند هر متغیر دیگری، یک ثابت در یک بسته اگر در بالای یک فایل خارج از محدوده هر تابعی اعلان شود، سراسری خواهد بود. به عنوان مثال، در نام برنامه زیر یک ثابت سراسری در سراسر بسته اصلی در هر تابع موجود است. توجه داشته باشید که نام یک ثابت برای اینکه خارج از بسته اصلی در دسترس باشد باید با حرف بزرگ شروع شود.کد زیر یک ثابت محلی را در یک بسته نشان می دهد.package main import "fmt" const name = "test" func main() { const a = 8 fmt.Println(a) testGlobal() } func testGlobal() { fmt.Println(name) //The below line will give compiler error as a is a local constant //fmt.Println(a) }انواع ثابت هاثابت می تواند چهار نوع باشد:رشته ایعددیبولیکاراکترثابت رشته ایدر go ثابت رشته به دو صورت نمایش داده می شودهر مقداری که بین دو گیومه محصور شده باشدهر مقدار محصور بین نقل قول های عقببرنامه زیر نمونه ای است از یک:ثابت رشته دارای نوعثابت رشته بدون نام بدون نوعثابت رشته با نام بدون نوعpackage main import "fmt" func main() { type myString string //Typed String constant const aa string = "abc" var uu = aa fmt.Println("Untyped named string constant") fmt.Printf("uu: Type: %T Value: %v\n\nn", uu, uu) //Below line will raise a compilation error //var v myString = aa //Untyped named string constant const bb = "abc" var ww myString = bb var xx = bb fmt.Println("Untyped named string constant") fmt.Printf("ww: Type: %T Value: %v\n", ww, ww) fmt.Printf("xx: Type: %T Value: %v\n\n", xx, xx) //Untyped unnamed string constant var yy myString = "abc" var zz = "abc" fmt.Println("Untyped unnamed string constant") fmt.Printf("yy: Type: %T Value: %v\n", yy, yy) fmt.Printf("zz: Type: %T Value: %v\n", zz, zz) }خروجی:Untyped named string constant uu: Type: string Value: abc nUntyped named string constant ww: Type: main.myString Value: abc xx: Type: string Value: abc Untyped unnamed string constant yy: Type: main.myString Value: abc zz: Type: string Value: abcدر برنامه فوق یک نوع جدید به نام myString در کد ایجاد کردیم.type myString stringبرنامه بالا مثالی است از :ثابت رشته دارای نوعثابت رشته بدون نام بدون نوعثابت رشته با نام بدون نوعثابت رشته دارای نوعconst aa string = "abc"توجه کنید که خط زیر باعث خطای کامپایل می شود. به این دلیل که ثابت aa از نوع stringاست. لذا نمی توان آن را به متغیری از نوع myString نسبت داد.var v myString = aaاما ثابت رشته دارای نوع را می توان به متغیری که با کلمه کلیدی var ایجاد شده است مانند زیر نسبت دادvar uu = aaثابت رشته با نام بدون نوعconst bb = "abc"ثابت رشته ای با نام بدون نوع را می توان به متغیری از نوع myString و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد، زیرا بدون نوع است، بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود.var ww myString = bbvar xx = bbثابت رشته بدون نام بدون نوعبه شکل زیر تعریف شده است:abcثابت رشته بدون نام بدون نوع را می توان به متغیری از نوع myString و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد، زیرا بدون نوع است، بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود.var yy myString = "abc"var zz = "abc"ثابت عددیثابت های عددی بیشتر به سه نوع تقسیم می شوندعدد صحیحشناورهااعداد مختلطیک ثابت عدد صحیح بدون نوع (هم با نام و هم بدون نام) را می توان به انواع int، انواع float و complex نسبت داد. این به این دلیل است که مقدار int می تواند int یا float یا complex باشد. برای مثال مقدار int 123 می تواند باشدیک int که مقدار آن 123 استیک float که مقدار آن 123.0 استیک complex که قسمت خیالی (imaginary) آن 0 استبر اساس منطق مشابه، یک ثابت float بدون نوع را می توان به همه انواع float و complex اختصاص داد، اما نه به نوع int، زیرا برای مثال یک عدد float با مقدار 5.3 نمی تواند یک عدد صحیح باشد.بر اساس منطق مشابه، یک ثابت complex بدون نوع را می توان به انواع complex اختصاص داد، اما نه int و یا float، زیرا برای مثال یک شناور 5i+3 نمی تواند یک عدد صحیح یا یک شناور باشد.برنامه زیر را ببینید که نکته فوق را نشان می دهد. این برنامه مثالی است برای :ثابت عدد صحیح دارای نوعثابت عدد صحیح بدون نام بدون نوعثابت عدد صحیح با نام بدون نوعpackage main import "fmt" func main() { //Typed int constant const aa int = 123 var uu = aa fmt.Println("Typed named integer constant") fmt.Printf("uu: Type: %T Value: %v\n\n", uu, uu) //Below line will raise a compilation error //var v int32 = aa //Untyped named int constant const bb = 123 var ww = bb var xx int32 = bb var yy float64 = bb var zz complex128 = bb fmt.Println("Untyped named integer constant") fmt.Printf("ww: Type: %T Value: %v\n", ww, ww) fmt.Printf("xx: Type: %T Value: %v\n", xx, xx) fmt.Printf("yy: Type: %T Value: %v\n", yy, yy) fmt.Printf("zz: Type: %T Value: %v\n\n", zz, zz) //Untyped unnamed int constant var ll = 123 var mm int32 = 123 var nn float64 = 123 var oo complex128 = 123 fmt.Println("Untyped unnamed integer constant") fmt.Printf("ll: Type: %T Value: %v\n", ll, ll) fmt.Printf("mm: Type: %T Value: %v\n", mm, mm) fmt.Printf("nn: Type: %T Value: %v\n", nn, nn) fmt.Printf("oo: Type: %T Value: %v\n", oo, oo) }خروجی :Typed named integer constant uu: Type: int Value: 123 Untyped named integer constant ww: Type: int Value: 123 xx: Type: int32 Value: 123 yy: Type: float64 Value: 123 zz: Type: complex128 Value: (123+0i) Untyped unnamed integer constant ll: Type: int Value: 123 mm: Type: int32 Value: 123 nn: Type: float64 Value: 123 oo: Type: complex128 Value: (123+0i) برنامه بالا نمونه ای از a را نشان می دهد که a -ثابت عدد صحیح دارای نوعثابت عدد صحیح بدون نام بدون نوعثابت عدد صحیح با نام بدون نوعثابت عدد صحیح دارای نوع const aa int = 123ثابت عدد صحیح دارای نوع را می توان به متغیر ایجاد شده با کلمه کلیدی var مانند زیر نسبت دادvar uu = aaهنگامی که به نوع int دیگری اختصاص داده شود، خطای کامپایل را ایجاد میکند. بنابراین در زیر خطای کامپایل را خواهیم داشت زیرا متغیر aa از نوع int استvar v int32 = aaثابت عدد صحیح با نام بدون نوعconst bb = 123ثابت عدد صحیح با نام بدون نوع را می توان به هر نوع int، هر نوع شناور و هر نوع عدد مختلط و همچنین به هر متغیری که با کلمه کلیدی var ایجاد شده است نسبت داد. بنابراین زیر کار می کندvar ww = bbvar xx int32 = bbvar yy float64 = bbvar zz complex128 = bbثابت عدد صحیح بدون نام بدون نوع123ثابت عدد صحیح با نام بدون نوع را می توان به هر نوع int، هر نوع float و هر نوع عدد complex و همچنین به هر متغیری که با کلمه کلیدی var ایجاد شده است نسبت داد. بنابراین زیر کار می کندvar ww = 123var xx int32 = 123var yy float64 = 123var zz complex128 = 123عبارات عددیبه دلیل ماهیت نامشخص ثابت های عددی ، انواع ثابت عددی مختلف را می توان با هم ترکیب کرد و یک عبارت را ایجاد کرد.package main import "fmt" func main() { var p = 5.2 / 3 fmt.Printf("p: Type: %T Value: %v\n", p, p) }خروجی:p: Type: float64 Value: 1.7333333333333334ثابت بولیدو ثابت بولی بدون نوع true و false وجود دارد. در زیر برنامه ای است که ثابت بولی را نشان می دهد.package main import "fmt" func main() { type myBool bool //Typed Boolean constant const aa bool = true var uu = aa fmt.Println("Typed named boolean constant") fmt.Printf("uu: Type: %T Value: %v\n\n", uu, uu) //Below line will raise a compilation error //var vv myBool = aa //Untyped named boolean constant const bb = true var ww myBool = bb var xx = bb fmt.Println("Untyped named boolean constant") fmt.Printf("ww: Type: %T Value: %v\n", ww, ww) fmt.Printf("xx: Type: %T Value: %v\n\n", xx, xx) //Untyped unnamed boolean constant var yy myBool = true var zz = true fmt.Println("Untyped unnamed boolean constant") fmt.Printf("yy: Type: %T Value: %v\n", yy, yy) fmt.Printf("zz: Type: %T Value: %v\n", zz, zz) }خروجی:Typed named boolean constant uu: Type: bool Value: true Untyped named boolean constant ww: Type: main.myBool Value: true xx: Type: bool Value: true Untyped unnamed boolean constant yy: Type: main.myBool Value: true zz: Type: bool Value: trueدر برنامه فوق یک نوع جدید myBool ایجاد کردیمtype myBool boolهمچنین برنامه بالا مثالی است از:ثابت بولی دارای نوعثابت بولی بدون نام بدون نوعثابت بولی با نام بدون نوعثابت بولی دارای نوع const aa bool = trueتوجه کنید که خط زیر باعث خطای کامپایل می شود. این به این دلیل است که متغیر aa از ثابت بولی دارای نوع است. بنابراین خط زیر باعث خطای کامپایل می شود زیرا نمی توان آن را به متغیری از نوع myBool اختصاص داد.var v mybool = aaاما ثابت رشته دارای نوع را می توان به متغیری که با کلمه کلیدی var ایجاد شده است مانند زیر نسبت دادvar uu = aaثابت بولی با نام بدون نوعconst bb = trueثابت رشته ای با نام بدون نوع را می توان به متغیری از نوع myBool و همچنین متغیر ایجاد شده با کلمه کلیدی var اختصاص داد زیرا بدون نوع است بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود تعیین می شود.var ww mybool = bbvar xx = bbثابت بولی بدون نام بدون نوعtrueثابت رشته بدون نام بدون نام را می توان به متغیری از نوع myBool و همچنین متغیر ایجاد شده با کلمه کلیدی var اختصاص داد زیرا بدون نوع است بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود تعیین می شود.var yy mybool = true var zz = trueثابت کاراکتریدر زیر برنامه ای است که ثابت کاراکتر را نشان می دهد.package main import "fmt" func main() { type myChar int32 //Typed character constant const aa int32 = 'a' var uu = aa fmt.Println("Untyped unnamed character constant") fmt.Printf("uu: Type: %T Value: %v\n\n", uu, uu) //Below line will raise a compilation error //var vv myBool = aa //Untyped named character constant const bb = 'a' var ww myChar = bb var xx = bb fmt.Println("Untyped named character constant") fmt.Printf("ww: Type: %T Value: %v\n", ww, ww) fmt.Printf("xx: Type: %T Value: %v\n\n", xx, xx) //Untyped unnamed character constant var yy myChar = 'a' var zz = 'a' fmt.Println("Untyped unnamed character constant") fmt.Printf("yy: Type: %T Value: %v\n", yy, yy) fmt.Printf("zz: Type: %T Value: %v\n", zz, zz) }خروجی:Untyped unnamed character constant uu: Type: int32 Value: 97 Untyped named character constant ww: Type: main.myChar Value: 97 xx: Type: int32 Value: 97 Untyped unnamed character constant yy: Type: main.myChar Value: 97 zz: Type: int32 Value: 97در برنامه فوق یک نوع جدید myChar ایجاد کردیمtype myChar int32همچنین برنامه بالا مثالی است از:ثابت کاراکتر دارای نوعثابت کاراکتر بدون نام بدون نوعثابت کاراکتر با نام بدون نوعثابت کاراکتر دارای نوعconst aa int32 = 'a'توجه کنید که خط زیر باعث خطای کامپایل می شود. این به این دلیل است که متغیر aa از نوع int32 است. بنابراین خط زیر باعث خطای کامپایل می شود زیرا نمی توان آن را به متغیری از نوع myChar نسبت دادvar v myChar = aaاما ثابت رشته دارای نوع را می توان به متغیری که با کلمه کلیدی var ایجاد شده است مانند زیر نسبت دادvar uu = aaثابت کاراکتر با نام بدون نوعconst bb = 'a'ثابت رشته ای با نام بدون نوع را می توان به متغیری از نوع myChar و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد، زیرا بدون نوع است، بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود.var ww myChar = bbvar xx = bbثابت کاراکتر بدون نام بدون نوع'a'ثابت رشته بدون نام را می توان به متغیری از نوع myChar و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد زیرا بدون نوع است بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود تعیین می شود.var yy myChar = 'a'var zz = 'a'نتیجهآنچه بیان شد همه چیز در مورد ثابت ها در زبان Go است. امیدواریم این مقاله را دوست داشته باشید. لطفا بازخورد یا بهبود یا اشتباهات را در نظرات به اشتراک بگذارید.-----------------------------------مطالب دیگر:متغیر ها در زبان گو (Go)-----------------------------------توجه: در بخشی از متن ترجمه شده به جهت خوانایی بیشتر، به نحوی که در مفهوم مطالب تغییری ایجاد نشود تغییراتی ایجاد شده است.منبع:https://golangbyexample.com/constant-golang/

متغیر ها در زبان گو (Go)

سعید فراهانی — Mon, 25 Sep 2023 00:36:06 +0330

متغیر چیستمتغیر نام یک مکان حافظه است. آن مکان حافظه ممکن است مقداری از هر نوع را ذخیره کند. بنابراین هر متغیر دارای یک نوع است که اندازه و محدوده آن متغیر و همچنین عملیات تعریف شده روی آن متغیر را تعیین می کند.قراردادهای نامگذاری متغیر ها در زبان برنامه نویسی Goنام متغیر فقط می تواند با یک حرف یا زیرخط شروع شود.بعد از آن می توان هر تعداد حروف، اعداد یا زیرخط را استفاده کردزبان Go به حروف بزرگ و کوچک حساس است، بنابراین با حروف بزرگ و کوچک متفاوت رفتار می شود.نام متغیر نمی تواند نام هیچ کلمه کلیدی در زبان Go باشدهیچ محدودیتی در طول نام متغیر وجود ندارد. اما توصیه می شود که نام متغیر طول بهینه را داشته باشید.تعریف یک متغیردر زبان Go متغیرها با استفاده از کلمه کلیدی var اعلان می شوند، اما روش های دیگری نیز برای اعلام یک متغیر وجود دارد که در ادامه این آموزش خواهیم دید. بیایید روش های مختلف اعلام یک متغیر را بررسی کنیم.تعریف تک متغیری بدون مقدار اولیهکد زیر روش اعلان یک متغیر منفرد بدون تخصیص مقدار اولیه است که شامل اول کلمه کلیدی var، دوم نام متغیر و سوم نوع متغیر است. همچنین توجه داشته باشید زمانی که مقدار ارائه نمی شود، متغیر با مقدار پیش فرض آن نوع که به عنوان مقدار صفر (zero) آن نوع نیز شناخته می شود مقداردهی اولیه می شود. در زبان Go مقدار پیش فرض یا مقدار صفر int عدد 0 است.var package main import "fmt" func main() { var aaa int fmt.Println(aaa) }خروجی: مقدار پیش فرض int را که 0 است را چاپ می کند0تعریف تک متغیری با مقدار اولیهکد زیر فرمت یک اعلان متغیر منفرد با مقدار اولیه است. همه چیز مانند بالا است، تنها چیز اضافی این است که در پایان به متغیر مقدار اختصاص می دهیمvar = مثال زیر را ببینید، یک متغیر به نام aaa از نوع int را اعلام می کند و به آن مقدار 8 می دهد.package main import "fmt" func main() { var aaa int = 8 fmt.Println(aaa) }خروجی:8تعریف چند متغیر بدون مقدار اولیهدر زیر فرمت اعلان چند متغیر بدون تخصیص مقدار اولیه قابل مشاهده است. لطفاً توجه داشته باشید که فقط متغیرهای یک نوع را می توان با هم اعلام کرد. توجه کنید که در تعریف متغیر، نوع در پایان می آید.var , ,…. مثال زیر را ببینیدpackage main import "fmt" func main() { var aaa, bbb int fmt.Println(aaa) fmt.Println(bbb) }خروجی: مقدار پیش فرض یا صفر int را چاپ می کند که برای aaa و bbb صفر است0 0تعریف چند متغیر با مقدار اولیهدر قطعه کد زیر فرمت یک اعلان متغیر چندگانه با مقدار اولیه نمایش داده شده است. لطفاً توجه داشته باشید که فقط متغیرهای یک نوع را می توان با هم اعلام کرد. var , , ….., = , , …..,نمونه کد زیر را ببینید. به متغیر aaa و bbb در یک اعلان به ترتیب مقدار 8 و 9 داده می شود.package main import "fmt" func main() { var aaa, bbb int = 8, 9 fmt.Println(aaa) fmt.Println(bbb) }خروجی:8 9تعریف متغیرهایی با انواع مختلفدر زیر فرمت اعلان چندین متغیر با انواع مختلف آورده شده است. در صورت نیاز مقادیر را می توان به متغیرها نسبت داد. متغیرهایی که مقدار برای آنها تخصیص داده نشده است، مقدار پیش فرض آن نوع را دریافت می کنند. در مثال زیر سه اعلان می بینیم.package main import "fmt" func main() { var ( aaa int bbb int = 8 ccc string = "a" ) fmt.Println(aaa) fmt.Println(bbb) fmt.Println(ccc) }خروجی:0 8 aاعلان متغیر بدون نوع متغیرها را نیز می توان بدون تعیین نوع آن اعلام کرد.کامپایلر GO بر اساس مقدار تخصیص داده شده به متغیر، نوع آن را مشخص می کند. بنابراین اگر متغیر دارای مقدار اولیه باشد، می توان نوع را حذف کرد. این استنتاج نوع نیز نامیده می شود. در زیر فرمت چنین تعریفی آمده استvar = در زیر جدول استنتاج نوع برای انواع اساسی int، float، اعداد مختلط، رشته، بولی، کاراکترها آمده است. اساساً به این معنی است که اگر مقدار یک عدد صحیح باشد نوع متغیر استنباط شده int خواهد بود، اگر مقدار یک float باشد، نوع متغیر استنباط‌شده بر اساس جدول زیر float64 و غیره خواهد بود.برای انواع دیگر مانند Array، Pointer، Structure و غیره، نوع Inference بر اساس مقدار اتفاق می افتد. بیایید یک مثال کاربردی از نکته بالا را ببینیم. توجه داشته باشید که نوع t به درستی به عنوان int استنباط می شود زیرا مقدار اختصاص داده شده به آن 123 است که int است. به طور مشابه نوع u نیز به درستی به عنوان رشته استنباط می شود زیرا مقدار اختصاص داده شده به آن یک رشته است.همچنین توجه داشته باشید که نوع متغیر z به درستی به عنوان ساختار main.sample استنباط شده استpackage main import "fmt" func main() { var t = 123 //Type Inferred will be int var u = "circle" //Type Inferred will be string var v = 5.6 //Type Inferred will be float64 var w = true //Type Inferred will be bool var x = 'a' //Type Inferred will be rune var y = 3 + 5i //Type Inferred will be complex128 var z = sample{name: "test"} //Type Inferred will be main.Sample fmt.Printf("Type: %T Value: %v\n", t, t) fmt.Printf("Type: %T Value: %v\n", u, u) fmt.Printf("Type: %T Value: %v\n", v, v) fmt.Printf("Type: %T Value: %v\n", w, w) fmt.Printf("Type: %T Value: %v\n", x, x) fmt.Printf("Type: %T Value: %v\n", y, y) fmt.Printf("Type: %T Value: %v\n", z, z) } type sample struct { name string }خروجی:Type: int Value: 123 Type: string Value: circle Type: float64 Value: 5.6 Type: bool Value: true Type: int32 Value: 97 Type: complex128 Value: (3+5i) Type: main.sample Value: اعلان متغیر کوتاهGo راه دیگری برای اعلان متغیرها ارائه می دهد که از عملگر := استفاده می کند. هنگامی که عملگر := استفاده می شود، هم کلمه کلیدی var و هم اطلاعات نوع را می توان حذف کرد. در زیر فرمت چنین اعلامیه ای آمده است:=استنتاج نوع همانطور که در بالا توضیح داده شد اتفاق می افتد. بیایید یک قطعه کد نمونه را بررسی کنیم:package main import "fmt" func main() { t := 123 //Type Inferred will be int u := "circle" //Type Inferred will be string v := 5.6 //Type Inferred will be float64 w := true //Type Inferred will be bool x := 'a' //Type Inferred will be rune y := 3 + 5i //Type Inferred will be complex128 z := sample{name: "test"} //Type Inferred will be main.Sample fmt.Printf("Type: %T Value: %v\n", t, t) fmt.Printf("Type: %T Value: %v\n", u, u) fmt.Printf("Type: %T Value: %v\n", v, v) fmt.Printf("Type: %T Value: %v\n", w, w) fmt.Printf("Type: %T Value: %v\n", x, x) fmt.Printf("Type: %T Value: %v\n", y, y) fmt.Printf("Type: %T Value: %v\n", z, z) } type sample struct { name string }خروجیType: int Value: 123 Type: string Value: circle Type: float64 Value: 5.6 Type: bool Value: true Type: int32 Value: 97 Type: complex128 Value: (3+5i) Type: main.sample Value: چند نکته در مورد عملگر := قابل ذکر استعملگر := فقط درون توابع قابل استفاده است. خارج از تابع مجاز نیست.متغیری که یک بار با استفاده از := اعلام شده است را نمی توان با استفاده از عملگر := دوباره اعلام کرد. بنابراین عبارت زیر یک خطای کامپایلر را ایجاد می‌کند که “متغیر جدیدی در سمت چپ :=” وجود ندارد.a := 8 a := 16عملگر := همچنین می تواند برای اعلان چندین متغیر در یک خط استفاده شود. مثال زیر را ببینیدa,b := 1, 2در صورت اعلان چندگانه، اگر حداقل یکی از متغیرهای سمت چپ جدید باشد، := می تواند دوباره برای یک متغیر خاص استفاده شود. مثال زیر را ببینید. توجه داشته باشید که b مجدداً با استفاده از := اعلام می شود که این تنها در صورتی امکان پذیر است که حداقل یکی از متغیرها جدید باشد که متغیر c در اینجا باشد. در این مورد به عنوان یک انتساب برای متغیر b عمل می کندpackage main import "fmt" func main() { a, b := 1, 2 b, c := 3, 4 fmt.Println(a, b, c) }خروجی:1, 3, 4نکات مهموجود یک متغیر استفاده نشده به عنوان یک خطای کامپایلر گزارش می شود. کامپایلر GO اجازه تعریف متغیر بدون استفاده ای را نمیدهد. این یک بهینه سازی در GO است. همانطور که در ادامه خواهیم دید، همین امر برای انواع ثابت (constant) نیز اعمال می شود. به عنوان مثال برنامه زیر یک خطای کامپایلر ایجاد می کندpackage main func main() { //a declared but not used var a = 1 }متغیری که در یک محدوده داخلی اعلام شده است بر روی متغیری با همان نام که در محدوده بیرونی معرفی شده است سایه می اندازد.package main import "fmt" var a = 123 func main() { var a = 456 fmt.Println(a) }خروجی:456بیان متغیر — در حالی که به متغیر اعلامی می توان یک عبارت یا یک تابع فراخوانی نیز اختصاص داد. مثال زیر را ببینید.متغیر a با عبارت 5 +3 اعلام می شودمتغیر b با فراخوانی تابع math.Max(4, 5) اعلام می شود که نتیجه آن در زمان اجرا به b اختصاص داده می شود.package main import ( "fmt" "math" ) func main() { a := 5 + 3 b := math.Max(4, 5) fmt.Println(a) fmt.Println(b) }خروجی:8 5زمانی که یک متغیر با یک نوع خاص مقداردهی اولیه شود، بعداً نمی‌توان به آن متغیر مقداری از نوع متفاوت نسبت داد. مثال زیر را ببینیدpackage main func main() { var aaa int = 1 aaa = "atest" bbb := 1 bbb = "btest" }خروجی:cannot use "atest" (type untyped string) as type int in assignment cannot use "btest" (type untyped string) as type int in assignmentبه متغیر aaa یک نوع int اختصاص داده شده است، از این رو کامپایلر در اختصاص مقداری از نوع رشته به آن خطایی ایجاد می کند. برای متغیر bbb، نوع استنباط شده int است، از این رو با اختصاص مقداری از نوع رشته به آن، خطای کامپایلر را نیز ایجاد می کند.محدوده یک متغیر (متغیر محلی و سراسری)اعلان متغیر را می توان در سطح پکیج یا سطح تابع یا سطح بلوک انجام داد. محدوده یک متغیر محل دسترسی آن متغیر و همچنین عمر متغیر را مشخص می کند. متغیرهای زبان Go را می توان بر اساس دامنه به دو دسته تقسیم کردمتغیر محلیمتغیر سراسریمتغیر محلیمتغیرهای محلی متغیرهایی هستند که در یک بلوک یا یک سطح تابع تعریف می شوندنمونه ای از بلوک یک حلقه for یا یک حلقه محدوده و غیره است.این متغیرها فقط از داخل بلوک یا تابع آنها قابل دسترسی هستنداین متغیرها فقط تا انتهای بلوک یا تابعی که در آن اعلان شده اند زنده هستند. پس از آن، آنها از حافظه پاک میشوند.مثال زیر را ببینیدمتغیر i بعد از حلقه for در دسترس نیستبه طور مشابه aaa خارج از تابعی که در آن اعلان شده است در دسترس نیست.بنابراین برنامه زیر خطای کامپایلر را افزایش می دهدundefined: i undefined: aaaکد:package main import "fmt" func main() { var aaa = "test" fmt.Println(aaa) for i := 0; i < 3; i++ { fmt.Println(i) } fmt.Println(i) } func testLocal() { fmt.Println(aaa) }متغیر سراسرییک متغیر در صورتی که در بالای یک فایل خارج از محدوده هر تابع یا بلوکی اعلان شود، درون یک پکیج به صورت سراسری خواهد بود.اگر نام این متغیر با حروف کوچک شروع شود، می‌توان از داخل پکیجی که این تعریف متغیر را در خود دارد به آن دسترسی داشت.اگر نام متغیر با یک حرف بزرگ مشخص شود، می‌توان از پکیجی خارج از پکیج که اعلام شده است، به آن دسترسی پیدا کرد.متغیرهای سراسری در طول عمر یک برنامه در دسترس هستندبه عنوان مثال در زیر متغیر برنامه aaa یک متغیر سراسری در سراسر پکیج اصلی خواهد بود. در هر عملکردی در پکیج اصلی موجود خواهد بود. توجه داشته باشید که نام متغیر خارج از پکیج اصلی در دسترس نخواهد بود زیرا نام آن با حروف کوچک شروع می شود.package main import "fmt" var aaa = "test" func main() { testGlobal() } func testGlobal() { fmt.Println(aaa) }خروجی:testنتیجهآنچه بیان شد همه چیز در مورد متغیرها در زبان Go است. امیدواریم این مقاله را دوست داشته باشید. لطفا بازخورد یا بهبود یا اشتباهات را در نظرات به اشتراک بگذارید.-----------------------------------توجه: در بخشی از متن ترجمه شده به جهت خوانایی بیشتر، به نحوی که در مفهوم مطالب تغییری ایجاد نشود تغییراتی ایجاد شده است.منبع:https://golangbyexample.com/variables-in-golang-complete-guide/