ตัวแปร (วิทยาการคอมพิวเตอร์)

จากวิกิพีเดีย สารานุกรมเสรี
ข้ามไปที่การนำทาง ข้ามไปที่การค้นหา

ในการเขียนโปรแกรมคอมพิวเตอร์ตัวแปรคือที่เก็บข้อมูลนามธรรมที่จับคู่กับชื่อสัญลักษณ์ ที่เกี่ยวข้อง ซึ่งประกอบด้วยข้อมูลจำนวนหนึ่งที่รู้จักหรือไม่รู้จักซึ่งเรียกว่าค่า หรือในแง่ที่ง่ายกว่า ตัวแปรคือคอนเทนเนอร์สำหรับชุดของบิตหรือประเภทข้อมูล เฉพาะ (เช่น จำนวนเต็ม ทุ่น สตริง ฯลฯ...) ตัวแปรสามารถเชื่อมโยงหรือระบุได้ด้วยที่อยู่หน่วยความจำในที่สุด ชื่อตัวแปรเป็นวิธีปกติในการอ้างอิงค่าที่เก็บไว้ นอกเหนือจากการอ้างถึงตัวแปรเอง ขึ้นอยู่กับบริบท การแยกชื่อและเนื้อหานี้ทำให้สามารถใช้ชื่อแยกจากข้อมูลที่ถูกต้องได้ ตัวระบุในซอร์สโค้ดของ คอมพิวเตอร์ สามารถผูกกับค่าระหว่างรันไทม์และค่าของตัวแปรอาจเปลี่ยนแปลงได้ในระหว่างการ ดำเนิน การโปรแกรม [1] [2] [3] [4]

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

ตำแหน่งการจัดเก็บของตัวแปรอาจถูกอ้างอิงโดยตัวระบุต่างๆ สถานการณ์ที่เรียกว่าaliasing การกำหนดค่าให้กับตัวแปรโดยใช้ตัวระบุตัวใดตัวหนึ่งจะเปลี่ยนค่าที่สามารถเข้าถึงได้ผ่านตัวระบุอื่นๆ

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

การดำเนินการกับตัวแปร

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

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

ตัวแปรคือภาชนะสำหรับเก็บค่า

ตัวแปรและขอบเขต:

  • ตัวแปรอัตโนมัติ : ตัวแปรโลคัลแต่ละตัวในฟังก์ชันจะมีขึ้นเมื่อมีการเรียกใช้ฟังก์ชันเท่านั้น และจะหายไปเมื่อออกจากฟังก์ชัน ตัวแปรดังกล่าวเรียกว่าตัวแปรอัตโนมัติ
  • ตัวแปรภายนอก: ตัวแปรเหล่านี้เป็นตัวแปรภายนอกฟังก์ชันและสามารถเข้าถึงได้โดยใช้ชื่อโดยฟังก์ชันใดๆ ตัวแปรเหล่านี้ยังคงมีอยู่อย่างถาวร แทนที่จะปรากฏและหายไปเมื่อมีการเรียกใช้และออกจากฟังก์ชัน ฟังก์ชันจะคงค่าไว้แม้หลังจากที่ฟังก์ชันที่ตั้งค่าไว้กลับคืนมา

ตัวระบุที่อ้างอิงตัวแปร

ตัวระบุที่อ้างอิงตัวแปรสามารถใช้ในการเข้าถึงตัวแปรเพื่ออ่านค่า หรือแก้ไขค่า หรือแก้ไขแอตทริบิวต์ อื่นๆ ของตัวแปร เช่น การอนุญาตการเข้าถึงการ ล็อกสัญญาณเป็นต้น

ตัวอย่างเช่น ตัวแปรอาจถูกอ้างอิงโดยตัวระบุ " total_count" และตัวแปรสามารถมีตัวเลข 1956 ได้ หากตัวระบุ " " อ้างอิงตัวแปรเดียวกันrและหากใช้ตัวระบุนี้ " r" ค่าของตัวแปรจะเป็น เปลี่ยนแปลงเป็นปี 2009 จากนั้นการอ่านค่าโดยใช้ตัวระบุ " total_count" จะให้ผลลัพธ์เป็นปี 2009 ไม่ใช่ปี 1956

