Halo kolega.
Jenny Marvin potret dari
UnsplashHari ini kami telah menyiapkan untuk Anda terjemahan sebuah artikel tentang kesamaan mendasar dari banyak bahasa pemrograman menggunakan Ruby dan C # sebagai contoh. Kami berharap bahwa ide-ide dari Severin Peres yang dihormati akan membantu banyak dari Anda dengan cepat mulai belajar bahasa pemrograman baru, dan segala sesuatunya akan berjalan dengan rasa dan kesenangan yang nyata.
Apa yang tidak mengambil dari programmer - dia tidak pernah berhenti belajar. Anda mungkin memiliki bahasa favorit, atau kerangka kerja, atau perpustakaan, tetapi tidak ada keraguan bahwa Anda tidak dapat melakukannya secara eksklusif dengan mereka. Anda mungkin menyukai JavaScript, tetapi proyek yang sedang Anda kerjakan mungkin memerlukan Python. Anda mungkin mahir di Perl, tetapi basis kode di perusahaan Anda dapat ditulis dalam C ++. Untuk pengembang pemula, gagasan belajar bahasa baru bisa menakutkan, terutama jika tenggat waktu datang. Ini berita buruk. Namun, ada yang bagus: belajar bahasa baru biasanya tidak terlalu sulit. Jika kita mengambil model mental yang ada sebagai dasar, maka Anda akan melihat bahwa belajar bahasa baru pada dasarnya adalah perpanjangan dari pengetahuan yang ada, dan tidak bekerja dari awal.
Apa kesamaan yang mereka miliki
Sebagian besar bahasa pemrograman pada dasarnya didasarkan pada serangkaian prinsip utama yang sama. Implementasinya berbeda, tetapi hampir tidak ada dua bahasa yang begitu berbeda sehingga tidak mungkin untuk membuat paralel antara mereka. Untuk mempelajari dan memahami bahasa baru, hal yang paling penting adalah mengidentifikasi bagaimana kelihatannya Anda sudah tahu, dan kemudian mendapatkan pengetahuan baru, memperluas pemahaman Anda tentang hal itu ketika / jika perlu. Pertimbangkan, misalnya, tipe dan variabel data. Dalam setiap bahasa, ada cara untuk mendefinisikan dan menyimpan data - secara seragam di seluruh program. Karena itu, ketika mempelajari bahasa baru, Anda harus terlebih dahulu memahami bagaimana variabel didefinisikan dan digunakan di sini. Ambil dua bahasa yang berbeda sebagai contoh: menafsirkan Ruby dengan pengetikan dinamis dan mengkompilasi C # dengan pengetikan statis.
my_int = 8 my_decimal = 8.5 my_string = "electron" puts "My int is: #{my_int}" puts "My float is: #{my_decimal}" puts "My string is: #{my_string}"
Contoh serupa:
using System; public class Program { public static void Main() { int myInt = 8; double myDecimal = 8.5; string myString = "electron"; Console.WriteLine("My int is: {0}", myInt); Console.WriteLine("My float is: {0}", myDecimal); Console.WriteLine("My string is: {0}", myString); } }
Katakanlah Anda adalah pengembang Ruby yang berpengalaman dan ingin belajar C #. Berikut ini adalah cuplikan kode, di mana Anda dapat dengan mudah mengenali Ruby. Di sana Anda hanya perlu mendefinisikan beberapa variabel dan menampilkannya di konsol. Sekarang perhatikan fragmen kedua. Apakah kamu belajar sesuatu? Sintaksnya berbeda, tetapi tidak ada keraguan bahwa kode kedua berfungsi seperti yang pertama. Operator = ditemui beberapa kali, yang mungkin mencolok sebagai simbol operasi penugasan. Kemudian sebuah
Console.WriteLine() tertentu dipanggil, menyiratkan bahwa nilai-nilai akan ditampilkan di konsol. Ada juga beberapa baris di sini yang tampaknya menggunakan interpolasi untuk menulis pesan. Secara konseptual, tidak ada yang mengejutkan di sini - penugasan, interpolasi, output ke konsol, semua operasi ini sudah diketahui oleh Anda dalam bekerja dengan Ruby.
Anda dapat memahami fragmen kode kedua tanpa pengetahuan C #, tetapi pasti ada ruang untuk memperluas model mental Anda. Misalnya, mengapa semua orang membungkus diri mereka sendiri dalam metode
Main() ? Apa kata kunci
int ,
double , dan
string ? Dengan ini, pelatihan dimulai. Anda sudah memahami secara umum apa yang terjadi di sini (tugas, interpolasi, output), sekarang saatnya beralih ke detail:
Main() : Setelah sedikit lebih dalam ke situasinya, kami mengetahui bahwa metode Main() adalah titik masuk dari mana program dimulai. Sekarang kita tahu bahwa di semua program C # kita memerlukan metode Main ().- Variabel: di bagian pertama dari fragmen kami di C # beberapa jenis tugas pasti terjadi. Dengan nomenklatur tersebut, Anda mungkin menebak bahwa kata kunci
int berarti variabel integer, double adalah angka floating-point presisi ganda, dan string adalah variabel string. Hampir segera, Anda menyadari bahwa dalam C #, tidak seperti Ruby, diperlukan pengetikan variabel statis, karena variabel dideklarasikan secara berbeda untuk tipe data yang berbeda. Setelah membaca dokumentasi, Anda akan mengerti betapa berbedanya itu. Console.WriteLine() : Akhirnya, menjalankan program, Anda akan melihat bahwa Console.WriteLine() menampilkan nilai-nilai di konsol. Dari Ruby, Anda tahu bahwa puts adalah metode objek $stdout global, dan jika Anda melihat dokumentasi untuk Console.WriteLine() , Anda akan menemukan bahwa Console adalah kelas dari System namespace, dan WriteLine() adalah metode yang didefinisikan dalam ini ruang kelas. Ini tidak hanya terlihat seperti puts , tetapi juga menunjukkan bahwa C #, seperti Ruby, adalah bahasa yang berorientasi objek. Di sini Anda memiliki model mental lain yang akan membantu Anda melacak paralel baru.
Contoh di atas sangat sederhana, tetapi bahkan sejumlah kesimpulan penting dapat ditarik darinya. Anda telah mengetahui bahwa program C # membutuhkan titik masuk yang terdefinisi dengan baik, bahwa bahasa ini diketik secara statis (tidak seperti Ruby) dan berorientasi objek (seperti Ruby). Anda menemukan jawabannya, karena Anda sudah membayangkan variabel dan metode apa, dan kemudian Anda memperluas model mental ini, memperkaya mereka dengan fenomena tipifikasi.
Cari perbedaan
Mulai mencoba cara membaca dan menulis kode dalam bahasa baru, hal pertama yang perlu Anda ketahui hal-hal apa yang sudah diketahui dan dapat berfungsi sebagai dasar untuk belajar. Selanjutnya, beralihlah ke perbedaan. Mari kita kembali ke transisi kita dari Ruby ke C # dan melihat sesuatu yang lebih rumit.
particles = ["electron", "proton", "neturon"] particles.push("muon") particles.push("photon") particles.each do |particle| puts particle end
Dalam fragmen Ruby ini, kita mendefinisikan sebuah array yang disebut
particles , yang akan berisi beberapa baris, dan kemudian menggunakan
Array#push untuk menambahkan beberapa baris ke dalamnya, dan
Array#each -
Array#each untuk beralih di atas array dan output setiap baris individu ke konsol. Tetapi bagaimana melakukan hal yang sama dalam C #? Sedikit googling, kami menemukan bahwa C # telah mengetik array (pengetikan seharusnya tidak mengejutkan Anda lagi, mengingat apa yang Anda pelajari sebelumnya), dan ada juga metode SetValue yang sedikit menyerupai
push , tetapi mengambil nilai dan posisi dalam indeks sebagai parameter. Dalam hal ini, upaya pertama untuk menulis ulang kode Ruby dalam C # dapat menghasilkan ini:
using System; using System.Collections.Generic; public class Program { public static void Main() { string[] particles = new string[] { "electron", "proton", "neturon" }; particles.SetValue("muon", 3);
Sayangnya, kode ini akan memunculkan
Run-time exception ketika Anda mencoba menggunakan
SetValue untuk menambahkan nilai baru ke array. Sekali lagi, kita melihat dokumentasi dan menemukan bahwa array dalam C # tidak dinamis, dan harus diinisialisasi dengan semua nilai, atau dengan indikasi panjang. Sekali lagi mencoba mereproduksi kode Ruby, pertimbangkan ini dan dapatkan opsi berikut:
using System; using System.Collections.Generic; public class Program { public static void Main() { string[] particles = new string[] { "electron", "proton", "neturon", null, null }; particles.SetValue("muon", 3); particles.SetValue("photon", 4); foreach (string particle in particles) { Console.WriteLine(particle); } } }
Cuplikan ini benar-benar mereproduksi semua fungsi kode sumber Ruby, tetapi dengan peregangan besar: hanya menampilkan nilai yang sama ke konsol. Jika Anda hati-hati memeriksa kedua fragmen, maka masalah dengan cepat ditemukan: dalam fragmen dalam C # dalam array partikel tidak boleh ada lebih dari 5 nilai, sedangkan dalam fragmen di Ruby ada sebanyak mungkin. Kemudian menjadi jelas bahwa array di Ruby dan C # pada dasarnya berbeda: yang pertama memiliki ukuran dinamis, sedangkan yang terakhir tidak. Untuk mereproduksi fungsionalitas potongan Ruby dengan benar di C #, Anda memerlukan lebih banyak kode ini:
using System; using System.Collections.Generic; public class Program { public static void Main() { List<String> particles = new List<String>(); particles.Add("electron"); particles.Add("proton"); particles.Add("neutron"); particles.Add("muon"); particles.Add("photon"); foreach (string particle in particles) { Console.WriteLine(particle); } } }
Ini menggunakan struktur data
List untuk mengumpulkan nilai secara dinamis. Dalam hal ini, kami sebenarnya mereproduksi kode Ruby asli dalam C #, tetapi, yang lebih penting, di sini kami dapat menghargai perbedaan utama antara kedua bahasa. Meskipun dalam kedua bahasa istilah "array" digunakan dan mungkin terlihat bahwa array ini adalah satu dan sama, dalam prakteknya mereka sangat berbeda. Berikut adalah satu hal lagi yang membantu memperluas model mental, untuk lebih memahami apa itu "array" dan bagaimana cara mengaturnya. Dalam C #, sebuah array sebagai struktur data mungkin cocok atau tidak cocok dalam situasi di mana di Ruby Anda akan menggunakan array; kita berbicara tentang situasi di mana ukuran dinamis array sangat penting. Sekarang Anda harus mengurus ini terlebih dahulu dan memikirkan kode Anda sesuai.
Kembali ke Prinsip Utama
Sangat mudah untuk mulai belajar bahasa baru, mengeksplorasi persamaan dan perbedaan mereka dibandingkan dengan bahasa yang sudah dikenal; namun, dalam beberapa kasus lebih disarankan untuk memulai dengan prinsip-prinsip universal. Di atas, kami secara logis menyimpulkan bahwa C # adalah bahasa berorientasi objek ketika kami bekerja dengan kelas bawaan dan salah satu metodenya,
System.Console.WriteLine() , yang dengannya kami melakukan tindakan. Adalah logis untuk mengasumsikan bahwa dalam C #, seperti dalam bahasa berorientasi objek lainnya, ada mekanisme untuk mendefinisikan kelas dan instantiating objek dari itu. Ini adalah prinsip dasar pemrograman berorientasi objek, sehingga Anda dapat memiliki sedikit keraguan tentang kebenaran asumsi kami. Pertama, mari kita lihat bagaimana operasi ini terlihat dalam bahasa Ruby yang akrab.
class Element attr_accessor :name, :symbol, :number def initialize(name, symbol, number) self.name = name self.symbol = symbol self.number = number end def describe puts "
Di sini kita memiliki kelas
Element sederhana, di mana ada metode konstruktor untuk menerima nilai dan menetapkannya ke objek yang dipakai, satu set metode akses untuk menetapkan dan menerima nilai, dan juga metode contoh untuk menghasilkan nilai-nilai ini. Dalam hal ini, konsep-konsep utama adalah gagasan kelas, gagasan metode konstruktor, gagasan pengambil / penyetel, dan gagasan metode contoh. Kembali ke gagasan kami tentang apa yang dapat dilakukan dalam bahasa berorientasi objek, kami akan melihat cara melakukan hal yang sama dalam C #.
using System; public class Program { public static void Main() { Element hydrogen = new Element("Hydrogen", "H", 1); hydrogen.Describe(); } public class Element { public string Name { get; set; } public string Symbol { get; set; } public int Number { get; set; } public Element(string name, string symbol, int number) { this.Name = name; this.Symbol = symbol; this.Number = number; } public void Describe() { Console.WriteLine ( "{0} ({1}) has atomic number {2}.", this.Name, this.Symbol, this.Number ); } } }
Setelah mempelajari fragmen ini dalam C #, kita melihat bahwa, pada kenyataannya, tidak jauh berbeda dari versi Ruby. Kami mendefinisikan kelas, menggunakan konstruktor menentukan bagaimana kelas akan instantiate objek, mendefinisikan getter / setter, dan menentukan metode instance yang akan kita panggil dalam objek yang dibuat. Secara alami, kedua fragmen ini sangat berbeda dalam penampilan, tetapi tidak dengan cara yang paling tidak terduga. Dalam versi C #, kami menggunakan
this untuk merujuk ke objek instantiated, sedangkan di Ruby kami menggunakan
self untuk ini. Versi C # diketik di tingkat metode dan di tingkat parameter, sedangkan di Ruby tidak. Namun, pada level prinsip-prinsip utama, kedua fragmen tersebut hampir identik.
Mengembangkan topik ini, kita dapat mempertimbangkan gagasan pewarisan. Diketahui bahwa pewarisan dan subclass adalah poin kunci dari pemrograman berorientasi objek, sehingga mudah untuk memahami bahwa dalam C # ini dilakukan dengan kesuksesan yang sama seperti di Ruby.
class Element attr_accessor :name, :symbol, :number def initialize(name, symbol, number) self.name = name self.symbol = symbol self.number = number end def describe puts "
Dalam versi Ruby, kami mendefinisikan subkelas
NobleGas yang diwarisi dari kelas
Element kami; konstruktornya menggunakan kata kunci super, yang memperluas konstruktor dari kelas induk dan kemudian menimpa metode contoh
describe untuk menentukan perilaku baru. Hal yang sama dapat dilakukan dalam C #, tetapi dengan sintaks yang berbeda:
using System; public class Program { public static void Main() { NobleGas argon = new NobleGas("Argon", "Ar", 18); argon.Describe(); } public class Element { public string Name { get; set; } public string Symbol { get; set; } public int Number { get; set; } public Element(string name, string symbol, int number) { this.Name = name; this.Symbol = symbol; this.Number = number; } public virtual void Describe() { Console.WriteLine ( "{0} ({1}) has atomic number {2}.", this.Name, this.Symbol, this.Number ); } } public class NobleGas : Element { public string Category { get; set; } public string Type { get; set; } public string Reactivity { get; set; } public NobleGas(string name, string symbol, int number) : base(name, symbol, number) { this.Category = "gas"; this.Type = "noble gas"; this.Reactivity = "low"; } public override void Describe() { Console.WriteLine ( "{0} ({1}; {2}) is a {3} of type {4}. It has {5} reactivity.", this.Name, this.Symbol, this.Number, this.Category, this.Type, this.Reactivity ); } } }
Sekilas, ketika kami masih tidak tahu apa-apa tentang C #, daftar terakhir ini mungkin tampak menakutkan. Sintaksnya tidak dikenal, beberapa kata kunci dan kode aneh tidak ditata seperti dulu. Namun, jika kita mempertimbangkan kode ini dari sudut pandang prinsip-prinsip dasar, perbedaannya tidak begitu signifikan: di sini kita hanya memiliki definisi kelas, satu set metode dan variabel dan serangkaian aturan untuk instantiating dan menggunakan objek.
TL; DR
Mempelajari bahasa baru bisa sangat sulit jika Anda melakukannya dari awal. Namun, sebagian besar bahasa pemrograman didasarkan pada prinsip-prinsip dasar yang sama, di mana mudah untuk menggambar paralel, melihat perbedaan penting dan berlaku dalam banyak bahasa. Mencoba bahasa baru pada model mental yang ada, Anda dapat menemukan di mana itu tidak berbeda dari bahasa yang sudah dipelajari, dan di mana Anda benar-benar perlu menjelaskan sesuatu. Mempelajari lebih banyak dan lebih banyak bahasa dari waktu ke waktu, Anda mengembangkan model mental Anda, dan penyempurnaan seperti itu semakin dibutuhkan - Anda akan mengenali berbagai implementasi dalam berbagai bahasa dari lembar.