سعید فراهانی
سعید فراهانی
خواندن ۱۸ دقیقه·۱ سال پیش

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

ثابت (Constant) چیزی است که مقدار آن تغییر نمیکند. یک ثابت در زبان برنامه نویسی Go می تواند از نوع رشته، عددی، بولی و کاراکتر باشد.


یک ثابت را می توان با استفاده از کلمه کلیدی const اعلام کرد. نکته مهمی که باید به آن توجه داشت این است که مقدار باید در حین اعلام یک ثابت تخصیص داده شود. بر خلاف متغیرهایی است که می توان بعداً مقدار را به آن اختصاص داد.


اعلام یک ثابت همراه با تعیین نوع:

با یک کلمه کلیدی const شروع می شود، سپس نام و سپس نوع. مقدار نیز باید تخصیص داده شود:

const c string = &quotcircle&quot


اعلام یک ثابت بدون تعیین نوع:

یک ثابت تعریف شده بدون اینکه نوع آن مشخص شود، یک ثابت بدون نوع (untyped) است. در ادامه بیشتر با ثابت دارای نوع و بدون نوع آشنا خواهیم شد. در حال حاضر، مهم است بدانید که ثابت بدون نوع اعلام شده دارای یک نوع پنهان پیش فرض است. زمانی که به هر طریقی به متغیری اختصاص داده شود، با توجه به مقدار آن یک نوع داده به آن اختصاص می یابد (مقدار دهی اولیه مستقیم، ارسال به یک تابع و غیره).

const c = &quotcircle&quot


اعلان چند ثابت با هم:

const (
   c = &quotcircle&quot
   s = &quotsquare&quot
)


نکات مهم

یک ثابت پس از اعلان، مجددا قابل تخصیص نیست. به عنوان مثال کد زیر یک خطای کامپایل ایجاد می کند

package main
func main() {
    const a int = 8
    a = 9
}

خطا:

main.go:5:4: cannot assign to a


مقدار ثابت باید در زمان کامپایل حتما مشخص باشد. بنابراین نمی توان به یک ثابت، یک مقدار حاصل از فراخوانی تابع (که در زمان اجرا ارزیابی می شود) را اختصاص داد. همانطور که در برنامه زیر a یک ثابت است و مقدار آن باید در زمان کامپایل در دسترس باشد، اما تابع getValue فقط در زمان اجرا فراخوانی می‌شود، بنابراین در حین کامپایل خطا ایجاد می‌کند.

package main
const name = &quottest&quot
func main() {
    const a = getValue()
}
func getValue() int {
    return 1
}

خطا:

const initializer getValue() is not a constant


یک ثابت اعلام شده در یک محدوده (scope) داخلی که نامی مشابه با ثابت اعلام شده در محدوده بیرونی دارد، ثابت در محدوده بیرونی را تحت الشعاع قرار می دهد.

package main
import &quotfmt&quot
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
&quotcircle&quot   //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 = &quotcircle&quot   //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 &quotfmt&quot

