Pattern matching adalah fitur utama dalam pengembangan perangkat lunak. sementara pattern matching berlaku di beberapa lokasi, penggunaan saat ini terbatas pada Saya ingin membandingkan kekuatan pattern matching di antara beberapa bahasa pemrograman yang saya kenal dalam posting ini. switch case Setiap pembaca pasti sudah akrab dengan Sintax yang diwariskan dari C. Singkatnya: switch case 
 
 
 
 
 Klausa switch merujuk pada pernyataan pengembalian nilai. Setiap klausa kasus menetapkan pernyataan lain; jika nilai cocok dengan pernyataan, itu mengeksekusi blok terkait. Klausa pertama yang cocok mendapatkan bloknya dieksekusi. Dalam C, klausa kasus adalah fall-through; Anda perlu melanggar secara eksplisit untuk melarikan diri dari switch, jika tidak, kasus berikutnya dinilai Pengertian Java Pattern Matching Saya akan mulai dengan Java, karena itu adalah bahasa pemrograman pertama yang saya gunakan dalam konteks profesional. Pattern matching Java telah berevolusi banyak di berbagai versi. Berikut adalah sampel “official” untuk versi 23, sedikit diubah. implementasi dan a Metode yang digunakan untuk mengevaluasi perimeter adalah Salah satu contohnya adalah Object Oriented Programming. Shape static not interface Shape { }
record Rectangle(double length, double width) implements Shape { }
record Circle(double radius) implements Shape { }

public class Main {
    static double getPerimeter(Shape s) throws IllegalArgumentException {
        return switch (s) {                                                 //1
            case Rectangle r when r.length() == r.width() -> {              //2
                System.out.println("Square detected");
                    yield 4 * r.length();
            }
            case Rectangle r ->                                             //3
                2 * r.length() + 2 * r.width();
            case Circle c ->                                                //4
                2 * c.radius() * Math.PI;
            default ->                                                      //5
                throw new IllegalArgumentException("Unrecognized shape");
        };
    }
}
 
 
 
 
 
 
 Referensi parameter bentuk sebagai s Menilai apakah s adalah rectangle dan apakah rectangle adalah persegi Menilai apakah s adalah rectangle Menilai apakah s adalah lingkaran Jika tidak ada klausa sebelumnya yang cocok, default untuk membuang pengecualian Versi Java ini akan menjadi dasar kami. Karakteristik dari New sintaksis switch Switchnya Syntax baru memiliki beberapa keunggulan dibandingkan dengan legacy non-arrow Warisan dari c. switch gaya c Perbedaannya adalah, setelah waktu yang telah ditempuh, a Blok, itu berjalan berikutnya Untuk menghindari hal itu, Anda harus mengatur Pada masa-masa lama yang tidak begitu baik, beberapa pengembang memanfaatkan fitur ini untuk menghindari duplikasi kode. case case case break Namun, pengalaman telah menunjukkan bahwa itu terlalu banyak penyebab potensi bug: praktik pengkodean modern cenderung menghindari itu. Dengan sintaks panah baru, runtime hanya mengevaluasi dengan blok. break case gaya c klausa hanya mengevaluasi nilai-nilai sederhana. Komunitas merayakan Java 7 sebagai hadiah besar ketika memungkinkan nilai-nilai String. Java 21 pergi lebih jauh: dikombinasikan dengan sintaks panah, memungkinkan untuk beralih pada jenis. Jenis . case Shape Selain itu, jika beralih ke kelas Jika hierarki kelas adalah , kompilator dapat secara otomatis mendeteksi kasus yang hilang. Akhirnya, versi 24 menambahkan opsi tambahan dengan filter. dan sealed when Di sisi lain, dalam sintaks C lama, runtime melompat langsung ke yang benar. Sintax panah baru mengevaluasi mereka secara berurutan, persis seperti jika dengan dengan pernyataan. case if else Di bagian berikutnya, kami akan memport kode ke bahasa lain. Spesifikasi Scala Pattern Matching Perpaduan pola Scala telah menjadi yang kedua sejak awalnya. Kotlin menarik banyak inspirasi darinya. trait Shape
