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

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

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

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

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

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

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

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

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

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

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

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

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

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

หากภาษาโปรแกรมไม่มีระบบจัดการ หน่วยความจำอัตโนมัติ (garbage collection ) ตัวแปรที่มีขอบเขตการใช้งานเกินขอบเขตที่กำหนดไว้อย่างถาวร อาจทำให้เกิด การรั่วไหลของ หน่วยความจำ (memory leak ) ซึ่งหมายความว่าหน่วยความจำที่จัดสรรให้กับตัวแปรนั้นจะไม่สามารถถูกปล่อยคืนได้ เนื่องจากตัวแปรที่จะใช้อ้างอิงเพื่อปล่อยคืนนั้นไม่สามารถเข้าถึงได้อีกต่อไป อย่างไรก็ตาม การผูกตัวแปรให้ขยายเกินขอบเขตที่กำหนดไว้อาจเป็นไปได้ เช่นเดียวกับที่เกิดขึ้นในclosures ของ Lisp และตัวแปร local แบบ static ของ C เมื่อการทำงานกลับเข้าสู่ขอบเขตของตัวแปร ตัวแปรนั้นก็อาจถูกนำมาใช้อีกครั้ง ตัวแปรที่มีขอบเขตเริ่มต้นก่อนขอบเขตการใช้งานจะเรียกว่าไม่ได้กำหนดค่าเริ่ม ต้น ( uninitialized ) และมักจะมีค่าที่ไม่แน่นอนหากมีการเข้าถึง (ดูwild pointer ) เนื่องจากยังไม่ได้กำหนดค่าเฉพาะเจาะจงให้ ตัวแปรที่มีขอบเขตการใช้งานสิ้นสุดก่อนขอบเขตที่กำหนดไว้อาจกลายเป็นdangling pointerและถือว่าไม่ได้กำหนดค่าเริ่มต้นอีกครั้ง เนื่องจากค่าของมันถูกทำลายไปแล้ว ตัวแปรที่อธิบายไว้ในสองกรณีข้างต้นอาจกล่าวได้ว่าอยู่ นอกขอบเขตการใช้งาน (out of extent)หรือไม่ถูกผูกมัด (unbound ) ในหลายภาษา การพยายามใช้ค่าของตัวแปรที่อยู่นอกขอบเขตถือเป็นข้อผิดพลาด ในบางภาษา การทำเช่นนั้นอาจให้ผลลัพธ์ที่ไม่สามารถคาดเดาได้อย่างไรก็ตาม ตัวแปรดังกล่าวอาจได้รับการกำหนดค่าใหม่ ซึ่งจะทำให้ตัวแปรนั้นมีขอบเขตใหม่

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

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

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

ใน ภาษา ที่มีการกำหนดประเภทแบบคงที่เช่นC , C++ , JavaหรือC#ตัวแปรยังมีประเภท ด้วย ซึ่งหมายความว่าสามารถเก็บค่าได้เฉพาะบางประเภทเท่านั้น ตัวอย่างเช่น ตัวแปรประเภท " จำนวนเต็ม " จะไม่สามารถเก็บค่าข้อความได้^{[ 6 ]}

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

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

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

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

def add_two ( x : int ) -> int : return x + 2พิมพ์( add_two ( 5 )) # พิมพ์: 7

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

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

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

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

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

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

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

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

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

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

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