ไปตัวแปรภาษา

ตัวแปรจากคณิตศาสตร์ภาษาคอมพิวเตอร์สามารถเก็บไว้ได้หรือผลการคำนวณสามารถแสดงค่าที่เป็นนามธรรม ตัวแปรที่สามารถเข้าถึงได้ผ่านชื่อตัวแปร

ไปชื่อตัวแปรภาษาประกอบด้วยตัวอักษรตัวเลขขีดที่ตัวอักษรตัวแรกไม่ได้เป็นตัวเลข

รูปแบบทั่วไปของตัวแปรมีการประกาศใช้คำ var นี้:

var identifier type

การประกาศตัวแปร

ครั้งแรกที่ระบุชนิดตัวแปรประกาศหากได้รับมอบหมายให้ใช้ค่าเริ่มต้น

var v_name v_type
v_name = value

ที่สองขึ้นอยู่กับมูลค่าของประเภทตัวแปรกำหนดวิถีชีวิตตนเอง

var v_name = value

ประการที่สามถนัด var หมายเหตุ: ตัวแปร = ซ้ายไม่ควรได้รับการประกาศในสถานที่ที่มิฉะนั้นจะเกิดข้อผิดพลาดคอมไพเลอร์

v_name := value

// 例如
var a int = 10
var b = 10
c : = 10

ตัวอย่างมีดังนี้

package main
var a = "w3cschool本教程"
var b string = "w3cschool.cc"
var c bool

func main(){
    println(a, b, c)
}

ตัวอย่างข้างต้นดำเนินการตามผล:

w3cschool本教程 w3cschool.cc false

ประกาศหลายตัวแปร

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

ตัวอย่างมีดังนี้

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

ตัวอย่างข้างต้นดำเนินการตามผล:

0 0 0 false 1 2 123 hello 123 hello

ชนิดของมูลค่าและประเภทการอ้างอิง

ทั้งหมดเช่น int ลอยบูลและสตริงเหล่านี้ประเภทพื้นฐานทุกประเภทค่าใช้เหล่านี้ประเภทของตัวแปรโดยตรงกับค่าที่เก็บไว้ในหน่วยความจำ:

เมื่อคุณใช้เครื่องหมายเท่ากับ = เมื่อค่าของตัวแปรที่มีการกำหนดให้กับตัวแปรอื่นเช่น: j = i คือในความเป็นจริงค่าของหน่วยความจำที่ผมจะได้รับสำเนาของ:

คุณจะได้รับที่อยู่ในหน่วยความจำของตัวแปร I & I ตัวอย่างเช่น: 0xf840000040 (แต่ละที่อยู่อาจจะแตกต่างกัน) ค่าที่เก็บไว้ประเภทค่าตัวแปรในกอง

อยู่หน่วยความจำจะแตกต่างกันขึ้นอยู่กับเครื่องหรือแม้กระทั่งโปรแกรมเดียวกันบนเครื่องที่แตกต่างหลังจากการดำเนินการจะมีอยู่หน่วยความจำที่แตกต่างกัน เพราะแต่ละเครื่องอาจจะมีรูปแบบของหน่วยความจำที่แตกต่างกันและการกำหนดตำแหน่งที่อาจแตกต่างกัน

ข้อมูลที่ซับซ้อนมากขึ้นมักจะต้องใช้คำหลายคำที่ข้อมูลเหล่านี้จะถูกเก็บไว้โดยทั่วไปใช้ประเภทอ้างอิง

ประเภทตัวแปรอ้างอิง R1 R1 เป็นค่าที่เก็บไว้ในหน่วยความจำที่อยู่ที่ (Digital) หรือตำแหน่งของหน่วยความจำที่อยู่ของคำแรกตั้งอยู่

อยู่หน่วยความจำที่เรียกว่าเป็นตัวชี้ว่าเป็นจริงมีอีกหนึ่งคำ

มีการอ้างอิงถึงส่วนใหญ่ของประเภทของตัวชี้คำอาจจะอยู่ในหน่วยความจำที่อยู่ติดกัน (รูปแบบหน่วยความจำอย่างต่อเนื่อง) ซึ่งเป็นการคำนวณรูปแบบที่มีประสิทธิภาพมากที่สุดในการจัดเก็บเหล่านี้ยังสามารถเก็บไว้ในหน่วยความจำคำแยกย้ายกันไปแต่ละ คำบ่งชี้ที่อยู่หน่วยความจำคำถัดไป

เมื่อคำสั่งมอบหมาย R2 = R1 อ้างอิงเท่านั้น (ที่อยู่) จะถูกคัดลอก

ถ้าค่า R1 มีการเปลี่ยนแปลงแล้วค่าของการอ้างอิงทั้งหมดจะได้รับการปรับเปลี่ยนให้จุดในกรณีนี้ R2 ยังได้รับผลกระทบ