case class Rectangle(length: Double, width: Double) extends Shape
case class Circle(radius: Double) extends Shape

def getPerimeter(s: Shape) = {
  s match {                                                                 //1
    case Rectangle(length, width) if length == width =>                     //2-3
      println("Square detected")
      4 * length
    case Rectangle(length, width) => 2 * length + 2 * width                 //3-4
    case Circle(radius) => 2 * radius * Math.PI                             //3-5
    case _ => throw new IllegalArgumentException("Unrecognized shape")      //6
  }
}
 
 
 
 
 
 
 
 Gunakan referensi s secara langsung Menilai apakah s adalah rectangle dan apakah rectangle adalah persegi Scala juga cocok dengan atribut kelas Menilai apakah s adalah rectangle Menilai apakah s adalah lingkaran Jika tidak ada klausa sebelumnya yang cocok, default untuk membuang pengecualian Spesifikasi Kotlin Pattern Matching Mari kita terjemahkan kode Java ke Kotlin. untuk itu, kita Untuk mengaktifkan   Karakteristik yang dijelaskan dalam . harus Eksperimen Xwhen-guards Pertahanan 371 interface Shape
data class Rectangle(val length: Double, val width: Double): Shape
data class Circle(val radius: Double): Shape

fun getPerimeter(s: Shape) = when (s) {                                     //1
        is Rectangle if s.length == s.width -> {                            //2
            println("Square detected")
            4 * s.length
        }
        is Rectangle -> 2 * s.length + 2 * s.width                          //3
        is Circle -> 2 * s.radius * Math.PI                                 //4
        else -> throw IllegalArgumentException("Unknown shape")             //5
    }
}
 
 
 
 
 
 
 Referensi parameter bentuk sebagai s Mengevaluasi apakah s adalah rectangle dan apakah lebar rectangle sama dengan ketinggian Menilai apakah s adalah rectangle Menilai apakah s adalah lingkaran Jika tidak ada klausa sebelumnya yang cocok, default untuk membuang pengecualian Kotlin pattern matching sangat mirip dengan Java, dengan sedikit perubahan sintaks, , yang Penggantian . yang g. if when Evolusi komparatif dari Kotlin vs. Java dalam matching pattern cukup menyoroti. Java tertinggal di belakang sintaks C warisan, sementara Kotlin sudah bisa cocok pada jenis beton sejak awal. Pada tahun 2020, Java 14 mengurangi kesenjangan dengan operator panah; satu tahun kemudian, Java 16 menutup kesenjangan sepenuhnya dengan kemampuan untuk cocok pada jenis beton. dengan klausa. when Pengertian Eksperimental dari Kotlin Ini berarti Java telah melampaui Java – setidaknya di daerah ini! if Pengertian Python Pattern Matching Sebelumnya, Python tidak menawarkan sesuatu yang mirip dengan Pernyataan dari bahasa JVM di atas. dari versi 3.10, itu menawarkan kemampuan yang sama dengan cara yang elegan: switch class Shape:
    pass


class Rectangle(Shape):
    def __init__(self, length: float, width: float):
        self.length = length
        self.width = width


class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius


def get_perimeter(s: Shape) -> float:
    match s:
        case Rectangle(length=l, width=w) if l == w:
            print("Square detected")
            return 4 * l
        case Rectangle(length=l, width=w):
            return 2 * l + 2 * w
        case Circle(radius=r):
            return 2 * pi * r
        case _:
            raise ValueError("Unknown shape")
 Runtime mengevaluasi Perbedaannya seperti dalam bahasa JVM. case Spesifikasi Rust Pattern Matching Pendekatan Rust untuk manajemen memori tidak bermain dengan baik dengan tipe checking. 
 
 
 
 
 Struktur adalah tempat data terstruktur; ukuran memori mereka diketahui pada waktu kompilasi Karakteristik adalah kontrak, mirip dengan antarmuka Anda dapat memberikan implementasi fitur untuk struktur Karena referensi dapat menunjukkan struktur dengan ukuran yang berbeda, kompilator tidak dapat mengetahui ukurannya pada saat kompilasi dan harus menempatkan variabel pada tumpukan bukan tumpukan. Saya mencoba untuk mentransfer kode asli ke Rust satu-ke-satu untuk tujuan pendidikan. Java asli tidak mengambil keuntungan dari polimorfisme; itu tidak bagus. di Rust, itu bahkan lebih jelek. Menarik untuk menyadari bahwa sementara Rust bukan bahasa pemrograman berorientasi objek, itu mengarahkan Anda untuk menggunakan polimorfisme. Peringatan: Saya tidak merekomendasikan kode berikut dan akan menyangkal asosiasi apa pun dengan itu! trait Shape: Any {
    fn as_any(&self) -> &dyn Any;                                     //1
}

struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Circle {
    fn as_any(&self) -> &dyn Any {                                    //2
        self
    }
}
impl Shape for Rectangle {
    fn as_any(&self) -> &dyn Any {                                    //2
        self
    }
}

fn get_perimeter(s: Box<dyn Shape>) -> f64 {
    match s.as_any() {                                                //3
        any if any.is::<Rectangle>() => {                             //4
            let rectangle = any.downcast_ref::<Rectangle>().unwrap(); //5
            if rectangle.width == rectangle.height {
                println!("Square matched");
                4.0 * rectangle.width
            } else {
                2.0 * (rectangle.width + rectangle.height)
            }
        }
        any if any.is::<Circle>() => {                                //4
            let circle = any.downcast_ref::<Circle>().unwrap();       //5
            2.0 * std::f64::consts::PI * circle.radius
        }
        _ => panic!()
    }
}
 
 
 
 
 
 
 Sistem tipe Rust tidak menawarkan cara untuk mendapatkan tipe variabel. kita harus membuat fungsi khusus untuk itu. Mengimplementasikan fungsi untuk struktur Pertandingan pada jenis struktur yang mendasarinya Periksa jenis Download ke struktur yang mendasari untuk menggunakan bidangnya Port kode buatan ini di atas salah mewakili kemampuan pattern-matching Rust. . Banyak tempat Kesimpulan Di antara semua bahasa yang dijelaskan dalam posting, Scala adalah yang pertama yang menyediakan pattern-matching di Selama bertahun-tahun, itu adalah Grail yang orang lain mencoba untuk menangkap; Kotlin dan Java akhirnya telah mencapai tahap ini. switch Di luar JVM, Python dan Rust memiliki kemampuan pattern-matching yang kuat. Dengan penghancuran, pattern matching adalah bantuan besar bagi pengembang yang ingin menulis kode yang dapat dibaca dan dapat dipelihara. Kode sumber lengkap untuk artikel ini dapat ditemukan di . dengan github To go further: 
 
 
 
 
 
 Cara Menggunakan Java 23 Spesifikasi Lengkap di Kotlin Spesifikasi Lengkap di Scala Pernyataan Pertandingan dalam Python Pattern matching dalam Rust Awalnya dipublikasikan di A Java Geek pada 20 Juli, 2025 Menggunakan Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Audio ini diproduksi dalam bahasa asli cerita!

Membandingkan pattern-matching di berbagai bahasa: Java, Scala, dan lainnya

About Author

KOMENTAR

HANG TAG

ARTIKEL INI DISAJIKAN PADA

Related Stories

The Magic Shop

19 things I learnt reading the NodeJSdocs

The Crypto Trading Writing Contest: Submission Deadline Extended!

A Beginner’s Guide to Blockchain Programming

The Magic Shop

19 things I learnt reading the NodeJSdocs

The Crypto Trading Writing Contest: Submission Deadline Extended!

A Beginner’s Guide to Blockchain Programming

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps