แผนภาพคลาส UML ที่มี enum อยู่ด้วย

ในการเขียนโปรแกรมคอมพิวเตอร์ประเภทแจงนับ (เรียกอีกอย่างว่าการแจงนับ , enumหรือfactorในภาษาการเขียนโปรแกรม R , condition-nameใน ภาษาการเขียนโปรแกรม COBOL , status variableใน ภาษาการเขียนโปรแกรม JOVIAL , ordinalในภาษาการเขียนโปรแกรม PL/Iและcategorical variableในสถิติ) คือประเภทข้อมูล^{[ a ]}ที่ประกอบด้วยชุดของค่า ที่มีชื่อ เรียกว่าองค์ประกอบสมาชิกตัวแจงนับหรือตัวแจงนับของประเภทนั้น ชื่อของตัวแจงนับมักจะเป็นตัวระบุที่ทำหน้าที่เป็นค่าคงที่ในภาษา ประเภทแจงนับสามารถมองได้ว่าเป็นยูเนียนแบบแท็กที่เสื่อม สภาพ ของประเภทหน่วยตัวแปรที่ประกาศว่ามีประเภทแจงนับสามารถกำหนดค่าให้กับตัวแจงนับใดก็ได้ กล่าวอีกนัยหนึ่ง ประเภทแจงนับมีค่าที่แตกต่างกัน และสามารถเปรียบเทียบและกำหนดได้ แต่โดยทั่วไป^{[ b ]}โปรแกรมเมอร์ไม่ได้ระบุว่ามีตัวแทนที่เฉพาะเจาะจงใด ๆ ในหน่วยความจำของคอมพิวเตอร์คอมไพเลอร์และอินเตอร์พรีเตอร์สามารถแสดงค่าเหล่านั้นได้ตามอำเภอใจ

ตัวอย่างเช่นชุดไพ่ ทั้งสี่ชุด ในสำรับไพ่อาจเป็นตัวแจงนับสี่ตัวที่มีชื่อว่าCLUBS, DIAMONDS, HEARTS, และSPADESซึ่งอยู่ในประเภทแจงนับที่ชื่อว่าCardSuitถ้าตัวแปรvถูกประกาศCardSuitโดยมีประเภทข้อมูลเป็น ก็สามารถกำหนดค่าใดๆ ในสี่ค่านั้นให้กับตัวแปรได้

แม้ว่าตัวแจงนับมักจะแตกต่างกัน แต่บางภาษาอาจอนุญาตให้ระบุตัวแจงนับเดียวกันได้สองครั้งในการประกาศประเภท ชื่อของตัวแจงนับไม่จำเป็นต้องมีความหมายสมบูรณ์หรือเข้ากันได้ในแง่ใดๆ ตัวอย่างเช่น ประเภทแจงนับที่เรียกว่าColorอาจถูกกำหนดให้ประกอบด้วยตัวแจงนับRED, GREEN, ZEBRA, MISSING, และBACONในบางภาษา การประกาศประเภทแจงนับยังกำหนดลำดับของสมาชิกโดยเจตนา ( HIGHลำดับMEDIUMความLOWสำคัญ) ในภาษาอื่นๆ ตัวแจงนับไม่มีลำดับ ( ภาษาที่รองรับ ENGLISH, FRENCH, GERMANและSPANISH) และในภาษาอื่นๆ ลำดับโดยนัยเกิดขึ้นจากการที่คอมไพเลอร์แสดงตัวแจงนับเป็นจำนวนเต็มอย่างเป็นรูปธรรม

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

ค่าและตัวแปรของชนิดข้อมูลแจงนับมักจะถูกนำไปใช้โดยใช้ ชนิด ข้อมูลจำนวนเต็มเป็นตัวแทนพื้นฐาน ภาษาบางภาษา โดยเฉพาะภาษาการเขียนโปรแกรมระบบอนุญาตให้ผู้ใช้ระบุชุดบิตที่จะใช้สำหรับตัวแจงนับแต่ละตัว ซึ่งอาจเป็นประโยชน์ในการแสดงชุดของตัวแจงนับอย่างมีประสิทธิภาพในรูปของสตริงบิตที่มีความยาวคงที่ ในทฤษฎี ชนิดข้อมูล ชนิดข้อมูลแจงนับมักถูกมองว่าเป็นผลรวมแบบแท็กของชนิดข้อมูลหน่วยเนื่องจากชนิดข้อมูลดังกล่าวอยู่ในรูปแบบจึงสามารถเขียนเป็นจำนวนธรรมชาติได้เช่นกัน ${\displaystyle 1+1+\cdots +1}$

ภาษาโปรแกรมยุคแรกบางภาษาไม่ได้มีประเภทข้อมูลแบบแจงนับ (enumerated types) มาตั้งแต่แรก หากโปรแกรมเมอร์ต้องการให้ตัวแปร เช่นmyColorมีค่าเป็นRED`null` ก็จะต้องประกาศตัวแปรคงที่นั้นREDและกำหนดค่าใดๆ ก็ได้ ซึ่งโดยปกติจะเป็นค่าคงที่จำนวนเต็มREDจากนั้นจึงกำหนดค่าคงที่นั้นให้กับ ตัวแปรแจง myColorนับ เทคนิคอื่นๆ อาจใช้วิธีการกำหนดค่าใดๆ ก็ได้ให้กับสตริงที่มีชื่อของตัวแจงนับอยู่

ค่าที่ไม่แน่นอนเหล่านี้บางครั้งถูกเรียกว่า " เลขมหัศจรรย์"เนื่องจากมักไม่มีคำอธิบายว่าได้ตัวเลขเหล่านั้นมาได้อย่างไร หรือค่าที่แท้จริงของตัวเลขเหล่านั้นมีความสำคัญหรือไม่ เลขมหัศจรรย์เหล่านี้อาจทำให้โค้ดต้นฉบับเข้าใจและดูแลรักษายากขึ้นสำหรับผู้อื่น

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

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

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

แม้ว่าALGOL 60เองจะไม่มีประเภทข้อมูลแบบแจงนับ แต่ภาษาโปรแกรมหลายภาษาที่สืบทอดมาจาก ALGOL 60 ก็มี โดยเฉพาะอย่างยิ่ง ภาษา Pascal มีอิทธิพลอย่างมากต่อการออกแบบภาษา Ada

ในภาษา Pascalประเภทข้อมูลแบบแจงนับสามารถประกาศโดยปริยายได้โดยการระบุค่าต่างๆ ในรายการที่อยู่ในวงเล็บ:

ชุดไพ่: ( ดอกจิก, ดอกข้าวหลามตัด, ดอกหัวใจ, ดอกโพธิ์) ;

โดยปกติแล้ว การประกาศนี้จะปรากฏอยู่ในรูปแบบการประกาศชื่อพ้องของประเภท (type synonym declaration) เพื่อให้สามารถใช้กับตัวแปรหลายตัวได้:

ประเภทชุดไพ่= ( ดอกจิก, ดอกจิก, โพแดง, โพดำ) ; ไพ่= บันทึกชุด ไพ่ : ชุดไพ่; ค่า: 1 .. 13 ; สิ้นสุด; ตัวแปรมือ: อาร์เรย์[ 1 .. 13 ] ของไพ่; ไพ่ทรัมป์: ชุดไพ่;

ลำดับการให้ค่าของรายการแจงนับมีความสำคัญ ประเภทแจงนับคือประเภทเชิงลำดับ และ ฟังก์ชัน pred`and` succจะให้ค่าก่อนหน้าหรือค่าถัดไปของรายการแจงนับ และordสามารถแปลงค่ารายการแจงนับให้เป็นค่าจำนวนเต็มได้ อย่างไรก็ตาม ภาษาปาสคาลมาตรฐานไม่มีฟังก์ชันการแปลงจากประเภทเลขคณิตเป็นรายการแจงนับ ภาษาปาสคาลแบบขยายมีฟังก์ชันนี้ผ่านsuccฟังก์ชันเพิ่มเติม ภาษาปาสคาลบางภาษาอนุญาตให้ทำได้ผ่านการแปลงประเภท ภาษาที่สืบทอดมาจากปาสคาลในปัจจุบันบางภาษา เช่นModula-3มีไวยากรณ์การแปลงพิเศษโดยใช้วิธีที่เรียกว่าVAL`modula-3` นอกจากนี้ Modula-3 ยังถือว่า `and` และ `or` BOOLEANเป็นCHARประเภทแจงนับที่กำหนดไว้ล่วงหน้าพิเศษ และใช้ `and` และ `or` ORDสำหรับVALการถอดรหัสและการเข้ารหัส ASCII มาตรฐาน

ภาษาโปรแกรมแบบ Pascal ยังอนุญาตให้ใช้การแจงนับ (enumeration) เป็นดัชนีของอาร์เรย์ได้ด้วย:

var suitcount : array [ cardsuit ] of integer ;

ในภาษา Adaนิยามของประเภทแจงนับนั้นคล้ายกับภาษา Pascal โดยแทนที่การใช้ "=" ด้วย "is":

ประเภทของชุดไพ่คือ( ดอกจิก, ข้าวหลามตัด, โพแดง, โพดำ);

นอกจากPred, Succ, ValและPosAda แล้ว ยังรองรับการแปลงสตริงแบบง่ายผ่านImageและ อีกValueด้วย

เช่นเดียวกับภาษาโปรแกรมแบบ C ภาษา Ada อนุญาตให้ระบุการแสดงผลภายในของการแจงนับได้:

สำหรับการใช้งานตามชุดไพ่( ดอกจิก=> 1 , ดอกข้าวหลามตัด=> 2 , ดอกหัวใจ=> 4 , ดอกโพธิ์=> 8 );

นอกจากนี้ Ada ยังอนุญาตให้ระบุจำนวนบิตของการแจงนับได้ในลักษณะตรงไปตรงมา ซึ่งแตกต่างจากภาษาแบบ C ที่มีการรองรับที่ไม่สอดคล้องกันซึ่งมักนำไปสู่ข้อผิดพลาดในการคอมไพล์ที่ผิดพลาดอย่าง ละเอียด อ่อน^{[ 1 ]}ตัวอย่างเช่น:

สำหรับขนาดชุดไพ่ให้ใช้4 ; -- 4 บิต

นอกจากนี้ ยังสามารถใช้ enum เป็นดัชนีสำหรับอาร์เรย์ได้ เช่นเดียวกับในภาษา Pascal แต่จะมีแอตทริบิวต์ที่กำหนดไว้สำหรับ enum เหล่านั้น

สับไพ่: อาร์เรย์คงที่( ชุดไพ่) ของชุดไพ่:= ( ดอกจิก=> ชุดไพ่' สำเร็จ( ดอกจิก), -- ดูแอตทริบิวต์ของการแจงนับ 'แรก, 'สุดท้าย, 'สำเร็จ, 'ก่อนหน้าดอกจิก= > ดอก หัวใจ , -- ค่าที่ระบุดอกหัวใจ=> ชุดไพ่' สุดท้าย, -- ค่าการแจงนับแรกของประเภทชุดไพ่ เช่น ดอกจิก ดอกโพธิ์=> ชุดไพ่' แรก-- ค่าการแจงนับสุดท้ายของประเภทชุดไพ่ เช่น ดอกโพธิ์);

เช่นเดียวกับModula-3ภาษา Ada ถือว่าBooleanและCharacterเป็นประเภทที่กำหนดไว้ล่วงหน้าพิเศษ (ในแพ็กเกจ " Standard") แต่ต่างจาก Modula-3 ตรงที่ยังสามารถกำหนดประเภทอักขระเองได้ด้วย:

ประเภทการ์ดคือ(' 7 ', ' 8 ', ' 9 ', ' X ', ' J ', ' Q ', ' K ', ' A ');

ทั้ง PL/I ดั้งเดิมและ ANSI X3.53–1976 ไม่มี enum แต่ IBM Enterprise PL/I ^{[ 2 ]}มีประเภทลำดับ

ตัวแปรเชิงลำดับไม่สามารถใช้เป็นตัวห้อยหรือเป็น ขีดจำกัด DO TO ได้โดยตรง อย่างไรก็ตาม

1. ฟังก์ชันประเภทfirstและlastรวมถึงฟังก์ชันในตัวbinaryvalue , ordinalpredและordinalsuccช่วยให้สามารถทำเช่นนั้นได้โดยอ้อม
2. DO UPTHRUและDO DOWNTOรองรับลำดับขั้น

กำหนดลำดับfoo ( green , with , envy ) ; ประกาศix เป็นลำดับfoo , bar ( first ( : foo :) : last ( : foo :)) fixed bin ; ทำซ้ำ i = first ( : foo :) ถึง last ( : foo :) ) ; bar ( i )= 13 ; สิ้นสุด; ทำซ้ำ ix = first ( : foo :)ขึ้นไปจนถึงlast ( : foo :) ) ; i = binaryvalue ( ix ) ; bar ( i ) = bar ( i ) + 1 ; สิ้นสุด; ทำซ้ำ ix = first ( : foo :)ทำซ้ำลำดับ success ( ix ) จนกระทั่ง( ix = first ( : foo :)) /* หยุดเมื่อวนรอบ */ ; i = binaryvalue ( ix ) ;แสดง( bar ( i ) || ' ที่ ' || ix ) ; สิ้นสุด;

ภาษาโปรแกรมCดั้งเดิม ของ K&Rไม่มีประเภทแจงนับ^{[ 3 ]}ใน C การแจงนับถูกสร้างขึ้นโดยคำจำกัดความที่ชัดเจน ( คำหลักเพียงอย่างเดียวไม่ทำให้เกิดการจัดสรรพื้นที่จัดเก็บ) ซึ่งใช้คำหลักและชวนให้นึกถึงคำจำกัดความของโครงสร้างและสหภาพ : enumenum

typedef enum { CLUBS , DIAMONDS , HEARTS , SPADES , } CardSuit ;typedef struct { CardSuit suit ; short int value ; } Card ;มือไพ่[ 13 ]; ไพ่ชุดทรัมป์;

ภาษา C เปิดเผยการแสดงค่าจำนวนเต็มของค่า enum ให้กับโปรแกรมเมอร์โดยตรง สามารถผสมจำนวนเต็มและค่า enum ได้อย่างอิสระ และอนุญาตให้ดำเนินการทางคณิตศาสตร์ใดๆ กับค่า enum ได้ แม้แต่ตัวแปร enum ก็สามารถเก็บค่าจำนวนเต็มที่ไม่แสดงค่า enum ใดๆ ได้ อันที่จริง ตามคำจำกัดความของภาษา โค้ดข้างต้นจะกำหนดClubs, Diamonds, Hearts, และSpadesเป็นค่าคงที่ประเภทintซึ่งจะถูกแปลง (โดยไม่แจ้งให้ทราบล่วงหน้า) เป็น ก็ต่อenum CardSuitเมื่อเก็บไว้ในตัวแปรประเภทนั้น เท่านั้น

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

enum CardSuit { CLUBS = 1 , DIAMONDS = 2 , HEARTS = 4 , SPADES = 8 , };

สามารถใช้เพื่อกำหนดประเภทที่อนุญาตให้ชุดไพ่ทางคณิตศาสตร์สามารถแสดงได้โดยใช้enum CardSuitการดำเนินการทางตรรกะแบบบิต

ตั้งแต่C23 เป็นต้น มา โปรแกรมเมอร์สามารถระบุประเภทพื้นฐานของ enum ได้โดยใช้ไวยากรณ์เดียวกับ C++ ^{[ 4 ]}ซึ่งช่วยให้โปรแกรมเมอร์สามารถสร้าง enum ที่มีประสิทธิภาพมากขึ้นโดยการเลือกประเภทพื้นฐานที่มีต้นทุนต่ำกว่า

enum CardSuit : char { CLUBS = 1 , DIAMONDS = 2 , HEARTS = 4 , SPADES = 8 , };

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

ประเภทแจงนับใน ภาษาการเขียนโปรแกรม C#รักษาความหมายของ "จำนวนเต็มขนาดเล็ก" ส่วนใหญ่ของ enum ในภาษา C ไว้ ใน C# enum ทั้งหมดเป็นคลาสที่ขยายSystem.Enum[ ^{5 ] การ}ดำเนินการทางคณิตศาสตร์บางอย่างไม่ได้กำหนดไว้สำหรับ enum แต่ค่า enum สามารถแปลงเป็นจำนวนเต็มและแปลงกลับได้อย่างชัดเจน และตัวแปร enum สามารถมีค่าที่ไม่ได้ประกาศไว้ในคำจำกัดความของ enum ตัวอย่างเช่น เมื่อกำหนด

enum CardSuit { Clubs , Diamonds , Spades , Hearts , }

อนุญาตให้ใช้ นิพจน์ ` CardSuit.Diamonds + 1and` CardSuit.Hearts - CardSuit.Clubsได้โดยตรง (เพราะอาจสมเหตุสมผลที่จะไล่ดูลำดับของค่าหรือถามว่ามีกี่ขั้นตอนระหว่างสองค่า) แต่ `or` CardSuit.Hearts * CardSuit.Spadesถือว่าสมเหตุสมผลน้อยกว่าและอนุญาตให้ใช้ได้เฉพาะในกรณีที่แปลงค่าเป็นจำนวนเต็มก่อนเท่านั้น

C# ยังมีคุณสมบัติคล้าย C ที่สามารถกำหนดค่าจำนวนเต็มเฉพาะสำหรับ enum ได้ การทำเช่นนี้ทำให้สามารถดำเนินการไบนารีกับ enum ได้ จึงถือว่าค่า enum เป็นชุดของแฟล็ก แฟล็กเหล่านี้สามารถทดสอบได้โดยใช้การดำเนินการไบนารีหรือด้วยเมธอดในตัวของประเภทHasFlag()enum ^{[ 6 ]}

คำจำกัดความของการแจงนับกำหนดชื่อสำหรับค่าจำนวนเต็มที่เลือกไว้ และเป็นเพียงรูปแบบย่อเนื่องจากสามารถกำหนดค่าจำนวนเต็มอื่น ๆ ที่ไม่อยู่ในขอบเขตของคำจำกัดความของการแจงนับให้กับตัวแปร enum ได้^{[ 7 ] [ 8 ] [ 9 ]}

C++มีประเภทข้อมูลแบบ enum ที่สืบทอดมาจาก C โดยตรง และทำงานคล้ายคลึงกัน ยกเว้นว่า enum เป็นประเภทข้อมูลจริงใน C++ ทำให้มีการตรวจสอบในระหว่างการคอมไพล์เพิ่มเติม นอกจากนี้ (เช่นเดียวกับ struct) enumคำหลักใน C++ จะรวมกับtypedefดังนั้นแทนที่จะอ้างถึงประเภทข้อมูลเป็นเราสามารถอ้างถึงมันได้ง่ายๆ เป็นซึ่งสามารถจำลองได้ในภาษา C โดยใช้ typedef:enumMyEnumMyEnumtypedefenum{VALUE_1,VALUE_2}MyEnum;

C++11ยังมี enum อีกประเภทหนึ่งที่เรียกว่าscoped enumeration enum ประเภทนี้ปลอดภัยต่อชนิดข้อมูล: ตัวแจงนับจะไม่ถูกแปลงเป็นชนิดข้อมูลจำนวนเต็มโดยปริยาย ข้อดีอย่างหนึ่งคือ สามารถกำหนดการสตรีมมิง I/O สำหรับชนิดข้อมูล enum ได้ อีกคุณสมบัติหนึ่งของ scoped enumeration คือ ตัวแจงนับต้องมีคุณสมบัติกำกับด้วยชื่อของ enum ดังนั้นการใช้งานจึงต้องมีคำนำหน้าด้วยชื่อของ enum (เช่นColor::REDสำหรับตัวแจงนับตัวแรกในตัวอย่างด้านล่าง) เว้นแต่ จะ มีการประกาศ (ที่แนะนำในC++20 ) เพื่อนำตัวแจงนับเข้ามาอยู่ในขอบเขตปัจจุบัน scoped enumeration ระบุโดยวลี(หรือ) ตัวอย่างเช่น: usingenumenumclassenumstruct

// enum แบบ unscoped สไตล์ C enum CardSuit { CLUBS , DIAMONDS , SPADES , HEARTS , };// enum แบบมีขอบเขตตามสไตล์ C++11 enum class Color { RED , GREEN , BLUE , };int main ( int argc , char * argv []) { Color c = Color :: RED ;// enum แบบ C ที่ไม่มีขอบเขตCardSuit card1 = Clubs ; // สามารถไม่มีขอบเขตได้CardSuit card2 = CardSuit :: SPADES ; // โดยปกติจะประกาศแบบมีขอบเขต}

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

// ต้องมีขนาดและโครงสร้างหน่วยความจำที่พอดีกับชนิดenum 'long' คลาสColor : long { RED , GREEN , BLUE , };// การประกาศล่วงหน้า หากภายหลังมีการกำหนดค่าที่ไม่พอดีกับ 'char' จะถือเป็นข้อผิดพลาดenum class Shapes : char ;

Goใช้iotaตัวระบุเพื่อสร้างค่าคงที่แบบแจงนับ^{[ 10 ] [ 11 ]}