หากตัวแปรถูกอ้างอิงโดยตัวระบุตัวเดียว ตัวระบุนั้นสามารถเรียกง่ายๆ ว่า ชื่อ ของตัวแปร มิฉะนั้นเราสามารถพูดถึงมันเป็นหนึ่งในชื่อของตัวแปร ตัวอย่างเช่น ในตัวอย่างก่อนหน้านี้ ตัวระบุ " total_count" คือชื่อของตัวแปรที่เป็นปัญหา และ " r" เป็นอีกชื่อหนึ่งของตัวแปรเดียวกัน

ขอบเขตและขอบเขต

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

ขอบเขตเป็นส่วนสำคัญของการแก้ปัญหาชื่อของตัวแปร ภาษาส่วนใหญ่จะกำหนดขอบเขต เฉพาะ สำหรับแต่ละตัวแปร (เช่นเดียวกับเอนทิตีที่มีชื่ออื่นๆ) ซึ่งอาจแตกต่างออกไปภายในโปรแกรมที่กำหนด ขอบเขตของตัวแปรคือส่วนของข้อความของโปรแกรมที่ชื่อตัวแปรมีความหมายและตัวแปรนั้น "มองเห็นได้" การเข้าสู่ขอบเขตนั้นมักจะเริ่มต้นอายุการใช้งานของตัวแปร (เมื่ออยู่ในบริบท) และการออกจากขอบเขตนั้นมักจะสิ้นสุดอายุการใช้งาน (เมื่อไม่อยู่ในบริบท) ตัวอย่างเช่น ตัวแปรที่มี " lexical scope " มีความหมายเฉพาะภายในฟังก์ชัน/ รูทีนย่อย บางอย่าง หรือละเอียดกว่านั้นภายในกลุ่มของนิพจน์/คำสั่ง (ตามขอบเขตการทำงานหรือ ขอบเขต บล็อก ); นี่คือความละเอียดคงที่ ดำเนินการได้ในเวลา parse-time หรือ compile-time อีกทางหนึ่ง ตัวแปรที่มีขอบเขตไดนามิกจะได้รับการแก้ไขในขณะทำงาน โดยยึดตามสแต็กการโยงสากลที่ขึ้นอยู่กับโฟลว์การควบคุมเฉพาะ ตัวแปรที่เข้าถึงได้เฉพาะในฟังก์ชันบางอย่างเท่านั้นที่เรียกว่า " ตัวแปรท้องถิ่น " " ตัวแปรส่วนกลาง " หรือตัวแปรที่มีขอบเขตไม่จำกัด อาจถูกอ้างอิงถึงที่ใดก็ได้ในโปรแกรม

ในทางกลับกัน Extentเป็นลักษณะรันไทม์ ( ไดนามิก ) ของตัวแปร การเชื่อมโยงตัวแปรแต่ละค่าเข้ากับค่าสามารถมีขอบเขตของตัวเองได้ในขณะรันไทม์ ขอบเขตของการผูกคือส่วนของเวลาดำเนินการของโปรแกรมในระหว่างที่ตัวแปรยังคงอ้างถึงค่าเดิมหรือตำแหน่งหน่วยความจำ โปรแกรมที่ทำงานอยู่อาจเข้าและออกจากขอบเขตที่กำหนดหลายครั้ง เช่น ในกรณีของการ ปิด

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

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

ถือเป็นแนวทางปฏิบัติที่ดีในการเขียนโปรแกรมเพื่อทำให้ขอบเขตของตัวแปรแคบลงที่สุดเท่าที่จะเป็นไปได้ เพื่อที่ส่วนต่างๆ ของโปรแกรมจะไม่โต้ตอบกันโดยไม่ได้ตั้งใจโดยการปรับเปลี่ยนตัวแปรของกันและกัน การ ทำเช่นนี้ยังป้องกันการกระทำในระยะไกล เทคนิคทั่วไปในการทำเช่นนั้นคือการให้ส่วนต่างๆ ของโปรแกรมใช้ช่องว่างชื่อ ต่างกัน หรือทำให้ตัวแปรแต่ละตัว "ส่วนตัว" ผ่านการกำหนดขอบเขตตัวแปรแบบไดนามิกหรือ การกำหนดขอบเขต ของ ตัวแปรศัพท์

ภาษาโปรแกรมหลายภาษาใช้ค่าที่สงวนไว้ (มักมีชื่อว่าnullหรือnil ) เพื่อบ่งชี้ตัวแปรที่ไม่ถูกต้องหรือไม่ได้กำหนดค่าเริ่มต้น

กำลังพิมพ์

ใน ภาษาที่ พิมพ์แบบสแตติกเช่นGoหรือMLตัวแปรยังมีtypeซึ่งหมายความว่าสามารถจัดเก็บค่าบางประเภทได้เท่านั้น ตัวอย่างเช่น ตัวแปรประเภท " จำนวนเต็ม " ถูกห้ามมิให้จัดเก็บค่าข้อความ

ใน ภาษาที่ พิมพ์แบบไดนามิกเช่นPythonประเภทของตัวแปรจะถูกอนุมานด้วยค่าของตัวแปร และสามารถเปลี่ยนแปลงได้ตามค่าของตัวแปร ในCommon Lispทั้งสองสถานการณ์มีอยู่พร้อมกัน: ตัวแปรจะได้รับประเภท (หากไม่ได้ประกาศ จะถือว่าเป็นsupertypeTสากล) ซึ่งมีอยู่ในเวลารวบรวม ค่ายังมีประเภทอีกด้วย ซึ่งสามารถตรวจสอบและสอบถาม ณ รันไทม์ได้

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

ตัวแปรมักจะจัดเก็บข้อมูลอย่างง่าย เช่น จำนวนเต็มและสตริงตามตัวอักษร แต่ภาษาโปรแกรมบางภาษาอนุญาตให้ตัวแปรเก็บค่าของประเภทข้อมูล อื่นๆ เช่นกัน ภาษาดังกล่าวยังอาจเปิดใช้งานฟังก์ชันต่างๆ ให้เป็นแบบพาราเมตริกพหุสัณฐาน ฟังก์ชันเหล่านี้ทำงานเหมือนตัวแปรเพื่อแสดงข้อมูลหลายประเภท ตัวอย่างเช่น ฟังก์ชันที่มีชื่อlengthอาจกำหนดความยาวของรายการ ฟังก์ชัน ดังกล่าวlengthอาจเป็นตัวแปรแบบพาราเมตริกโดยการรวมตัวแปรประเภทไว้ในลายเซ็นประเภทเนื่องจากจำนวนองค์ประกอบในรายการไม่ขึ้นกับประเภทขององค์ประกอบ

พารามิเตอร์

พารามิเตอร์ที่ เป็นทางการ (หรืออาร์กิวเมนต์ ที่เป็นทางการ ) ของฟังก์ชันเรียกอีกอย่างว่าตัวแปร ตัวอย่างเช่น ในส่วนโค้ด Python นี้

>>> def  addtwo ( x ): 
...     return  x  +  2 
... 
>>> addtwo ( 5 ) 
7

ตัวแปรที่ตั้งชื่อxเป็นพารามิเตอร์เนื่องจากได้รับค่าเมื่อเรียกใช้ฟังก์ชัน จำนวนเต็ม 5 คืออาร์กิวเมนต์ที่ให้xค่าของมัน ในภาษาส่วนใหญ่ พารามิเตอร์ของฟังก์ชันมีขอบเขตในเครื่อง ชื่อตัวแปรเฉพาะนี้xสามารถอ้างถึงได้ภายในaddtwoฟังก์ชันเท่านั้น (แม้ว่าฟังก์ชันอื่น ๆ ก็สามารถเรียกตัวแปรได้ ด้วยเช่นกัน x)

การจัดสรรหน่วยความจำ

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

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

ออบเจ็กต์ที่จัดสรรจากฮีปจะต้องถูกเรียกคืน—โดยเฉพาะอย่างยิ่งเมื่อไม่ต้องการอ็อบเจ็กต์อีกต่อไป ใน ภาษา ที่รวบรวมโดยขยะ (เช่นC# , Java , Python, Golang และLisp ) สภาพแวดล้อมรันไทม์จะเรียกคืนอ็อบเจ็กต์โดยอัตโนมัติเมื่อตัวแปรที่ยังหลงเหลืออยู่ไม่สามารถอ้างถึงได้อีกต่อไป ในภาษาที่ไม่เก็บขยะ เช่นCโปรแกรม (และโปรแกรมเมอร์) จะต้องจัดสรรหน่วยความจำอย่างชัดเจน จากนั้นจึงปล่อยให้ว่างในภายหลัง เพื่อเรียกคืนหน่วยความจำ ความล้มเหลวในการดำเนินการดังกล่าวจะนำไปสู่หน่วยความจำรั่วซึ่งฮีพหมดลงในขณะที่โปรแกรมทำงาน เสี่ยงต่อความล้มเหลวในท้ายที่สุดจากการใช้หน่วยความจำที่มีอยู่จนหมด

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

หลักการตั้งชื่อ

ตัวแปรการเขียนโปรแกรมและค่าคงที่ต่างจากคู่ทางคณิตศาสตร์ของพวกมัน ปกติแล้วจะใช้ชื่อหลายอักขระ เช่นCOSTหรือtotal. ชื่อตัวอักษรเดียวมักใช้กับตัวแปรเสริมเท่านั้น ตัวอย่างเช่น , i, jสำหรับkตัวแปรดัชนี อาร์เรย์

หลักการตั้งชื่อบางอย่างบังคับใช้ที่ระดับภาษาโดยเป็นส่วนหนึ่งของไวยากรณ์ภาษาที่เกี่ยวข้องกับรูปแบบของตัวระบุที่ถูกต้อง ในเกือบทุกภาษา ชื่อตัวแปรต้องไม่ขึ้นต้นด้วยตัวเลข (0–9) และไม่มีอักขระเว้นวรรค เครื่องหมายวรรคตอนจะได้รับอนุญาตในชื่อตัวแปรหรือไม่แตกต่างกันไปในแต่ละภาษา หลายภาษาอนุญาตเฉพาะขีดล่าง ("_") ในชื่อตัวแปรและห้ามเครื่องหมายวรรคตอนอื่นๆ ทั้งหมด ในภาษาโปรแกรมบางภาษาเครื่องหมาย (สัญลักษณ์หรือเครื่องหมายวรรคตอน) จะติดอยู่กับตัวระบุตัวแปรเพื่อระบุประเภทข้อมูลหรือขอบเขตของตัวแปร

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

อย่างไรก็ตาม นอกเหนือจากข้อจำกัดพื้นฐานที่กำหนดโดยภาษา การตั้งชื่อตัวแปรส่วนใหญ่เป็นเรื่องของรูปแบบ ที่ ระดับ รหัสเครื่องจะไม่มีการใช้ชื่อตัวแปร ดังนั้นชื่อที่แน่นอนที่เลือกจึงไม่สำคัญกับคอมพิวเตอร์ ดังนั้นชื่อของตัวแปรจึงระบุได้ ส่วนที่เหลือเป็นเพียงเครื่องมือสำหรับโปรแกรมเมอร์เพื่อให้โปรแกรมเขียนและเข้าใจได้ง่ายขึ้น การใช้ชื่อตัวแปรที่เลือกได้ไม่ดีอาจทำให้ตรวจสอบโค้ดได้ยากกว่าชื่อที่ไม่มีคำอธิบาย ดังนั้นจึงขอแนะนำให้ใช้ชื่อที่ชัดเจน [5] [6]

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

ประเภทตัวแปร (ตามอายุการใช้งาน)

เราสามารถจำแนกตัวแปรตามอายุการใช้งานได้ ตัวแปรประเภทต่างๆ ได้แก่ สแตติก สแต็กไดนามิก ฮีปไดนามิกที่ชัดเจน และฮีปไดนามิกโดยนัย ตัวแปรคงที่เรียกอีกอย่างว่าตัวแปรโกลบอล มันถูกผูกไว้กับเซลล์หน่วยความจำก่อนเริ่มดำเนินการ และยังคงอยู่ในเซลล์หน่วยความจำเดียวกันจนกว่าจะสิ้นสุด ตัวอย่างทั่วไปคือตัวแปรคงที่ใน C และ C++ ตัวแปรสแต็กไดนามิกเรียกว่าตัวแปรโลคัล ซึ่งถูกผูกไว้เมื่อมีการดำเนินการคำสั่งการประกาศ และจะถูกจัดสรรคืนเมื่อโพรซีเดอร์กลับมา ตัวอย่างหลักคือตัวแปรโลคัลในโปรแกรมย่อย C และเมธอด Java ตัวแปร Heap-Dynamic ที่ชัดเจนคือเซลล์หน่วยความจำที่ไม่มีชื่อ (นามธรรม) ที่ได้รับการจัดสรรและจัดสรรคืนโดยคำสั่งรันไทม์ที่ชัดเจนซึ่งระบุโดยโปรแกรมเมอร์ ตัวอย่างหลักคืออ็อบเจ็กต์ไดนามิกใน C++ (ผ่านใหม่และลบ) และอ็อบเจ็กต์ทั้งหมดใน Java ตัวแปร Heap-Dynamic โดยนัยถูกผูกไว้กับหน่วยเก็บข้อมูลฮีปเฉพาะเมื่อได้รับการกำหนดค่า การจัดสรรและการปล่อยจะเกิดขึ้นเมื่อมีการกำหนดค่าใหม่ให้กับตัวแปร ด้วยเหตุนี้ ตัวแปรฮีปไดนามิกโดยนัยจึงมีระดับความยืดหยุ่นสูงสุด ตัวอย่างหลักคือตัวแปรบางตัวใน JavaScript, PHP และตัวแปรทั้งหมดใน APL

ดูเพิ่มเติม

หมายเหตุ

  1. ^ ตัวอย่างเช่น Haskellกำหนดให้ชื่อประเภทขึ้นต้นด้วยอักษรตัวใหญ่

อ้างอิง

  1. ^ คอมไพเลอร์: หลักการ เทคนิค และเครื่องมือ , pp. 26–28
  2. ^ คนุธ, โดนัลด์ (1997). ศิลปะแห่งการเขียนโปรแกรมคอมพิวเตอร์ . ฉบับที่ ครั้งที่ 1 (ฉบับที่ 3) เรดดิ้ง แมสซาชูเซตส์: แอดดิสัน-เวสลีย์ หน้า 3-4. ISBN 0-201-89683-4.
  3. ^ "การเขียนโปรแกรมด้วยตัวแปร" . ข่าน อะคาเดมี่. สืบค้นเมื่อ23 มีนาคม 2020 .
  4. ^ "ขีดข่วนสำหรับ Coders รุ่น" . ฮาร์วาร์ด. สืบค้นเมื่อ23 มีนาคม 2020 .
  5. ^ How Not To Pick Variables , สืบค้นเมื่อ 11 กรกฎาคม 2555 [DEAD LINK]
  6. ^ Edsger Dijkstra สู่ นรกด้วย "ตัวระบุที่มีความหมาย"!