แบบสั้นใช้ = ผู้ประกอบการที่ได้รับมอบหมาย

เรารู้ว่าคุณจะสามารถสรุปประเภทของตัวแปรที่จะเริ่มต้นได้โดยตัวแปรระบบถูกละไว้คำสั่งที่เขียนไว้ในคำหลักประกาศ var เป็นจริงบิตซ้ำซ้อนเพื่อให้เราสามารถย่อพวกเขาเป็น = 50 หรือ B: = false

คอมไพเลอร์และประเภท B (int และบูล) จะอนุมานได้โดยอัตโนมัติ

นี่คือรูปแบบที่ต้องการของการใช้งานของตัวแปร แต่ก็สามารถนำมาใช้เฉพาะในร่างกายของฟังก์ชันก็ไม่สามารถนำมาใช้ในการประกาศกับมอบหมายให้ตัวแปรทั่วโลก ใช้ประกอบการ: = มีประสิทธิภาพสามารถสร้างตัวแปรที่เรียกว่าคำสั่งการเริ่มต้นใหม่

ข้อควรระวัง

หากบล็อกเดียวกันของรหัสที่เราไม่สามารถกลับมาใช้ชื่อเดียวกันสำหรับคำสั่งตัวแปรเริ่มต้นตัวอย่างเช่น: A: = 20 ไม่ได้รับอนุญาต, คอมไพเลอร์จะแสดงข้อผิดพลาดไม่มีตัวแปรใหม่บนด้านซ้าย = แต่ = 20 เป็นไปได้เพราะมันเป็นตัวแปรเดียวที่มีการกำหนดค่าใหม่

ถ้าคุณใช้มันก่อนที่คุณจะกำหนดตัวแปรที่คุณจะได้รับการรวบรวมข้อผิดพลาดไม่ได้กำหนดที่:

ถ้าคุณประกาศตัวแปรท้องถิ่น แต่ไม่ได้ใช้ในบล็อกเดียวกันของรหัสในนั้นคุณจะได้รับการรวบรวมข้อผิดพลาดเช่นตัวอย่างต่อไปนี้ซึ่งตัวแปร:

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

พยายามรวบรวมรหัสนี้จะได้รับข้อผิดพลาดและประกาศไม่ได้ใช้

นอกจากนี้เพื่อให้การกำหนดที่เรียบง่ายไม่เพียงพอค่านี้ต้องถูกนำมาใช้เพื่อให้การใช้งาน

fmt.Println("hello, world", a)

มันจะลบข้อผิดพลาด

แต่ตัวแปรทั่วโลกมีการประกาศ แต่ไม่ได้รับอนุญาตให้ใช้

ตัวแปรหลายชนิดเดียวกันสามารถประกาศในบรรทัดเดียวกันเช่น:

var a, b, c int

ตัวแปรเพิ่มเติมสามารถดูได้ที่ได้รับมอบหมายในบรรทัดเดียวกันเช่น:

a, b, c = 5, 7, "abc"

บรรทัดข้างต้นสันนิษฐานว่าตัวแปร A, B และ C ได้รับการประกาศเป็นอย่างอื่นก็ควรจะใช้วิธีนี้:

a, b, c := 5, 7, "abc"

ค่าเหล่านี้จะอยู่ทางด้านขวาในลำดับเดียวกันกำหนดให้กับตัวแปรทางด้านซ้ายเพื่อให้ค่าคือ 5, B คุ้มค่าคือ 7 ค่าของ C คือ "เอบีซี"

งานนี้เรียกว่าขนานหรือพร้อมกัน

หากคุณต้องการที่จะแลกเปลี่ยนค่าของตัวแปรทั้งสองคุณก็สามารถใช้ A, B = B เป็น

ระบุที่ว่างเปล่า _ ยังใช้ค่าทิ้งเช่นค่าของ 5: _ B = 5, 7 ถูกทอดทิ้ง

_ จริงตัวแปรเขียนเท่านั้นคุณไม่สามารถได้รับความคุ้มค่า ไปทำเช่นนี้เพราะภาษาที่คุณต้องใช้ตัวแปรทั้งหมดมีการประกาศ แต่บางครั้งคุณไม่จำเป็นต้องใช้ค่าที่ส่งกลับจากฟังก์ชั่นที่ได้รับ

ที่ได้รับมอบหมายขนานยังใช้เป็นฟังก์ชั่นคืนค่ากลับมาหลายอย่างเช่น Val และผิดพลาดข้อผิดพลาดที่นี่จะได้รับพร้อมกันโดยการเรียกฟังก์ชั่น Func1: Val ผิดพลาด = Func1 (var1)