ประเภทไบต์ขนาดจำนวนเต็มconst ( _ = iota // ละเว้นค่าแรกโดยกำหนดให้กับตัวระบุว่างเปล่า; 0 KB ByteSize = 1 << ( 10 * iota ) // 1 << (10 * 1) == 1 << 10 == 1024; ในรูปแบบไบนารี 10000000000 MB // 1 << (10 * 2) == 1048576; ในรูปแบบไบนารี 1000000000000000000000 GB // 1 << (10 * 3) == 1073741824; ในรูปแบบไบนารี 1000000000000000000000000000000 )

ภาษาโปรแกรม Javaเวอร์ชัน J2SE 5.0 ได้เพิ่มประเภทข้อมูลแบบแจงนับ (enumerated types) ซึ่งมีไวยากรณ์การประกาศคล้ายกับภาษาC :

enum CardSuit { CLUBS , DIAMONDS , SPADES , HEARTS , };ไพ่ชุดทรัมป์;

อย่างไรก็ตาม ระบบประเภทของ Java ถือว่า enum เป็นประเภทที่แยกต่างหากจากจำนวนเต็ม และไม่อนุญาตให้ผสมค่า enum กับค่าจำนวนเต็ม อันที่จริง ประเภท enum ใน Java เป็นคลาส พิเศษที่สร้างขึ้นโดยคอมไพเลอ ร์มากกว่าจะเป็นประเภททางคณิตศาสตร์ และค่า enum จะทำงานเหมือนอินสแตนซ์ที่สร้างไว้ล่วงหน้าทั่วโลกของคลาสนั้น ประเภท enum สามารถมีเมธอดอินสแตนซ์และคอนสตรัคเตอร์ (ซึ่งสามารถระบุอาร์กิวเมนต์แยกกันสำหรับแต่ละค่า enum ได้) ประเภท enum ทั้งหมดจะขยายEnumคลาสแบบนามธรรมโดยปริยาย ดังนั้น enum จึงไม่สามารถขยายสิ่งอื่นใดได้ คลาสjava.lang.Enum<E>ถูกจำกัดไว้ดังนี้ประเภท enum ไม่สามารถสร้างอินสแตนซ์โดยตรงได้^{[ 12 ]}Enum<EextendsEnum<E>>

ภายใน ค่า enum แต่ละค่าจะมีจำนวนเต็ม ซึ่งสอดคล้องกับลำดับที่ประกาศไว้ในซอร์สโค้ด โดยเริ่มจาก 0 โปรแกรมเมอร์ไม่สามารถกำหนดจำนวนเต็มที่กำหนดเองให้กับค่า enum ได้โดยตรง แต่สามารถกำหนดคอนสตรัคเตอร์แบบโอเวอร์โหลดที่สามารถกำหนดค่าใดๆ ให้กับสมาชิกที่กำหนดเองของคลาส enum ได้ การกำหนด getter จะช่วยให้สามารถเข้าถึงสมาชิกที่กำหนดเองเหล่านั้นได้ สามารถรับจำนวนเต็มภายในจากค่า enum ได้โดยใช้ordinal()วิธีการ และสามารถรับรายการค่า enum ของประเภทการแจงนับตามลำดับได้โดยใช้values()วิธีการ โดยทั่วไปแล้วไม่แนะนำให้โปรแกรมเมอร์แปลง enum เป็นจำนวนเต็มและในทางกลับกัน^{[ 13 ]}ประเภทการแจงนับนั้นjava.lang.Comparable<T>ใช้จำนวนเต็มภายใน ดังนั้นจึงสามารถเรียงลำดับได้

ไลบรารีมาตรฐานของ Java มีคลาสยูทิลิตี้สำหรับใช้กับ enum EnumSetคลาสนี้ใช้java.util.Set<E>ในการสร้างอาร์เรย์ของค่า enum โดยใช้บิตอาร์เรย์ซึ่งทำให้มีขนาดกะทัดรัดและมีประสิทธิภาพเท่ากับการจัดการบิตโดยตรง แต่ปลอดภัยกว่า นอกจากนี้EnumMapคลาส นี้ java.util.Map<K, V>ยังใช้ในการสร้างออบเจ็กต์ของค่า enum โดยใช้อาร์เรย์ที่มีค่าจำนวนเต็มของค่า enum เป็นดัชนี

แตกต่างจาก C++ ตรงที่ enum ใน Java สามารถมีเมธอด คอนสตรัคเตอร์ และฟิลด์ได้เหมือนกับคลาสอื่นๆ

public enum Planet { // ดาวเคราะห์ ตามด้วยมวลและรัศมีMERCURY ( 3.303e+23 , 2.4397e6 ), VENUS ( 4.869e+24 , 6.0518e6 ), EARTH ( 5.976e+24 , 6.37814e6 ), MARS ( 6.421e+23 , 3.3972e6 ), JUPITER ( 1.9e+27 , 7.1492e7 ), SATURN ( 5.688e+26 , 6.0268e7 ), URANUS ( 8.686e+25 , 2.5559e7 ), NEPTUNE ( 1.024e+26 , 2.4746e7 );public static final double G = 6.67300E-11 ;ส่วนตัวขั้นสุดท้าย มวล คู่; ส่วนตัวขั้นสุดท้ายรัศมีคู่;ดาวเคราะห์( มวลสองเท่า, รัศมีสองเท่า) { มวลนี้= มวล; รัศมีนี้= รัศมี; }private double mass () { return mass ; }private double radius () { return radius ; }double surfaceGravity () { return G * มวล/ ( รัศมี* รัศมี); }double surfaceWeight ( double otherMass ) { return otherMass * surfaceGravity (); }public static void main ( String [] args ) { double earthWeight = Double.parseDouble ( args [ 0 ] ) ; double mass = earthWeight / EARTH.surfaceGravity ( ); for ( Planet p : Planet.values ()) { System.out.printf ( " น้ำหนักของคุณบน% s คือ%f%n " , p , p.surfaceWeight ( mass ) ) ; } } }

โดยทั่วไปแล้ว ภาษาโปรแกรม แบบไดนามิกที่มีโครงสร้างไวยากรณ์แบบเดียวกับภาษา C (เช่นPerlหรือJavaScript ) จะไม่มีการใช้งาน enum แต่ในภาษา Perl นั้น สามารถได้ผลลัพธ์เดียวกันโดยใช้ลิสต์สตริง และแฮช (หรืออาจจะเป็นสไลซ์ ) แทนได้

my @enum = qw(Clubs Diamonds Hearts Spades) ; my ( %set1 , %set2 ); @set1 { @enum } = (); # ล้างทั้งหมด@set2 { @enum } = ( 1 ) x @enum ; # ตั้งค่าทั้งหมดเป็น 1 $set1 { Clubs } ... # false $set2 { Diamonds } ... # true

Raku (เดิมชื่อ Perl 6) รองรับ enum มีหลายวิธีในการประกาศ enum ใน Raku ซึ่งทั้งหมดจะสร้าง Map ในส่วนแบ็กเอนด์

enum Cat <sphynx siamese bengal shorthair other> ; # การใช้ "quote-words"

enum Cat ( 'sphynx' , 'siamese' , 'bengal' , 'shorthair' , 'other' ); # การใช้ลิสต์

enum Cat ( sphynx => 0 , siamese => 1 , bengal => 2 , shorthair => 3 , other => 4 ); # การใช้คอนสตรัคเตอร์ Pair

enum Cat (: sphynx ( 0 ), : siamese ( 1 ), : bengal ( 2 ), shorthair ( 3 ), : other ( 4 )); # อีกวิธีหนึ่งในการใช้ Pairs คุณสามารถใช้ `:0sphynx` ได้เช่นกัน

Enum ถูกเพิ่มเข้ามาใน PHP เวอร์ชัน 8.1

enum CardSuit { case Hearts ; case Diamonds ; case Clubs ; case Spades ; }

ตัวแจงนับอาจใช้ค่าสตริงหรือจำนวนเต็มเป็นตัวรองรับ เพื่อช่วยในการแปลงเป็นรูปแบบอนุกรม:

enum CardSuit : string { case Hearts = 'H' ; case Diamonds = 'D' ; case Clubs = 'C' ; case Spades = 'S' ; }

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

แม้ว่า Rust จะใช้enumคีย์เวิร์ด `unique` เหมือนกับภาษา C แต่ก็ใช้เพื่ออธิบายunion ที่มีแท็กซึ่ง enum อาจถือได้ว่าเป็นรูปแบบที่เสื่อมสภาพกว่า ดังนั้น enum ใน Rust จึงมีความยืดหยุ่นมากกว่าและสามารถมี struct และ tuple ในรูปแบบต่างๆ ได้

enum Message { Quit , Move { x : i32 , y : i32 }, // struct Write ( String ), // ทูเปิลที่มีองค์ประกอบเดียวChangeColor ( i32 , i32 , i32 ), // ทูเปิลที่มีสามองค์ประกอบ}

เช่นเดียวกับภาษา C ภาษา Rust ก็รองรับการระบุค่าของแต่ละตัวแปรด้วยเช่นกัน

pub enum Weekday { Sunday = 1 , Monday = 2 , Tuesday = 4 , Wednesday = 8 , Thursday = 16 , Friday = 32 , Saturday = 64 , }

ในภาษา C การกำหนดค่าแบบ enum จะกำหนดชื่อที่เกี่ยวข้องกันให้กับชุดของค่าจำนวนเต็ม ในภาษา Swiftการกำหนดค่าแบบ enum มีความยืดหยุ่นมากกว่าและไม่จำเป็นต้องระบุค่าสำหรับแต่ละกรณีของ enum หากมีการระบุค่า (เรียกว่า ค่า ดิบ ) สำหรับแต่ละกรณีของ enum ค่าดังกล่าวอาจเป็นสตริง อักขระ หรือค่าของจำนวนเต็มหรือเลขทศนิยมใดๆ ก็ได้

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

ใน Swift นั้น enum เป็นประเภทข้อมูลระดับเฟิร์สคลาส (first-class type) โดยมีคุณสมบัติหลายอย่างที่แต่เดิมมีเฉพาะในคลาสเท่านั้น เช่น คุณสมบัติที่คำนวณได้ (computed properties) เพื่อให้ข้อมูลเพิ่มเติมเกี่ยวกับค่าปัจจุบันของ enum และเมธอดของอินสแตนซ์ (instance methods) เพื่อให้ฟังก์ชันการทำงานที่เกี่ยวข้องกับค่าที่ enum แสดง นอกจากนี้ enum ยังสามารถกำหนดตัวเริ่มต้น (initializers) เพื่อกำหนดค่าเริ่มต้น และสามารถขยายเพื่อเพิ่มฟังก์ชันการทำงานให้มากกว่าการใช้งานดั้งเดิมได้ และยังสามารถปฏิบัติตามโปรโตคอลเพื่อให้ฟังก์ชันการทำงานมาตรฐานได้อีกด้วย

enum CardSuit { case clubs case diamonds case hearts case spades }

แตกต่างจากภาษา C และObjective-Cในภาษา Swift นั้น กรณีการแจงนับจะไม่ได้รับการกำหนดค่าจำนวนเต็มเริ่มต้นเมื่อสร้างขึ้น ในตัวอย่าง CardSuit ข้างต้น ดอกจิก เพชร หัวใจ และโพดำ ไม่ได้มีค่าเท่ากับ 0, 1, 2 และ 3 โดยปริยาย แต่กรณีการแจงนับที่แตกต่างกันเหล่านี้เป็นค่าที่สมบูรณ์ในตัวเอง โดยมีประเภท CardSuit ที่กำหนดไว้อย่างชัดเจน

สามารถแสดงกรณีหลายกรณีในบรรทัดเดียวได้ โดยคั่นด้วยเครื่องหมายจุลภาค:

enum CardSuit { case clubs , diamonds , hearts , spades }

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

ตัวอย่างเช่น เมื่อใช้จำนวนเต็มสำหรับค่าดิบ ค่าโดยนัยสำหรับแต่ละกรณีจะเป็นค่ามากกว่ากรณีก่อนหน้าหนึ่งค่า หากกรณีแรกไม่มีค่ากำหนดไว้ ค่าของกรณีนั้นจะเป็น 0 สำหรับตัวอย่าง CardSuit นั้น สามารถกำหนดหมายเลขชุดไพ่เริ่มต้นจาก 1 ได้โดยการเขียนว่า:

enum CardSuit { case clubs = 1 , diamonds , hearts , spades }

TypeScript เพิ่มชนิดข้อมูล 'enum' ให้กับ JavaScript

enum CardSuit { Clubs , Diamonds , Hearts , Spades };var c : CardSuit = CardSuit.Diamonds ;​​

โดยค่าเริ่มต้น enum จะกำหนดหมายเลขสมาชิกเริ่มต้นที่ 0 ซึ่งสามารถเปลี่ยนแปลงได้โดยการกำหนดค่าให้กับสมาชิกตัวแรก:

enum CardSuit { Clubs = 1 , Diamonds , Hearts , Spades };var c : CardSuit = CardSuit.Diamonds ;​​

สามารถตั้งค่าทุกอย่างได้:

enum CardSuit { Clubs = 1 , Diamonds = 2 , Hearts = 4 , Spades = 8 };var c : CardSuit = CardSuit.Diamonds ;​​

TypeScript รองรับการแมปค่าตัวเลขกับชื่อของมัน ตัวอย่างเช่น โค้ดนี้จะค้นหาชื่อของค่า 2:

enum CardSuit { Clubs = 1 , Diamonds , Hearts , Spades };var suitName : string = CardSuit [ 2 ];แจ้งเตือน( suitName );

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

จากenum นำเข้าEnumคลาสCardSuit ( Enum ): ดอกจิก: int = 1 ดอกเพชร: int = 2 ดอกหัวใจ: int = 3 ดอกโพธิ์: int = 4

นอกจากนี้ยังมีAPI ที่ใช้งานได้จริงสำหรับการสร้าง enum พร้อมดัชนีที่สร้างขึ้นโดยอัตโนมัติ (เริ่มต้นที่หนึ่ง):

Cards : Enum = Enum ( "Cards" , "CLUBS DIAMONDS HEARTS SPADES" )

การแจงนับใน Python ไม่ได้บังคับใช้ความถูกต้องทางความหมาย (การเปรียบเทียบที่ไม่มีความหมายกับการแจงนับที่ไม่เข้ากันจะส่งคืนค่าFalse เสมอ แทนที่จะเกิดข้อผิดพลาดTypeError ):

สี: Enum = Enum ( "สี" , "แดง เขียว น้ำเงิน" ) รูปร่าง: Enum = Enum ( "รูปร่าง" , [ "วงกลม" , "สามเหลี่ยม" , "สี่เหลี่ยม" , "หกเหลี่ยม" ])def has_vertices ( shape : Enum ) -> bool : return shape != Shape . CIRCLEถ้า__name__ == "__main__" : has_vertices ( Color . GREEN ) # แสดงผล "True"

ภาษา Dartรองรับรูปแบบพื้นฐานที่สุดของ enum และมีไวยากรณ์คล้ายกับภาษาอื่นๆ ที่รองรับ enum

enum CardSuit {สโมสร​เพชร​หัวใจ​โพดำ}void main () {CardSuit card = CardSuit . Clubs ;// ภาษา Dart ใช้ตัวดำเนินการ "switch" เพื่อจับคู่ค่าของ enum กับผลลัพธ์ที่ต้องการสวิตช์( การ์ด) {กรณีชุดไพ่ดอกจิก: {พิมพ์( "คลับ" );}หยุดพัก;กรณีชุดไพ่เพชร: {พิมพ์( "เพชร" );}หยุดพัก;กรณีชุดไพ่. หัวใจ: {พิมพ์( "หัวใจ" );}หยุดพัก;กรณีชุดไพ่. โพดำ: {พิมพ์( "โพดำ" );}หยุดพัก;ค่าเริ่มต้น: {พิมพ์( "ไม่ทราบ" );}หยุดพัก;}}

โปรดทราบว่าก่อน Dart 3 ^{[ 14 ]}ตัวดำเนินการ switch ไม่รับประกันความสมบูรณ์ของกรณีต่างๆ ซึ่งหมายความว่าหากคุณละเว้นกรณีใดกรณีหนึ่ง คอมไพเลอร์จะไม่แสดงข้อผิดพลาด

ในภาษา COBOLตัวแปรเงื่อนไข (condition-variable) คือตัวแปรปกติที่มีฟิลด์ระดับ 88 ย่อยที่เรียกว่าชื่อเงื่อนไข (condition-name) แต่ละชื่อเงื่อนไขต้องมีส่วนคำสั่ง VALUE ส่วนคำสั่ง VALUE สำหรับเงื่อนไขอาจระบุค่าเดียวหรือรายการของค่าก็ได้

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

enum , bind ( C ) enumerator :: CLUBS = 1 , DIAMONDS = 2 , HEARTS = 4 , SPADES = 8 end enum

Fortran 2023 ได้นำเสนอประเภทข้อมูลแบบแจงนับ (enumeration) ที่แท้จริง โดยค่าต่างๆ จะเรียงลำดับตามลำดับที่กำหนดไว้ ฟังก์ชันพื้นฐาน (intrinsic functions) intและhugeรองรับการแจงนับ นอกจากนี้ยังมีฟังก์ชันnextและpreviousให้ใช้งานอีกด้วย

ประเภทการแจงนับ:: วันในสัปดาห์ตัวแจงนับ:: วัน จันทร์ วันอังคารวันพุธวันพฤหัสบดี วันศุกร์ตัวแจงนับ:: วันเสาร์วันอาทิตย์สิ้นสุดประเภทการแจงนับประเภท( วันในสัปดาห์) :: วัน: ถ้า( วัน== วันพุธ) แล้ว พิมพ์* , 'วันพุธกลางสัปดาห์' จบ ถ้า: เลือก กรณี( วัน) กรณี( วันจันทร์: วันศุกร์) พิมพ์* , 'วันธรรมดา' กรณี( วันเสาร์, วันอาทิตย์) พิมพ์* , 'วันหยุดสุดสัปดาห์' จบ เลือก

Enum CardSuit ' Zero-based Clubs Diamonds Hearts Spades End EnumSub EnumExample () Dim suit As CardSuit suit = Diamonds MsgBox suit End Sub

Enum CardSuit Clubs Diamonds Hearts Spades End EnumSub EnumExample () Dim suit As CardSuit suit = CardSuit . Diamonds MessageBox . show ( suit ) End Sub

ภาษา Common Lispใช้ตัวระบุประเภทสมาชิก เช่น

( deftype cardsuit () ' ( member club diamond heart spade ))

นั่นหมายความว่าวัตถุนั้นมีประเภทเป็นชุดไพ่ ถ้าเป็น#'eqlดอกจิก ดอกเพชร ดอกหัวใจ หรือดอกโพธิ์ อย่างไรก็ตาม ตัวระบุประเภทสมาชิกนั้นไม่ถูกต้องในฐานะตัวกำหนดพารามิเตอร์พิเศษของCommon Lisp Object System(eql atom) (CLOS) แต่สามารถใช้ ซึ่งเทียบเท่ากับ ได้(member atom)(กล่าวคือ สามารถระบุสมาชิกเพียงหนึ่งเดียวของเซตด้วยตัวระบุประเภท eql ได้ แต่สามารถใช้เป็นตัวกำหนดพารามิเตอร์พิเศษของ CLOS ได้) กล่าวอีกนัยหนึ่ง ในการกำหนดเมธอดเพื่อครอบคลุมประเภทแจงนับ จะต้องกำหนดเมธอดสำหรับแต่ละองค์ประกอบเฉพาะของประเภทนั้น

นอกจากนี้

( deftype finite-element-set-type ( &rest elements ) ` ( member ,@ elements ))

อาจใช้เพื่อกำหนดประเภทแจงนับแบบใดก็ได้ในระหว่างการทำงาน ตัวอย่างเช่น

( finite-element-set-type club diamond heart spade )

จะหมายถึงประเภทที่เทียบเท่ากับคำจำกัดความก่อนหน้าของชุดไพ่ ซึ่งแน่นอนว่าจะใช้คำนั้นแทน

( สมาชิกคลับเพชร รูปหัวใจรูปโพธิ์)

แต่การใช้ฟังก์ชันอาจไม่สับสนมากนัก#'memberเนื่องจากเหตุผลด้านรูปแบบ

ใน ภาษา การเขียนโปรแกรมเชิงฟังก์ชันใน ตระกูล ML (เช่นStandard ML (SML), OCamlและHaskell ) สามารถใช้ ชนิดข้อมูลเชิงพีชคณิตที่มีเฉพาะคอนสตรัคเตอร์ที่เป็นค่าว่าง (nullary constructor ) เพื่อสร้างชนิดข้อมูลแบบแจงนับได้ ตัวอย่างเช่น (ในไวยากรณ์ของลายเซ็น SML):

ชนิดข้อมูลcardsuit = Clubs | Diamonds | Hearts | Spades ชนิดcard = { suit : cardsuit ; value : int } val hand : card list val trump : cardsuit

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

ฐานข้อมูลบางแห่งรองรับประเภทแจงนับโดยตรงMySQLมีประเภทแจงนับENUMที่มีค่าที่อนุญาตระบุเป็นสตริงเมื่อสร้างตาราง ค่าจะถูกจัดเก็บเป็นดัชนีตัวเลข โดยสตริงว่างจะถูกจัดเก็บเป็น 0 ค่าสตริงแรกจะถูกจัดเก็บเป็น 1 ค่าสตริงที่สองจะถูกจัดเก็บเป็น 2 เป็นต้น ค่าสามารถจัดเก็บและเรียกใช้เป็นดัชนีตัวเลขหรือค่าสตริงได้^{[ 15 ]}

ตัวอย่าง:

สร้างตารางshirts ( name VARCHAR ( 40 ), size ENUM ( 'x-small' , 'small' , 'medium' , 'large' , 'x-large' ) );

สามารถกำหนดได้ในสคีมา JSON โดยใช้คีย์เวิร์ด "enum" ^{[ 16 ]}

{ "$schema" : "https://json-schema.org/draft/2020-12/schema" , "type" : "object" , "properties" : { "cardsuit" : { "type" : "string" , "enum" : [ "Clubs" , "Diamonds" , "Hearts" , "Spades" ] } }, "required" : [ "cardsuit" ] }

XML Schemaรองรับประเภทข้อมูลแบบแจงนับผ่านทางฟีเจอร์การแจงนับ ซึ่งใช้สำหรับจำกัดประเภทข้อมูลพื้นฐานส่วนใหญ่ เช่น สตริง

<xs:element name= "cardsuit" > <xs:simpleType> <xs:restriction base= "xs:string" > <xs:enumeration value= "Clubs" /> <xs:enumeration value= "Diamonds" /> <xs:enumeration value= "Hearts" /> <xs:enumeration value= "Spades" /> </xs:restriction> </xs:simpleType> </xs:element>

• ชุดคอนทราสต์

หนังสือวิกิเกี่ยวกับการเขียนโปรแกรมภาษาอะดามีหน้าหนึ่งที่กล่าวถึงหัวข้อ: การแจงนับ (Enumeration)

• ประเภทข้อมูลแบบแจงนับในภาษา C/C++ เก็บถาวรเมื่อ 2008-04-03 ที่Wayback Machine
• ประเภทแจงนับใน C#
• ประเภทแจงนับใน Java
• ประเภทแจงนับใน MySQL
• ประเภทแจงนับใน Obix
• ประเภทแจงนับใน PHP
• ประเภทแจงนับใน Swift
• ประเภทแจงนับใน XML
• ประเภทแจงนับใน Visual Basic