อะไรคือความแตกต่างระหว่างคำนำหน้าชื่อ“ กับ” และ“ เป็น” ความแตกต่าง? [ปิด]

ความแตกต่างระหว่าง"กับ"และ"เป็น"คำนำหน้าชื่อเมธอดเช่นคืออะไร

• ToList ()
• asList ()
• ฯลฯ ...

เมื่อใดที่จะใช้ซึ่งเมื่อออกแบบวิธีการ?

toXYZ()ฟังก์ชั่นที่คาดว่าจะทำแปลงและจะกลับมาใหม่เป็นอิสระวัตถุ ( แต่เปลี่ยนไม่ได้ช่วยให้การเพิ่มประสิทธิภาพjava.lang.String.toString()เพียงแค่ส่งกลับวัตถุ)
_{ตัวอย่างเช่นใน C ++ เรามีstd::bitset::to_ulong()สิ่งที่สามารถล้มเหลวได้อย่างง่ายดายและมีto_string()การแปลงที่ซับซ้อน (มากหรือน้อย) ทั้งหมดและทำการจัดสรรหน่วยความจำ}

asXYZ()ฟังก์ชั่นบนมืออื่น ๆ ที่คาดว่าจะกลับมาเป็น (ที่แตกต่างกันอาจ) มุมมองของแหล่งที่มาของการทำงานน้อยที่สุด
_{ตัวอย่างเช่นใน C ++ เรามีstd::as_const()เพียงแค่คืนค่าอ้างอิงคงที่และยิ่งเกี่ยวข้องstd::forward_as_tupleซึ่งอ้างอิงถึงการขัดแย้งโดยอ้างอิง}

สุจริตอาจเป็นเพียงการตั้งชื่อที่ไม่สอดคล้องกัน หากมองไปที่วัตถุห้องสมุดมาตรฐานในสมอลล์ทอล์คเช่นวิธีการทั้งหมดที่ทำ "แปลงซับซ้อน" หรือ "กลับมาแสดงที่เรียบง่ายในรูปแบบอื่น" จะมีคำนำหน้าasเช่นเดียวกับในasString, asFloat, และวิธีการมาตรฐานสำหรับการแปลงอะไรเพื่ออะไรอื่นasSecondsas: aClass

ในทับทิมชนิดเดียวกันของวิธีการจะมีคำนำหน้าto_เช่นเดียวกับในto_s, to_a, to_hสั้นstring, arrayและhashตามลำดับ

ทั้งห้องสมุดมาตรฐานดูเหมือนจะแยกความแตกต่างระหว่างการแปลงประเภทต่าง ๆ อาจเป็นเพราะมันควรจะถือเป็นรายละเอียดการใช้งาน

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

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

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

String[] wordArray = {"one", "fine", "day"};
List<String> wordList = Arrays.asList(wordArray);

// changes to the array are visible in the list
System.out.println(wordList); // prints "[one, fine, day]"
wordArray[1] = "horrible";
System.out.println(wordList); // prints "[one, horrible, day]"

// changes to the list are visible in the array
wordList.set(1, "beautiful");
System.out.println(wordArray[1]); // prints "beautiful"

// but changes to the list or array don't affect the 
// result from the list's toArray method.
String[] moreWords = wordList.toArray(new String[] {});
wordList.set(0, "the");
wordArray[1] = "best";
for (int i=0; i<3; i++) {
  System.out.println(moreWords[i]); // prints "one", "beautiful", and "day"
}

ทั้งหมดที่กล่าวมาไม่มีการรับประกันว่านักพัฒนาห้องสมุดทุกคนจะปฏิบัติตามอนุสัญญานี้ดังนั้นคุณยังต้องตรวจสอบเอกสารเพื่อดูว่านี่เป็นพฤติกรรมที่คุณจะได้รับจากรหัสที่ไม่รู้จักหรือไม่

สถานที่อื่น ๆ ที่ฉันเคยเห็นว่าเป็น ... ()วิธีการที่ใช้บ่อยอยู่ในประเภท downcasting เป็นประเภทย่อย เช่นหากคุณมีชุดย่อยที่ระบุคุณอาจท้ายด้วยรหัสเช่น:

  /**
   * Every Node is either an ANode or a BNode.
   */
  interface Node {

    /**
     * Returns this Node as an ANode.
     * 
     * @return this node
     */
    default ANode asANode() {
      if (this instanceof ANode) {
        return (ANode) this;
      }
      else {
        throw new UnsupportedOperationException();
      }
      // Or, in Java8 style, perhaps:
      // return Optional.of(this)
      //     .filter(ANode.class::isInstance)
      //     .map(ANode.class::cast)
      //     .orElseThrow(UnsupportedOperationException::new);
    }

    /**
     * Returns this Node as a BNode.
     * 
     * @return this node
     */
    default BNode asBNode() {
      if (this instanceof BNode) {
        return (BNode) this;
      }
      else {
        throw new UnsupportedOperationException();
      }
    }
  }

ความแตกต่างที่ฉันสังเกตุ (ตอนนี้กำลังคิดถึงมัน) คือ

• โดยทั่วไปแล้วจะแปลงเป็นประเภทการอ้างอิงที่แตกต่างกัน (วัตถุที่ค่อนข้างซับซ้อน)
• ตามปกติแล้วจะส่งคืนประเภทค่าอย่างง่าย

ดังนั้นเราจึงเห็น AsInteger และ AsString และเราเห็น ToArray และ ToStringList

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

วิธีการค้นหาอีกครั้งที่นี่:

• To เป็นการดำเนินการดังนั้นคุณจะใช้มันสำหรับวิธีการ
• ในฐานะที่เป็นตัวแทนง่ายดังนั้นคุณจะใช้มันสำหรับคุณสมบัติ

จากนั้นก็มี "ศิลปะก่อน" (หรือมรดก) เพื่อจัดการกับ ก่อนที่ภาษาจะมี OO อย่างสมบูรณ์ตั้งแต่เริ่มต้นคุณจะมีฟังก์ชั่นห้องสมุดเช่น StrToInt () และ IntToStr () พวกเขาทำการแปลงพวกเขากำลังดำเนินการดังนั้นจึงเหมาะสมที่จะเรียกพวกเขาว่า SomethingToSomethingelse () หลังจากทั้งหมด To มีการใช้งานมากกว่าเป็น ฉันกำลังคิดเกี่ยวกับ Delphi โดยเฉพาะอย่างยิ่งที่นี่

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