Apa perbedaan antara awalan nama metode "ke" dan "sebagai"? [Tutup]

Seperti apa perbedaan antara "to" dan "as" seperti awalan nama metode

• toList (),
• asList (),
• dll ...

Kapan harus menggunakan yang mana ketika merancang suatu metode?

Suatu toXYZ()fungsi diharapkan untuk melakukan konversi, dan untuk mengembalikan objek independen baru (meskipun ketidakmampuan memungkinkan untuk optimasi, java.lang.String.toString()hanya mengembalikan objek).
_{Sebagai contoh, di C ++ kami memiliki std::bitset::to_ulong()yang dapat dengan mudah gagal, dan sebagian besar dari to_string(), semua melakukan konversi kompleks (lebih atau kurang) dan mengalokasikan memori.}

Sebuah asXYZ()fungsi di sisi lain diharapkan untuk mengembalikan (berpotensi berbeda) pandangan sumber, melakukan pekerjaan minimal.
_{Sebagai contoh, di C ++ kita memiliki std::as_const()yang hanya mengembalikan referensi konstan, dan lebih banyak terlibat std::forward_as_tupleyang juga merujuk argumennya dengan referensi.}

Sejujurnya, itu mungkin hanya penamaan yang tidak konsisten. Jika di benda-benda perpustakaan standar di Smalltalk, misalnya, semua metode yang melakukan "kompleks konversi" atau "kembali representasi sederhana dalam jenis lain" yang diawali dengan as, seperti dalam asString, asFloat, asSeconds, dan metode standar untuk mengkonversi apa pun untuk hal lain, as: aClass.

Di Ruby, jenis yang sama dari metode yang diawali dengan to_, seperti dalam to_s, to_a, to_h, singkatan string, arraydan hashmasing-masing.

Tidak ada perpustakaan standar yang membedakan antara jenis konversi yang berbeda, mungkin karena itu harus dianggap sebagai detail implementasi.

Namun, di Jawa kami melihat banyak campuran. Seperti yang Anda sebutkan, ada toString, asListdan sebagainya. Saya percaya ini hanyalah inkonsistensi penamaan, karena jika Anda mencoba mendefinisikan arti yang berbeda untuk setiap awalan, Anda akan selalu menemukan contoh tandingan di tempat lain di pustaka standar.

Jadi dalam hal apa pun, saya akan mengatakan yang penting bagi Anda dan tim Anda untuk memilih satu awalan dan menggunakannya secara konsisten di seluruh kode. Konsistensi adalah kuncinya, sehingga orang tidak dibiarkan bertanya-tanya, seperti yang harus Anda lakukan.

Meskipun sudah ada jawaban yang diterima, tampaknya berfokus pada C ++, sementara pertanyaannya ditandai dengan java . Di Jawa, contoh pertama yang terlintas dalam pikiran untuk hal semacam ini adalah Arrays.asList , yang mengembalikan, pada dasarnya, tampilan array, terbungkus dalam daftar. Array yang mendasari dan daftar masih terhubung; perubahan array dicerminkan dalam daftar, dan sebaliknya. Namun, array yang dikembalikan oleh metode toArray daftar tidak tergantung dari array asli dan dari daftar:

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"
}

Semua yang dikatakan, tidak ada jaminan bahwa setiap pengembang perpustakaan mengikuti konvensi ini, jadi Anda masih perlu memeriksa dokumentasi untuk mengetahui apakah ini perilaku yang akan Anda dapatkan dari kode yang tidak dikenal.

Tempat lain yang saya lihat sebagai ... () metode yang sering digunakan adalah tipe downcasting ke sub-tipe. Misalnya, jika Anda memiliki satu set subtipe, maka Anda mungkin berakhir dengan kode seperti:

  /**
   * 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();
      }
    }
  }

Perbedaan yang saya perhatikan (barusan dengan memikirkannya) adalah

• Untuk biasanya mengkonversi ke tipe referensi yang berbeda (objek yang agak kompleks)
• Seperti biasanya mengembalikan tipe nilai sederhana

Jadi kita melihat AsInteger dan AsString dan kita melihat ToArray dan ToStringList.

Untuk menyiratkan konversi, yang masuk akal (itu adalah gerakan, proses). Seperti menyiratkan representasi, cara mengekspresikan objek asli.

Cara lain untuk melihat ini:

• To adalah operasi, jadi Anda akan menggunakannya untuk metode.
• Seperti representasi sederhana, jadi Anda akan menggunakannya untuk properti.

Dan kemudian ada "prior art" (atau warisan) yang harus dihadapi. Sebelum bahasa sepenuhnya OO dari bawah ke atas, Anda akan memiliki fungsi perpustakaan seperti StrToInt () dan IntToStr (). Mereka melakukan konversi, mereka adalah operasi sehingga masuk akal untuk memanggil mereka SomethingToSomethingelse (). Bagaimanapun, To lebih aktif daripada As. Saya terutama berpikir tentang Delphi di sini.

Ketika C # dirancang dengan ambisi untuk menjalankan OO sepenuhnya, masuk akal untuk memiliki metode pada objek integer sekarang yang akan mengubah integer menjadi string. Meskipun kami juga memiliki kelas Konversi, konversi ke string sangat umum sehingga dibuat metode virtual pada objek. Para desainer mungkin berpikir bahwa ToString akan lebih akrab bagi orang-orang dari paradigma lama dan mungkin ini sebabnya kami mendapat metode virtual ToString () dan bukan properti virtual AsString.