Saya ingin menambahkan jawaban untuk pertanyaan ini karena saya telah berjalan dengan susah payah melalui beberapa Jawa baik, buruk tapi sebagian besar jelek akhir-akhir ini dan saya memiliki banyak generalisasi over-gross total tentang Java dan dev Java vs JS dan JS devs yang mungkin sebenarnya didasarkan pada sesuatu yang samar-samar menyerupai kebenaran yang bermanfaat.
Ada IDE Tetapi Dapat Membantu untuk Memahami Mengapa Belum Ada Banyak
Saya sudah mencoba Webstorm sekarang karena saya merasa tertarik pada pengembangan Node dan itu tidak cukup buruk sehingga saya benar-benar membelinya tetapi saya masih cenderung membuka file js di Scite lebih sering daripada WS. Alasan untuk ini adalah bahwa Anda dapat melakukan lebih banyak dengan lebih sedikit di JS tetapi juga karena UI bekerja memberikan umpan balik langsung, alat pengembang browser (khususnya Chrome dan Firebug) sebenarnya cukup bagus, dan (memperhitungkan konteks non-browser ) menjalankan kembali kode yang diubah dengan cepat dan mudah tanpa langkah kompilasi.
Hal lain yang saya cukup yakin adalah bahwa IDE pada dasarnya menciptakan permintaan mereka sendiri dengan mengaktifkan kode ceroboh yang Anda benar-benar tidak mampu dalam JavaScript. Ingin mempelajari cara kami mengelola JS? Mungkin membantu untuk memulai dengan mencoba menulis sesuatu yang non-sepele di Jawa tanpa IDE dan memperhatikan hal-hal yang harus Anda mulai lakukan dan pikirkan untuk benar-benar dapat mempertahankan / memodifikasi kode itu tanpa IDE bergerak meneruskan. IMO, hal-hal yang sama masih penting untuk menulis kode yang dapat dipelihara apakah Anda memiliki IDE atau tidak. Jika saya harus menulis kurikulum pemrograman 4 tahun, itu tidak akan membiarkan Anda menyentuh IDE selama dua tahun pertama dengan tujuan tidak mendapatkan alat dan ketergantungan memutar.
Struktur
Pengembang JS berpengalaman yang berurusan dengan aplikasi kompleks dapat dan membuat struktur kodenya. Sebenarnya itu adalah satu hal yang kita cenderung harus lebih baik dengan sejarah awal yang tidak memiliki IDE untuk membaca kode untuk kita tetapi juga karena bahasa yang sangat ekspresif dapat dengan kuat mengekspresikan basis data bencana yang benar-benar tidak dapat dipelihara dengan sangat cepat jika Anda tidak membuat kode dengan bijaksana.
Saya benar-benar memiliki kurva belajar yang cukup curam dalam memahami basis kode Java kami baru-baru ini sampai saya akhirnya menyadari bahwa tidak ada yang benar OOP. Kelas tidak lebih dari kumpulan metode terkait longgar mengubah data yang tersedia secara global duduk di dalam kacang atau DTO atau getter statis / setter. Pada dasarnya itu adalah binatang tua yang sama yang seharusnya diganti OOP. Jadi saya berhenti mencari dan memikirkan kode pada dasarnya. Saya baru saja belajar tombol pintas dan menelusuri kekacauan dan semuanya berjalan lebih lancar. Jadi, jika Anda sudah tidak terbiasa dengan kebiasaan itu, pikirkan lebih keras tentang OOD.
Aplikasi JS yang terstruktur dengan baik di tingkat tertinggi akan cenderung terdiri dari fungsi kompleks (misalnya jQuery) dan objek yang berinteraksi satu sama lain. Saya berpendapat bahwa tanda aplikasi yang terstruktur dengan baik dan mudah dirawat dalam bahasa apa pun adalah bahwa aplikasi tersebut dapat terbaca dengan sempurna apakah Anda melihatnya dengan IDE atau Notepad ++. Itu salah satu alasan utama saya sangat kritis terhadap injeksi ketergantungan dan tes TDD pertama yang diambil secara ekstrem.
Dan akhirnya, lepaskan kelas. Pelajari warisan prototypal. Ini sebenarnya cukup elegan mudah diimplementasikan ketika Anda benar-benar membutuhkan warisan. Saya menemukan pendekatan pengomposisikan cenderung bekerja lebih baik di JS, dan saya pribadi mulai sakit dan mengalami teror malam EXTJS setiap kali saya melihat lebih dari satu atau dua tingkat warisan terjadi dalam bahasa apa pun.
Prinsip Inti Pertama
Saya sedang berbicara tentang hal-hal inti yang harus diperoleh dari semua praktik baik lainnya: KERING, YAGNI, prinsip yang paling tidak mengejutkan, pemisahan yang bersih dari domain bermasalah, menulis ke antarmuka, dan menulis kode yang dapat dibaca manusia adalah inti pribadi saya. Apa pun yang sedikit lebih rumit yang menganjurkan ditinggalkannya praktik-praktik tersebut harus dianggap sebagai Kool Aid dalam bahasa apa pun, tetapi terutama bahasa seperti JavaScript di mana sangat mudah untuk meninggalkan warisan kode yang sangat membingungkan untuk orang berikutnya. Kopling longgar, misalnya, adalah hal-hal hebat sampai Anda mengambilnya sejauh itu sehingga Anda bahkan tidak tahu di mana interaksi antara objek terjadi.
Jangan Takut Mengetik Dinamis
Tidak ada banyak tipe inti dalam JavaScript. Untuk sebagian besar, aturan casting dinamis adalah praktis dan lurus ke depan tetapi membayar untuk mempelajarinya sehingga Anda dapat lebih baik belajar mengelola aliran data tanpa gips yang tidak perlu dan rutinitas validasi pointless. Percayalah kepadaku. Tipe ketat bagus untuk kinerja dan menemukan masalah pada kompilasi tetapi mereka tidak melindungi Anda dari apa pun.
Pelajari Omong kosong dari Fungsi dan Penutupan JS
Fungsi kelas satu JS bisa dibilang alasan utama JS memenangkan "Hanya Bahasa yang Layak Menyentuh Web Sisi Klien Dengan Penghargaan." Dan ya, sebenarnya ada persaingan. Mereka juga merupakan fitur utama JS. Kami membangun objek dengan mereka. Semuanya mencakup fungsi. Dan mereka memiliki fitur yang berguna. Kami dapat memeriksa params melalui kata kunci argumen. Kita dapat melampirkan dan memadamkannya untuk sementara waktu dalam konteks menjadi metode objek lain. Dan mereka membuat pendekatan berbasis peristiwa untuk hal-hal yang sangat mudah diimplementasikan. Singkatnya, mereka menjadikan JS binatang buas mutlak dalam mengurangi kompleksitas dan mengadaptasi berbagai implementasi JS itu sendiri (tetapi kebanyakan DOM API) tepat di sumbernya.
Evaluasi Kembali Pola / Praktek Sebelum Mengadopsi
Fungsi kelas satu dan tipe dinamis membuat banyak pola desain yang lebih kompleks benar-benar tidak berguna dan rumit di JS. Namun, beberapa pola yang lebih sederhana sangat berguna dan mudah diterapkan mengingat sifat JS yang sangat fleksibel. Adaptor dan dekorator sangat berguna dan saya telah menemukan lajang membantu untuk pabrik widget ui kompleks yang juga bertindak sebagai manajer acara untuk elemen ui yang mereka bangun.
Ikuti Pimpinan Bahasa dan Lakukan Lebih Banyak Dengan Lebih Sedikit
Saya percaya salah satu honchos kepala Java membuat argumen di suatu tempat bahwa verbositas sebenarnya adalah fitur positif yang membuat kode lebih mudah dipahami untuk semua pihak. Omong kosong. Jika itu benar, legalese akan lebih mudah dibaca. Hanya penulis yang dapat membuat apa yang mereka tulis lebih mudah dimengerti dan Anda hanya bisa melakukannya dengan menempatkan diri Anda pada posisi orang lain sesekali. Jadi merangkul kedua aturan ini. 1. Jadilah sejelas dan sejelas mungkin. 2. Dapatkan ke titik sialan sudah. Kemenangannya adalah kode yang bersih dan ringkas itu adalah urutan besarnya yang lebih mudah dipahami dan dipelihara daripada sesuatu di mana Anda harus melintasi dua puluh lima lapisan untuk mendapatkan dari pelatuk ke tindakan yang diinginkan sebenarnya. Kebanyakan pola yang mendukung hal semacam itu dalam bahasa yang lebih ketat sebenarnya merupakan solusi untuk keterbatasan yang tidak dimiliki JavaScript.
Semuanya ditempa dan tidak apa-apa
JS mungkin adalah salah satu bahasa yang paling tidak proteksionis dalam penggunaan populer. Pegang itu. Ini bekerja dengan baik. Sebagai contoh, Anda dapat menulis objek dengan vars "pribadi" persisten yang tidak dapat diakses hanya dengan mendeklarasikan vars reguler dalam fungsi konstruktor dan saya sering melakukannya. Tapi itu bukan untuk melindungi kode saya atau pengguna "dari diri mereka sendiri" (mereka bisa menggantinya dengan versi mereka sendiri selama waktu berjalan). Melainkan itu untuk menunjukkan niat karena asumsinya adalah bahwa lelaki lain cukup kompeten untuk tidak mau memecah-mecah ketergantungan dan akan melihat bahwa Anda tidak dimaksudkan untuk mendapatkannya secara langsung mungkin karena alasan yang baik.
Tidak Ada Batas Ukuran, Hanya Masalah Domain
Masalah terbesar yang saya miliki dengan semua basis kode Java yang pernah saya lihat adalah terlalu banyaknya file kelas. Pertama-tama SOLID hanyalah pengulangan membingungkan dari apa yang harus Anda ketahui tentang OOP. Kelas harus menangani serangkaian masalah terkait yang spesifik. Tidak ada masalah dengan satu metode. Itu hanya mengambil kode Ch-func-spaghetti tua rantai buruk hanya dengan penambahan semua sintaks kelas gunanya untuk boot. Tidak ada batasan ukuran atau metode. Jika masuk akal untuk menambahkan sesuatu ke fungsi atau kelas atau konstruktor yang sudah lama, masuk akal. Ambil jQuery. Ini seluruh toolset panjang perpustakaan dalam satu fungsi dan tidak ada yang salah dengan itu. Apakah kita masih membutuhkan jQuery hingga debat yang masuk akal tetapi dalam hal desain,
Jika Java adalah Semua yang Anda Ketahui, Bereksperimenlah dalam Sesuatu Dengan Sintaks Non-C Berbasis
Ketika saya mulai mengacaukan Python karena saya menyukai apa yang saya dengar tentang Django, saya belajar untuk mulai memisahkan sintaksis dari desain bahasa. Akibatnya, menjadi lebih mudah untuk memahami Java dan C sebagai jumlah bagian desain bahasa mereka daripada jumlah hal yang mereka lakukan secara berbeda dengan sintaksis yang sama. Efek samping yang bagus adalah bahwa semakin Anda memahami bahasa lain dalam hal desain, semakin baik Anda memahami kekuatan / kelemahan bahasa yang paling Anda kenal melalui kontras.
Kesimpulan
Sekarang, mempertimbangkan semua itu, mari kita tekan semua poin masalah Anda:
- Tidak ada cara segera untuk menemukan titik masuk fungsi (selain pencarian teks biasa, yang kemudian dapat menghasilkan pencarian selanjutnya untuk metode lebih lanjut hierarki panggilan, setelah dua atau tiga di antaranya Anda lupa di mana Anda mulai)
Chrome dan Firebug benar-benar memiliki penelusuran jejak. Tetapi lihat juga poin saya tentang struktur dan menjaga segala sesuatunya singkat dan langsung. Semakin Anda dapat menganggap aplikasi Anda sebagai konstruk yang lebih besar yang dienkapsulasi dengan baik berinteraksi satu sama lain, semakin mudah untuk mencari kesalahan siapa itu ketika terjadi kesalahan. Saya akan mengatakan ini juga berlaku untuk Jawa. Kami memiliki konstruktor fungsi seperti kelas yang dapat diservis dengan sempurna untuk masalah OOP tradisional.
function ObjectConstructor(){
//No need for an init method.
//Just pass in params and do stuff inside for instantiation behavior
var privateAndPersistent = true;
//I like to take advantage of function hoisting for a nice concise interface listing
this.publicAndPointlessEncapsulationMurderingGetterSetter
= publicAndPointlessEncapsulationMurderingGetterSetter;
//Seriously though Java/C# folks, stop with the pointless getter/setters already
function publicAndPointlessEncapsulationMurderingGetterSetter(arg){
if(arg === undefined){
return privateAndPersistent;
}
privateAndPersistent = arg;
}
}
ObjectConstructor.staticLikeNonInstanceProperty = true;
var instance = new ObjectConstructor();//Convention is to capitalize constructors
Dalam kode saya, saya hampir tidak pernah menggunakan objek literal {}sebagai komponen aplikasi struktural karena mereka tidak dapat memiliki vars (pribadi) internal dan lebih suka memesannya untuk digunakan sebagai struktur data. Itu membantu menetapkan harapan yang menjaga kejelasan niat. (jika Anda melihat ikal, itu data, bukan komponen arsitektur aplikasi).
- Parameter diteruskan ke fungsi, tanpa mengetahui sifat dan fungsi apa yang tersedia pada parameter itu (selain benar-benar menjalankan program, menavigasi ke titik di mana fungsi dipanggil, dan menggunakan console.logs untuk menampilkan semua properti tersedia)
Sekali lagi, lihat alat peramban modern. Tetapi juga, mengapa sangat mengecewakan untuk menjalankan program lagi? Muat ulang adalah sesuatu yang biasanya dikenali oleh web dev sisi klien setiap beberapa menit karena tidak ada biaya sama sekali untuk melakukannya. Ini lagi, titik lain di mana struktur aplikasi dapat membantu, tetapi itu adalah salah satu sisi negatif dari JS yang harus Anda jalankan validasi Anda sendiri ketika menegakkan kontrak sangat penting (sesuatu yang hanya saya lakukan pada titik akhir yang terpapar pada hal-hal lain yang basis kode saya tidak lakukan. dapat mengontrol). IMO, pengorbanan ini sangat bermanfaat.
- Penggunaan umum dari fungsi anonim sebagai panggilan balik, yang sering mengarah ke spaghetti jalur kode yang membingungkan, yang tidak dapat Anda navigasikan dengan cepat.
Ya itu buruk pada hal-hal yang tidak sepele. Jangan lakukan itu. Beri nama anak-anak fungsi Anda. Lebih mudah untuk melacak hal-hal juga. Anda dapat mendefinisikan, mengevaluasi (diharuskan untuk menetapkan), dan menetapkan fungsi sepele yang sederhana sesuai dengan:
doSomethingWithCallback( (function callBack(){}) );
Sekarang Chrome akan memiliki nama untuk Anda ketika Anda menelusuri panggilan. Untuk fungsi non-sepele saya akan mendefinisikannya di luar panggilan. Perhatikan juga bahwa fungsi anonoymous yang ditugaskan ke variabel masih anonim.
- Dan tentu saja, JSLint menangkap beberapa kesalahan sebelum runtime, tetapi bahkan itu tidak berguna seperti memiliki garis bergelombang merah di bawah kode Anda langsung di browser.
Saya tidak pernah menyentuh barang-barang itu. Crockford memberikan beberapa hal baik kepada komunitas tetapi JSLint melewati batas menjadi preferensi gaya dan menyarankan elemen-elemen tertentu dari JavaScript adalah bagian yang buruk tanpa alasan yang jelas, IMO. Abaikan saja satu hal tentang regEx dan kelas negasi yang diikuti oleh * atau +. Wildcard memiliki kinerja yang lebih buruk dan Anda dapat dengan mudah membatasi pengulangan dengan {}. Juga, abaikan semua yang dia katakan tentang fungsi konstruktor. Anda dapat dengan mudah membungkusnya dalam func pabrik jika kata kunci baru mengganggu Anda. CSSLint (bukan Crockford) bahkan lebih buruk di bagian depan saran buruk. Selalu bawa orang yang melakukan banyak pembicaraan dengan sebutir garam. Terkadang saya bersumpah mereka hanya ingin membangun otoritas atau menghasilkan materi baru.
Dan lagi, Anda harus melupakan apa yang telah Anda pelajari dengan masalah run-time yang Anda miliki. (itu yang umum saya lihat dengan banyak Java / C # devs) Jika melihat kesalahan dalam run-time masih mengganggu Anda 2 tahun kemudian, saya ingin Anda duduk dan mengisi ulang spam di browser sampai tenggelam. Ada tidak ada pembagian waktu kompilasi / run-waktu (yah bukan yang terlihat - JS dijalankan pada JIT sekarang). Tidak hanya menemukan bug saat run-time, tetapi juga sangat bermanfaat untuk memuat ulang spam yang murah dan mudah dan menemukan bug di setiap titik pemberhentian Anda.
Dan dapatkan crack pada alat dev Chrome itu. Mereka terintegrasi langsung ke webkit. Klik kanan di Chrome. Memeriksa elemen. Jelajahi tab. Banyak kekuatan debug di sana dengan kemampuan untuk mengubah kode di konsol selama run-time menjadi salah satu opsi yang paling kuat tetapi kurang jelas. Sangat bagus untuk pengujian.
Pada catatan terkait, kesalahan adalah teman Anda. Jangan pernah menulis pernyataan tangkap kosong. Di JS kita tidak menyembunyikan atau mengubur kesalahan (atau setidaknya kita tidak boleh batuk YUI / batuk ). Kami hadir untuk mereka. Kurang dari itu akan menyebabkan sakit debug. Dan jika Anda menulis pernyataan menangkap untuk menyembunyikan potensi kesalahan dalam produksi setidaknya diam-diam mencatat kesalahan dan mendokumentasikan cara mengakses log.