มันเป็นการปฏิบัติที่ไม่ถูกต้องหรือไม่ที่จะเก็บค่าบางอย่างเป็นสตริง

มันเป็นชื่อที่คลุมเครือมาก แต่ฉันก็นึกไม่ออกว่าจะพูดอะไรดี แต่เพียงแค่เป็นตัวอย่างที่คิดเกี่ยวกับทิศทางที่ตัวละครในเกมที่มีการเคลื่อนไหวใน. if(character.direction == "left")มันก็รู้สึกชนิดของความผิดที่จะต้องใช้สตริงแล้วทำสิ่งที่ชอบ ดูเหมือนว่าผมว่ามันออกจากห้องมากเกินไปสำหรับข้อผิดพลาดโง่เหมือนตั้งใจใช้Leftหรือหรือสิ่งแทนl leftความสงสัยของฉันถูกต้องหรือไม่? ถ้าเป็นเช่นนั้นแล้ววิธีที่ต้องการในการบรรลุสิ่งนี้คืออะไร?

หากภาษาที่คุณใช้รองรับการใช้ enums ฉันจะใช้มัน ช่วยให้คุณสามารถ จำกัด จำนวนของตัวเลือกสำหรับประเภทที่กำหนด เช่นใน Java:

public enum Direction {
    LEFT,
    RIGHT,
    UP,
    DOWN
}

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

Enums เป็นสิ่งที่ดีหรืออย่างน้อยก็ใช้ค่าคงที่ (แน่นอนว่า enums เป็นเพียงประเภทของ wrapper สำหรับค่าคงที่ที่เกี่ยวข้องอย่างน้อยหนึ่งค่า)

const string LEFT = "left"
if (someThing == LEFT) { doStuff(); }

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

นี่คือการอ้างอิงที่รวดเร็วหนึ่งรายการฉันแน่ใจว่ามีอีกหลายร้อยรายการ: /programming/47882/what-is-a-magic-number-and-why-is-it-bad

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

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

left = "left";

หรือสิ่งที่เทียบเท่ามันมีข้อดีที่จะใช้สตริงเมื่อคุณอ้างถึงมันในรหัสของคุณ ตัวอย่างเช่น,

if (player.direction == Left)

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

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

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

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

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

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

ตามที่แนะนำให้ใช้การแจกแจงหากภาษาของคุณอนุญาต ในตัวอย่างเฉพาะของคุณมันเป็นทางเลือกที่ดีกว่าอย่างชัดเจน

เพียงใช้ประเภทข้อมูลที่เหมาะสมกับสถานการณ์ของคุณ

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

ปัญหาที่แท้จริงของโค้ดของคุณอยู่ที่การทำซ้ำค่า

อย่าทำสิ่งนี้:

if (direction == 'left') {
  goLeft();
}

หากคุณพิมพ์ผิดในเงื่อนไขอย่างใดอย่างหนึ่งเหล่านี้หรือการใช้ "ซ้าย" ในที่อื่นคุณอาจไม่สามารถค้นหารหัสฐานกว้างได้อย่างมีประสิทธิภาพเพราะคุณพิมพ์ผิด!

ให้ใช้รหัสแทนการแจงนับหรือค่าคงที่ - ขึ้นอยู่กับชนิดของข้อมูลที่คุณต้องการในภาษาที่คุณใช้

ซึ่งหมายความว่าLEFTควรกำหนดให้กับครั้งเดียวและครั้งเดียวในใบสมัครของคุณ และส่วนที่เหลือของรหัสของคุณควรใช้ประโยชน์จากค่าเหล่านั้นหรือค่าคงที่:

const string LEFT = "left";

if (direction == LEFT) {
  goLeft();
}

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

มันเป็นการปฏิบัติที่ไม่ดี?

อาจจะใช่ แต่มันขึ้นอยู่กับว่าสิ่งที่คุณกำลังทำและยังเกี่ยวกับการเขียนโปรแกรมภาษาที่คุณกำลังใช้

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

• enumประเภทจะดีกว่าถ้าเขียนโปรแกรมภาษาของคุณสนับสนุนนี้
• มิฉะนั้นค่าคงที่จำนวนเต็มชื่อจะเป็นวิธีที่จะไปด้วยคำจำกัดความเดียวสำหรับค่าคงที่

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

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

หากคุณกำลังใช้งานใน Java character.direction == "left"การปฏิบัติที่ไม่ถูกต้องด้วยเหตุผลอื่น คุณไม่ควรใช้==เพื่อเปรียบเทียบสตริงเนื่องจากเป็นการทดสอบข้อมูลเฉพาะตัวของวัตถุมากกว่าความเท่าเทียมกันของสตริง (มันจะทำงานถ้าคุณสามารถรับประกันได้ว่าอินสแตนซ์ทั้งหมดของ"left"สตริงได้รับการฝึกงาน แต่ที่ต้องมีการวิเคราะห์ทั้งหมดของแอพลิเคชัน)

ตามที่แนะนำคุณควรใช้ Enums อย่างไรก็ตามการใช้ Enum เพื่อแทนที่ Strigns นั้นไม่เพียงพอสำหรับ IMHO ในตัวอย่างของคุณความเร็วของผู้เล่นควรเป็นเวกเตอร์ด้วยฟิสิกส์:

class Vector {
  final double x;
  final double y;
}

ควรใช้เวกเตอร์นี้เพื่ออัปเดตตำแหน่งผู้เล่นแต่ละเห็บ

จากนั้นคุณสามารถรวมเข้ากับ enum เพื่อให้อ่านง่ายขึ้น:

enum Direction {
  UP(new Vector(0, 1)),
  RIGHT(new Vector(1, 0)),
  DOWN(new Vector(0, -1)),
  LEFT(new Vector(-1, 0));

  private Vector direction;

  Direction(Vector v) {
    this.direction = v;
  }

  public Vector getVector() { return this.direction; }
}