Apakah ide yang buruk untuk mengembalikan tipe data yang berbeda dari satu fungsi dalam bahasa yang diketik secara dinamis?

Bahasa utama saya diketik secara statis (Jawa). Di Jawa, Anda harus mengembalikan satu jenis dari setiap metode. Misalnya, Anda tidak dapat memiliki metode yang mengembalikan secara Stringkondisional atau mengembalikan secara kondisional Integer. Tetapi dalam JavaScript, misalnya, ini sangat mungkin.

Dalam bahasa yang diketik secara statis saya mengerti mengapa ini adalah ide yang buruk. Jika setiap metode dikembalikan Object(orang tua umum semua kelas mewarisi dari) maka Anda dan kompiler tidak tahu apa yang Anda hadapi. Anda harus menemukan semua kesalahan saat dijalankan.

Tetapi dalam bahasa yang diketik secara dinamis, bahkan mungkin tidak ada kompiler. Dalam bahasa yang diketik secara dinamis, tidak jelas bagi saya mengapa fungsi yang mengembalikan beberapa jenis adalah ide yang buruk. Latar belakang saya dalam bahasa statis membuat saya menghindari penulisan fungsi-fungsi seperti itu, tetapi saya khawatir saya terlalu dekat dengan fitur yang bisa membuat kode saya lebih bersih dengan cara yang tidak bisa saya lihat.

Sunting : Saya akan menghapus contoh saya (sampai saya bisa memikirkan yang lebih baik). Saya pikir itu mengarahkan orang untuk menjawab suatu hal yang tidak saya coba sampaikan.

Berbeda dengan jawaban lain, ada kasus di mana mengembalikan berbagai jenis dapat diterima.

Contoh 1

sum(2, 3) → int
sum(2.1, 3.7) → float

Dalam beberapa bahasa yang diketik secara statis, ini melibatkan kelebihan beban, jadi kami dapat mempertimbangkan bahwa ada beberapa metode, masing-masing mengembalikan jenis yang telah ditentukan sebelumnya, jenis tetap. Dalam bahasa dinamis, ini mungkin fungsi yang sama, diimplementasikan sebagai:

var sum = function (a, b) {
    return a + b;
};

Fungsi yang sama, berbagai jenis nilai pengembalian.

Contoh 2

Bayangkan Anda mendapat respons dari komponen OpenID / OAuth. Beberapa penyedia OpenID / OAuth mungkin berisi lebih banyak informasi, seperti usia orang tersebut.

var user = authProvider.findCurrent();
// user is now:
// {
//     provider: 'Facebook',
//     name: {
//         firstName: 'Hello',
//         secondName: 'World',
//     },
//     email: '[email protected]',
//     age: 27
// }

Orang lain akan memiliki minimum, apakah itu alamat email atau nama samaran.

var user = authProvider.findCurrent();
// user is now:
// {
//     provider: 'Google',
//     email: '[email protected]'
// }

Sekali lagi, fungsi yang sama, hasil yang berbeda.

Di sini, manfaat mengembalikan jenis yang berbeda sangat penting dalam konteks di mana Anda tidak peduli dengan jenis dan antarmuka, tetapi benda apa yang sebenarnya berisi. Misalnya, mari kita bayangkan sebuah situs web berisi bahasa dewasa. Maka findCurrent()dapat digunakan seperti ini:

var user = authProvider.findCurrent();
if (user.age || 0 >= 16) {
    // The person can stand mature language.
    allowShowingContent();
} else if (user.age) {
    // OpenID/OAuth gave the age, but the person appears too young to see the content.
    showParentalAdvisoryRequestedMessage();
} else {
    // OpenID/OAuth won't tell the age of the person. Ask the user himself.
    askForAge();
}