func main() {
    //Unanamed untyped constant
    fmt.Printf(&quotType: %T Value: %v\n&quot, 123, 123)
    fmt.Printf(&quotType: %T Value: %v\n&quot, &quotcircle&quot, &quotcircle&quot)
    fmt.Printf(&quotType: %T Value: %v\n&quot, 5.6, 5.6)
    fmt.Printf(&quotType: %T Value: %v\n&quot, true, true)
    fmt.Printf(&quotType: %T Value: %v\n&quot, 'a', 'a')
    fmt.Printf(&quotType: %T Value: %v\n&quot, 3+5i, 3+5i)

    //Named untyped constant
    const a = 123      //Default hidden type is int
    const b = &quotcircle&quot //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(&quot&quot)
    fmt.Printf(&quotType: %T Value: %v\n&quot, a, a)
    fmt.Printf(&quotType: %T Value: %v\n&quot, b, b)
    fmt.Printf(&quotType: %T Value: %v\n&quot, c, c)
    fmt.Printf(&quotType: %T Value: %v\n&quot, d, d)
    fmt.Printf(&quotType: %T Value: %v\n&quot, e, e)
    fmt.Printf(&quotType: %T Value: %v\n&quot, 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 &quotfmt&quot
func main() {
    //Untyped
    var u = 123      //Default hidden type is int
    var v = &quotcircle&quot //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(&quotType: %T Value: %v\n&quot, u, u)
    fmt.Printf(&quotType: %T Value: %v\n&quot, v, v)
    fmt.Printf(&quotType: %T Value: %v\n&quot, w, w)
    fmt.Printf(&quotType: %T Value: %v\n&quot, x, x)
    fmt.Printf(&quotType: %T Value: %v\n&quot, y, y)
    fmt.Printf(&quotType: %T Value: %v\n&quot, 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 (
    &quotfmt&quot
    &quotmath&quot
)
func main() {
    var f1 float32
    var f2 float64
    f1 = math.Pi
    f2 = math.Pi

    fmt.Printf(&quotType: %T Value: %v\n&quot, math.Pi, math.Pi)
    fmt.Printf(&quotType: %T Value: %v\n&quot, f1, f1)
    fmt.Printf(&quotType: %T Value: %v\n&quot, 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 &quotfmt&quot

const name = &quottest&quot

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 &quotfmt&quot

func main() {
	type myString string

	//Typed String constant
	const aa string = &quotabc&quot
	var uu = aa
	fmt.Println(&quotUntyped named string constant&quot)
	fmt.Printf(&quotuu: Type: %T Value: %v\n\nn&quot, uu, uu)

	//Below line will raise a compilation error
	//var v myString = aa

	//Untyped named string constant
	const bb = &quotabc&quot
	var ww myString = bb
	var xx = bb
	fmt.Println(&quotUntyped named string constant&quot)
	fmt.Printf(&quotww: Type: %T Value: %v\n&quot, ww, ww)
	fmt.Printf(&quotxx: Type: %T Value: %v\n\n&quot, xx, xx)

	//Untyped unnamed string constant
	var yy myString = &quotabc&quot
	var zz = &quotabc&quot
	fmt.Println(&quotUntyped unnamed string constant&quot)
	fmt.Printf(&quotyy: Type: %T Value: %v\n&quot, yy, yy)
	fmt.Printf(&quotzz: Type: %T Value: %v\n&quot, 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 = &quotabc&quot

توجه کنید که خط زیر باعث خطای کامپایل می شود. به این دلیل که ثابت aa از نوع stringاست. لذا نمی توان آن را به متغیری از نوع myString نسبت داد.

var v myString = aa


اما ثابت رشته دارای نوع را می توان به متغیری که با کلمه کلیدی var ایجاد شده است مانند زیر نسبت داد

var uu = aa


ثابت رشته با نام بدون نوع

const bb = &quotabc&quot

ثابت رشته ای با نام بدون نوع را می توان به متغیری از نوع myString و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد، زیرا بدون نوع است، بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود.

var ww myString = bb
var xx = bb


ثابت رشته بدون نام بدون نوع

به شکل زیر تعریف شده است:

abc


ثابت رشته بدون نام بدون نوع را می توان به متغیری از نوع myString و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد، زیرا بدون نوع است، بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود، تعیین می شود.

var yy myString = &quotabc&quot
var zz = &quotabc&quot



ثابت عددی

ثابت های عددی بیشتر به سه نوع تقسیم می شوند

  • عدد صحیح
  • شناورها
  • اعداد مختلط


یک ثابت عدد صحیح بدون نوع (هم با نام و هم بدون نام) را می توان به انواع 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 &quotfmt&quot

func main() {
	//Typed int constant
	const aa int = 123
	var uu = aa
	fmt.Println(&quotTyped named integer constant&quot)
	fmt.Printf(&quotuu: Type: %T Value: %v\n\n&quot, 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(&quotUntyped named integer constant&quot)
	fmt.Printf(&quotww: Type: %T Value: %v\n&quot, ww, ww)
	fmt.Printf(&quotxx: Type: %T Value: %v\n&quot, xx, xx)
	fmt.Printf(&quotyy: Type: %T Value: %v\n&quot, yy, yy)
	fmt.Printf(&quotzz: Type: %T Value: %v\n\n&quot, zz, zz)

	//Untyped unnamed int constant
	var ll = 123
	var mm int32 = 123
	var nn float64 = 123
	var oo complex128 = 123
	fmt.Println(&quotUntyped unnamed integer constant&quot)
	fmt.Printf(&quotll: Type: %T Value: %v\n&quot, ll, ll)
	fmt.Printf(&quotmm: Type: %T Value: %v\n&quot, mm, mm)
	fmt.Printf(&quotnn: Type: %T Value: %v\n&quot, nn, nn)
	fmt.Printf(&quotoo: Type: %T Value: %v\n&quot, 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 = bb
var xx int32 = bb
var yy float64 = bb
var zz complex128 = bb


ثابت عدد صحیح بدون نام بدون نوع

123

ثابت عدد صحیح با نام بدون نوع را می توان به هر نوع int، هر نوع float و هر نوع عدد complex و همچنین به هر متغیری که با کلمه کلیدی var ایجاد شده است نسبت داد. بنابراین زیر کار می کند

var ww = 123
var xx int32 = 123
var yy float64 = 123
var zz complex128 = 123


عبارات عددی

به دلیل ماهیت نامشخص ثابت های عددی ، انواع ثابت عددی مختلف را می توان با هم ترکیب کرد و یک عبارت را ایجاد کرد.

package main
import &quotfmt&quot
func main() {
    var p = 5.2 / 3
    fmt.Printf(&quotp: Type: %T Value: %v\n&quot, p, p)
}

خروجی:

p: Type: float64 Value: 1.7333333333333334


ثابت بولی

دو ثابت بولی بدون نوع true و false وجود دارد. در زیر برنامه ای است که ثابت بولی را نشان می دهد.


package main

import &quotfmt&quot

func main() {
	type myBool bool

	//Typed Boolean constant
	const aa bool = true
	var uu = aa
	fmt.Println(&quotTyped named boolean constant&quot)
	fmt.Printf(&quotuu: Type: %T Value: %v\n\n&quot, 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(&quotUntyped named boolean constant&quot)
	fmt.Printf(&quotww: Type: %T Value: %v\n&quot, ww, ww)
	fmt.Printf(&quotxx: Type: %T Value: %v\n\n&quot, xx, xx)

	//Untyped unnamed boolean constant
	var yy myBool = true
	var zz = true
	fmt.Println(&quotUntyped unnamed boolean constant&quot)
	fmt.Printf(&quotyy: Type: %T Value: %v\n&quot, yy, yy)
	fmt.Printf(&quotzz: Type: %T Value: %v\n&quot, 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 = bb
var xx = bb



ثابت بولی بدون نام بدون نوع

true

ثابت رشته بدون نام بدون نام را می توان به متغیری از نوع myBool و همچنین متغیر ایجاد شده با کلمه کلیدی var اختصاص داد زیرا بدون نوع است بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود تعیین می شود.

var yy mybool = true
var zz = true



ثابت کاراکتری

در زیر برنامه ای است که ثابت کاراکتر را نشان می دهد.

package main

import &quotfmt&quot

func main() {
	type myChar int32

	//Typed character constant
	const aa int32 = 'a'
	var uu = aa
	fmt.Println(&quotUntyped unnamed character constant&quot)
	fmt.Printf(&quotuu: Type: %T Value: %v\n\n&quot, 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(&quotUntyped named character constant&quot)
	fmt.Printf(&quotww: Type: %T Value: %v\n&quot, ww, ww)
	fmt.Printf(&quotxx: Type: %T Value: %v\n\n&quot, xx, xx)

	//Untyped unnamed character constant
	var yy myChar = 'a'
	var zz = 'a'
	fmt.Println(&quotUntyped unnamed character constant&quot)
	fmt.Printf(&quotyy: Type: %T Value: %v\n&quot, yy, yy)
	fmt.Printf(&quotzz: Type: %T Value: %v\n&quot, 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 = bb
var xx = bb


ثابت کاراکتر بدون نام بدون نوع

'a'

ثابت رشته بدون نام را می توان به متغیری از نوع myChar و همچنین متغیر ایجاد شده با کلمه کلیدی var نسبت داد زیرا بدون نوع است بنابراین نوع ثابت بسته به نوع متغیری که به آن اختصاص داده می شود تعیین می شود.

var yy myChar = 'a'
var zz = 'a'


نتیجه
آنچه بیان شد همه چیز در مورد ثابت ها در زبان Go است. امیدواریم این مقاله را دوست داشته باشید. لطفا بازخورد یا بهبود یا اشتباهات را در نظرات به اشتراک بگذارید.

-----------------------------------

مطالب دیگر:

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

-----------------------------------

توجه: در بخشی از متن ترجمه شده به جهت خوانایی بیشتر، به نحوی که در مفهوم مطالب تغییری ایجاد نشود تغییراتی ایجاد شده است.

منبع:

https://golangbyexample.com/constant-golang/

زبان برنامه نویسیبرنامه نویسیآموزش زبان goآموزش زبان go با مثالثابت ها در زبان go
شاید از این پست‌ها خوشتان بیاید