Refactoring ini ke dalam kode di mana setiap penyedia akan memiliki fungsinya sendiri yang akan mengembalikan tipe yang terdefinisi dengan baik dan tidak hanya akan menurunkan basis kode dan menyebabkan duplikasi kode, tetapi juga tidak akan membawa manfaat apa pun. Seseorang mungkin akhirnya melakukan kengerian seperti:

var age;
if (['Facebook', 'Yahoo', 'Blogger', 'LiveJournal'].contains(user.provider)) {
    age = user.age;
}

Secara umum, ini adalah ide yang buruk karena alasan yang sama dengan persamaan moral dalam bahasa yang diketik secara statis adalah ide yang buruk: Anda tidak tahu tipe konkret dikembalikan, jadi Anda tidak tahu apa yang dapat Anda lakukan dengan hasilnya (selain dari beberapa hal yang dapat dilakukan dengan nilai apa pun). Dalam sistem tipe statis, Anda memiliki anotasi yang diperiksa kompiler untuk jenis kembali dan semacamnya, tetapi dalam bahasa dinamis pengetahuan yang sama masih ada - itu hanya informal dan disimpan dalam otak dan dokumentasi daripada dalam kode sumber.

Dalam banyak kasus, bagaimanapun, ada sajak dan alasan yang jenis dikembalikan dan efeknya mirip dengan kelebihan beban atau polimorfisme parametrik dalam sistem tipe statis. Dengan kata lain, jenis hasil yang diprediksi, itu hanya tidak cukup sederhana untuk mengekspresikan.

Tetapi perhatikan bahwa mungkin ada alasan lain mengapa fungsi tertentu dirancang dengan buruk: Misalnya, sumfungsi mengembalikan false pada input yang tidak valid adalah ide yang buruk terutama karena nilai pengembalian tidak berguna dan rentan kesalahan (0 <-> kebingungan salah).

Dalam bahasa dinamis, Anda tidak boleh bertanya apakah mengembalikan tipe berbeda tetapi objek dengan API berbeda . Karena sebagian besar bahasa dinamis tidak terlalu peduli tentang jenis, tetapi gunakan berbagai versi pengetikan bebek .

Ketika kembali berbagai jenis masuk akal

Misalnya metode ini masuk akal:

def load_file(file): 
    if something: 
       return ['a ', 'list', 'of', 'strings'] 
    return open(file, 'r')

Karena kedua file, dan daftar string adalah (dengan Python) iterables yang mengembalikan string. Tipe yang sangat berbeda, API yang sama (kecuali seseorang mencoba memanggil metode file pada daftar, tetapi ini adalah cerita yang berbeda).

Anda dapat kembali secara kondisional listatau tuple( tupleadalah daftar yang tidak dapat diubah dengan python).

Bahkan secara formal melakukan:

def do_something():
    if ...: 
        return None
    return something_else

atau:

function do_something(){
   if (...) return null; 
   return sth;
}

mengembalikan tipe yang berbeda, karena kedua python Nonedan Javascript nulladalah tipe di kanan mereka sendiri.

Semua kasus penggunaan ini akan memiliki rekan mereka dalam bahasa statis, fungsinya hanya akan mengembalikan antarmuka yang tepat.

Ketika mengembalikan objek dengan API yang berbeda secara kondisional adalah ide yang bagus

Mengenai apakah mengembalikan API yang berbeda adalah ide yang baik, IMO dalam banyak kasus itu tidak masuk akal. Hanya contoh masuk akal yang muncul di pikiran adalah sesuatu yang dekat dengan apa yang dikatakan @MainMa : ketika API Anda dapat memberikan jumlah detail yang bervariasi, mungkin masuk akal untuk mengembalikan lebih detail ketika tersedia.

Pertanyaan Anda membuat saya ingin sedikit menangis. Bukan untuk penggunaan contoh yang Anda berikan, tetapi karena seseorang tanpa disadari akan mengambil pendekatan ini terlalu jauh. Ini adalah langkah singkat dari kode yang sangat sulit dipelihara.

Kondisi kesalahan menggunakan jenis kasus masuk akal, dan pola nol (semuanya harus menjadi pola) dalam bahasa yang diketik secara statis melakukan hal yang sama. Panggilan fungsi Anda mengembalikan objectatau mengembalikannya null.

Tapi itu langkah singkat untuk mengatakan "Aku akan menggunakan ini untuk membuat pola pabrik " dan kembali baik fooatau baratau baztergantung suasana hati fungsi ini. Debugging ini akan menjadi mimpi buruk ketika penelepon mengharapkan footetapi diberikan bar.

Jadi saya tidak berpikir Anda sedang berpikiran tertutup. Anda berhati-hati dalam menggunakan fitur bahasa.

Pengungkapan: latar belakang saya dalam bahasa yang diketik secara statis, dan saya umumnya bekerja pada tim yang lebih besar dan beragam di mana kebutuhan akan kode yang dapat dipelihara cukup tinggi. Jadi perspektif saya mungkin miring juga.

Menggunakan Generics in Java memungkinkan Anda mengembalikan tipe yang berbeda, namun tetap mempertahankan keamanan tipe statis. Anda cukup menentukan tipe yang ingin Anda kembalikan dalam parameter tipe generik dari panggilan fungsi.

Apakah Anda bisa menggunakan pendekatan serupa di Javascript, tentu saja, merupakan pertanyaan terbuka. Karena Javascript adalah bahasa yang diketik secara dinamis, mengembalikan sebuah objectsepertinya pilihan yang jelas.

Jika Anda ingin tahu di mana skenario pengembalian dinamis dapat berfungsi saat Anda terbiasa bekerja dalam bahasa yang diketik secara statis, pertimbangkan untuk melihat dynamickata kunci dalam C #. Rob Conery berhasil menulis Object-Relational Mapper dalam 400 baris kode menggunakan dynamickata kunci.

Tentu saja, semua dynamicsebenarnya adalah membungkus objectvariabel dengan beberapa jenis keamanan runtime.

Itu ide yang buruk, saya pikir, untuk mengembalikan tipe yang berbeda secara kondisional. Salah satu cara ini sering muncul bagi saya adalah jika fungsinya dapat mengembalikan satu atau lebih nilai. Jika hanya satu nilai yang perlu dikembalikan, mungkin masuk akal untuk mengembalikan nilai, daripada mengemasnya dalam Array, untuk menghindari keharusan membongkar dalam fungsi panggilan. Namun, ini (dan sebagian besar contoh lain dari ini) menempatkan kewajiban pada penelepon untuk membedakan antara dan menangani kedua jenis. Fungsi akan lebih mudah untuk dipikirkan jika selalu mengembalikan jenis yang sama.

"Praktek buruk" ada terlepas dari apakah bahasa Anda diketik secara statis. Bahasa statis lebih banyak menjauhkan Anda dari praktik-praktik ini, dan Anda mungkin menemukan lebih banyak pengguna yang mengeluh tentang "praktik buruk" dalam bahasa statis karena itu adalah bahasa yang lebih formal. Namun, masalah yang mendasarinya ada dalam bahasa yang dinamis, dan Anda dapat menentukan apakah mereka dibenarkan.

Inilah bagian yang tidak menyenangkan dari apa yang Anda usulkan. Jika saya tidak tahu jenis apa yang dikembalikan, maka saya tidak dapat langsung menggunakan nilai kembali. Saya harus "menemukan" sesuatu tentang itu.

total = sum_of_array([20, 30, 'q', 50])
if (type_of(total) == Boolean) {
  display_error(...)
} else {
  record_number(total)
}

Seringkali jenis pengalihan kode ini merupakan praktik yang buruk. Itu membuat kode lebih sulit dibaca. Dalam contoh ini, Anda melihat mengapa melempar dan menangkap kasus pengecualian sangat populer. Dengan kata lain: jika fungsi Anda tidak dapat melakukan apa yang dikatakannya, itu tidak seharusnya kembali dengan sukses . Jika saya memanggil fungsi Anda, saya ingin melakukan ini:

total = sum_of_array([20, 30, 'q', 50])
display_number(total)

Karena baris pertama kembali dengan sukses, saya berasumsi bahwa totalsebenarnya berisi jumlah array. Jika tidak berhasil kembali, kami beralih ke halaman lain dari program saya.

Mari kita gunakan contoh lain yang bukan hanya tentang menyebarkan kesalahan. Mungkin sum_of_array mencoba menjadi pintar dan mengembalikan string yang dapat dibaca manusia dalam beberapa kasus, seperti "Itu kombinasi loker saya!" jika dan hanya jika arraynya adalah [11,7,19]. Saya mengalami kesulitan memikirkan contoh yang baik. Bagaimanapun, masalah yang sama berlaku. Anda harus memeriksa nilai pengembalian sebelum Anda dapat melakukan apa pun dengan itu:

total = sum_of_array([20, 30, 40, 50])
if (type_of(total) == String) {
  write_message(total)
} else {
  record_number(total)
}

Anda mungkin berpendapat bahwa akan berguna untuk fungsi mengembalikan integer atau float, misalnya:

sum_of_array(20, 30, 40) -> int
sum_of_array(23.45, 45.67, 67.789044) -> float

Tetapi hasil itu bukan tipe yang berbeda, sejauh yang Anda ketahui. Anda akan memperlakukan mereka berdua sebagai angka, dan hanya itu yang Anda pedulikan. Jadi sum_of_array mengembalikan tipe angka. Inilah yang dimaksud dengan polimorfisme.

Jadi ada beberapa praktik yang mungkin Anda langgar jika fungsi Anda dapat mengembalikan beberapa tipe. Mengetahui mereka akan membantu Anda menentukan apakah fungsi khusus Anda akan mengembalikan beberapa jenis.

Sebenarnya, tidak jarang sama sekali untuk mengembalikan tipe yang berbeda bahkan dalam bahasa yang diketik secara statis. Itu sebabnya kami memiliki jenis serikat pekerja, misalnya.

Bahkan, metode di Jawa hampir selalu mengembalikan satu dari empat jenis: beberapa jenis objek atau nullpengecualian atau mereka tidak pernah kembali sama sekali.

Dalam banyak bahasa, kondisi kesalahan dimodelkan sebagai subrutin yang mengembalikan tipe hasil atau tipe kesalahan. Misalnya, dalam Scala:

def transferMoney(amount: Decimal): Either[String, Decimal]

Ini adalah contoh yang bodoh, tentu saja. Jenis kembali berarti "mengembalikan string atau desimal". Secara konvensi, tipe kiri adalah tipe kesalahan (dalam hal ini, string dengan pesan kesalahan) dan jenis yang tepat adalah jenis hasil.

Ini mirip dengan pengecualian, kecuali kenyataan bahwa pengecualian juga merupakan konstruk aliran kontrol. Mereka, pada kenyataannya, setara dalam kekuatan ekspresif GOTO.

Belum ada jawaban yang menyebutkan prinsip SOLID. Secara khusus, Anda harus mengikuti prinsip substitusi Liskov, bahwa setiap kelas yang menerima tipe selain tipe yang diharapkan masih dapat bekerja dengan apa pun yang mereka dapatkan, tanpa melakukan apa pun untuk menguji jenis apa yang dikembalikan.

Jadi, jika Anda melempar beberapa properti tambahan ke objek, atau membungkus fungsi yang dikembalikan dengan semacam dekorator yang masih memenuhi apa yang ingin dicapai fungsi asli, Anda baik, selama tidak ada kode yang memanggil fungsi Anda pernah bergantung pada ini perilaku, di jalur kode apa pun.

Alih-alih mengembalikan string atau integer, contoh yang lebih baik mungkin mengembalikan sistem sprinkler atau kucing. Ini bagus jika semua kode panggilan yang akan dilakukan adalah memanggil functionInQuestion.hiss (). Secara efektif Anda memiliki antarmuka tersirat yang diharapkan oleh kode panggilan, dan bahasa yang diketik secara dinamis tidak akan memaksa Anda untuk membuat antarmuka menjadi eksplisit.

Sedihnya, rekan kerja Anda mungkin akan melakukannya, jadi Anda mungkin harus melakukan pekerjaan yang sama dalam dokumentasi Anda, kecuali tidak ada cara yang dapat diterima secara universal, singkat, dan dapat dianalisis dengan mesin untuk melakukannya - seperti saat Anda mendefinisikan antarmuka dalam bahasa yang memilikinya.

Satu tempat di mana saya melihat diri saya mengirim berbagai jenis adalah untuk input yang tidak valid atau "pengecualian orang miskin" di mana kondisi "luar biasa" tidak terlalu luar biasa. Sebagai contoh, dari repositori fungsi-fungsi utilitas PHP contoh singkat ini:

function ensure_fields($consideration)
{
        $args = func_get_args();
        foreach ( $args as $a ) {
                if ( !is_string($a) ) {
                        return NULL;
                }
                if ( !isset($consideration[$a]) || $consideration[$a]=='' ) {
                        return FALSE;
                }
        }

        return TRUE;
}

Fungsi secara nominal mengembalikan BOOLEAN, namun mengembalikan NULL pada input yang tidak valid. Perhatikan bahwa sejak PHP 5.3, semua fungsi PHP internal juga berperilaku seperti ini . Selain itu, beberapa fungsi PHP internal mengembalikan FALSE atau INT pada input nominal, lihat:

strpos('Hello', 'e');  // Returns INT(1)
strpos('Hello', 'q');  // Returns BOOL(FALSE)

Saya rasa ini bukan ide yang buruk! Berbeda dengan pendapat yang paling umum ini, dan seperti yang telah ditunjukkan oleh Robert Harvey, bahasa yang diketik secara statis seperti Java memperkenalkan Generics persis untuk situasi seperti yang Anda tanyakan. Sebenarnya Java mencoba untuk menjaga (sedapat mungkin) keamanan ketik pada waktu kompilasi, dan terkadang Generics menghindari duplikasi kode, mengapa? Karena Anda dapat menulis metode yang sama atau kelas yang sama yang menangani / mengembalikan tipe yang berbeda . Saya akan membuat contoh yang sangat singkat untuk menunjukkan ide ini:

Jawa 1.4

public static Boolean getBoolean(String property){
    return (Boolean) properties.getProperty(property);
}
public static Integer getInt(String property){
    return (Integer) properties.getProperty(property);
}

Java 1.5+

public static <T> getValue(String property, Class<T> clazz) throws WhateverCheckedException{
    return clazz.getConstructor(String.class).newInstance(properties.getProperty(property));
}
//the call will be
Boolean b = getValue("useProxy",Boolean.class);
Integer b = getValue("proxyPort",Integer.class);

Dalam bahasa yang diketik dinamis, karena Anda tidak memiliki ketelitian pada waktu kompilasi, Anda benar-benar bebas untuk menulis kode yang sama yang bekerja untuk banyak jenis. Karena bahkan dalam bahasa yang diketik secara statis, Generik diperkenalkan untuk menyelesaikan masalah ini, jelas merupakan petunjuk bahwa menulis fungsi yang mengembalikan berbagai jenis dalam bahasa dinamis bukanlah ide yang buruk.

Mengembangkan perangkat lunak pada dasarnya adalah seni dan keterampilan mengelola kompleksitas. Anda mencoba mempersempit sistem pada titik yang Anda mampu, dan membatasi opsi di titik lain. Antarmuka fungsi adalah kontrak yang membantu mengelola kompleksitas kode dengan membatasi pengetahuan yang diperlukan untuk bekerja dengan bagian kode apa pun. Dengan mengembalikan jenis yang berbeda, Anda secara signifikan memperluas antarmuka fungsi dengan menambahkan semua antarmuka dari jenis yang berbeda yang Anda kembalikan DAN menambahkan aturan yang tidak jelas tentang antarmuka yang dikembalikan.

Perl banyak menggunakan ini karena apa fungsi tidak tergantung pada konteksnya . Misalnya, suatu fungsi dapat mengembalikan array jika digunakan dalam konteks daftar, atau panjang array jika digunakan di tempat di mana nilai skalar diharapkan. Dari tutorial itu adalah hit pertama untuk "konteks perl" , jika Anda melakukannya:

my @now = localtime();

Kemudian @now adalah variabel array (itulah arti dari @), dan akan berisi array seperti (40, 51, 20, 9, 0, 109, 5, 8, 0).

Jika sebaliknya, Anda memanggil fungsi dengan cara di mana hasilnya harus berupa skalar, dengan ($ variabel skalar):

my $now = localtime();

maka ia melakukan sesuatu yang sama sekali berbeda: $ sekarang akan menjadi sesuatu seperti "Jumat 9 Januari 20:51:40 2009".

Contoh lain yang dapat saya pikirkan adalah dalam mengimplementasikan REST API, di mana format apa yang dikembalikan tergantung pada apa yang diinginkan klien. Misalnya, HTML, atau JSON, atau XML. Meskipun secara teknis itu semua aliran byte, idenya serupa.

Di tanah yang dinamis itu semua tentang mengetik bebek. Hal yang paling bertanggung jawab untuk diekspos / menghadap publik adalah untuk membungkus tipe yang berpotensi berbeda dalam pembungkus yang memberi mereka antarmuka yang sama.

function ThingyWrapper(thingy){ //a function constructor (class-like thingy)

    //thingy is effectively private and persistent for ThingyWrapper instances

    if(typeof thingy === 'array'){
        this.alertItems = function(){
            thingy.forEach(function(el){ alert(el); });
        }
    }
    else {
        this.alertItems = function(){
            for(var x in thingy){ alert(thingy[x]); }
        }
    }
}

function gimmeThingy(){
    var
        coinToss = Math.round( Math.random() ),//gives me 0 or 1
        arrayThingy = [1,2,3],
        objectThingy = { item1:1, item2:2, item3:3 }
    ;

    //0 dynamically evaluates to false in JS
    return new ThingyWrapper( coinToss ? arrayThingy : objectThingy );
}

gimmeThingy().alertItems(); //should be same every time except order of numbers - maybe

Kadang-kadang mungkin masuk akal untuk menghapus berbagai jenis sama sekali tanpa pembungkus generik tetapi jujur ​​dalam 7 tahun tahun menulis JS, itu bukan sesuatu yang saya temukan itu masuk akal atau nyaman untuk dilakukan sangat sering. Sebagian besar itu adalah sesuatu yang akan saya lakukan dalam konteks lingkungan tertutup seperti interior objek di mana segala sesuatunya disatukan. Tapi itu bukan sesuatu yang sudah saya lakukan cukup sering sehingga setiap contoh terlintas dalam pikiran.

Sebagian besar, saya akan menyarankan Anda berhenti memikirkan jenis sama sekali. Anda berurusan dengan tipe saat Anda membutuhkannya dalam bahasa yang dinamis. Tidak lagi. Itu intinya. Jangan periksa jenis setiap argumen tunggal. Itu adalah sesuatu yang saya hanya akan tergoda untuk melakukannya di lingkungan di mana metode yang sama dapat memberikan hasil yang tidak konsisten dengan cara yang tidak jelas (jadi pasti tidak melakukan hal seperti itu). Tapi itu bukan tipe yang penting, tapi bagaimana pun yang kau berikan padaku, bekerja.