Pattern matching adalah ciri utama dalam pembangunan perisian. manakala pattern matching digunakan di beberapa lokasi, penggunaan semasa terhad kepada Saya mahu membandingkan kuasa pattern matching di antara beberapa bahasa pemrograman yang saya kenali dalam post ini. switch case Saya menganggap bahawa setiap pembaca mempunyai pengetahuan tentang Syntax diwarisi daripada C. Singkatnya: switch case 
 
 
 
 
 Klausa switch merujuk kepada pernyataan pengembalian nilai. Setiap klausa kes menetapkan pernyataan yang lain; jika nilai sepadan dengan pernyataan, ia melaksanakan blok yang berkaitan. klausa kes dinilai dalam urutan. klausa pertama yang sepadan mendapat bloknya dilaksanakan. Dalam C, klausa kes adalah runtuh; anda perlu melanggar secara eksplisit untuk melarikan diri daripada pemutus, jika tidak, kes seterusnya dinilai Perpaduan Pattern Java Saya akan mula dengan Java, kerana ia merupakan bahasa pemrograman pertama yang saya gunakan dalam konteks profesional. Perpaduan corak Java telah berkembang banyak di seluruh versi. Berikut adalah sampel "pemerintah" untuk versi 23, sedikit diubahsuai. pelaksanaan dan a cara untuk menilai perimeternya. ia pasti contoh yang baik dalam pemrograman objek. 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");
        };
    }
}
 
 
 
 
 
 
 Merujuk kepada parameter Shape sebagai s Menilai sama ada s adalah rectangle dan sama ada rectangle adalah persegi Menilai sama ada s ialah rectangle Menilai sama ada s ialah lingkaran Jika tiada klausa terdahulu yang sepadan, lalai untuk melemparkan pengecualian Versi Java ini akan menjadi baseline kami. Ciri-ciri daripada yang baru sintaks pertukaran pertukaran Syntax baru mempunyai beberapa kelebihan berbanding legacy bukan anak panah yang diwarisi daripada c. switch C gaya Perkara-perkara ini boleh berlaku.Selepas pelancaran satu blok, ia berjalan seterusnya blok. untuk mengelak daripada itu, anda perlu menetapkan Dalam masa lama yang tidak begitu baik, sesetengah pengembang memanfaatkan ciri ini untuk mengelakkan duplikasi kod. case case case break Walau bagaimanapun, pengalaman telah menunjukkan bahawa ia terlalu banyak menjadi punca kepada bug yang berpotensi: amalan pengkodean moden cenderung untuk mengelak daripada itu. Dengan sintaks anak panah baru, runtime hanya menilai kepada blok. break case C gaya klausa hanya menilai nilai-nilai mudah. Komuniti merayakan Java 7 sebagai anugerah besar apabila ia membenarkan nilai-nilai String. Java 21 pergi lebih jauh: digabungkan dengan sintaks anak panah, ia membenarkan untuk bertukar pada jenis. Dalam contoh di atas, kami memeriksa yang tepat Jenis . case Shape Selain itu, jika anda menukar kelas Jika hierarki kelas adalah , kompilator boleh mengesan kes yang hilang secara automatik. Akhirnya, versi 24 menambah opsyen tambahan Filem yang dan sealed when Di sisi berbalik, dalam sintaks C lama, runtime melompat terus ke yang betul klausa. sintaks anak panah baru menilai mereka secara berurutan, persis seperti jika dengan Pernyataan case if else Dalam bahagian-bahagian seterusnya, kami akan memindahkan kod kepada bahasa lain. Scala Pattern Perpaduan Scala pattern matching telah kedua kepada tiada sejak penubuhannya. 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 rujukan s secara langsung Menilai sama ada s adalah rectangle dan sama ada rectangle adalah persegi Scala juga sepadan dengan atribut kelas Menilai sama ada s ialah rectangle Menilai sama ada s ialah lingkaran Jika tiada klausa terdahulu yang sepadan, lalai untuk melemparkan pengecualian Perpaduan Pattern Kotlin Mari kita terjemahkan kod Java kepada Kotlin. Mengaktifkan   ciri-ciri yang digambarkan dalam . mesti Eksperimen Xwhen-guards Perlembagaan 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
    }
}
 
 
 
 
 
 
 Merujuk kepada parameter Shape sebagai s Menilai sama ada s adalah rectangle dan sama ada lebar rectangle adalah sama dengan ketinggian Menilai sama ada s ialah rectangle Menilai sama ada s ialah lingkaran Jika tiada klausa terdahulu yang sepadan, lalai untuk melemparkan pengecualian Kotlin pattern matching sangat menyerupai Java, dengan sedikit perubahan sintaks, daripada Penggantian . dan g. if when Evolusi perbandingan Kotlin vs. Java dalam perbandingan corak agak mengejutkan. Java terlepas daripada sintaks C warisan, manakala Kotlin sudah boleh mencocokkan pada jenis konkrit dari awal. Pada tahun 2020, Java 14 mengurangkan kesenjangan dengan operator panah; setahun kemudian, Java 16 menutup kesenjangan sepenuhnya dengan keupayaan untuk mencocokkan pada jenis konkrit. Klausa yang when Ciri-ciri eksperimen Kotlin Ini bermakna Java telah melampaui Java – sekurang-kurangnya di kawasan ini! if Perpaduan Pattern Python Sebelum ini, Python tidak menawarkan apa-apa yang serupa dengan daripada bahasa JVM di atas. Dari versi 3.10, ia menawarkan keupayaan 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 Perkataan-perkataan yang berbeza seperti dalam bahasa JVM. case Rust's Pattern Perlawanan Pendekatan Rust untuk pengurusan memori tidak bermain dengan baik dengan jenis cek.Sekarang, Rust menawarkan dua konsep asas: 
 
 
 
 
 Struktur ialah pemegang tempat data terstruktur; saiz memori mereka dikenali pada masa kompilasi Ciri-ciri adalah kontrak, seperti antara muka Anda boleh menyediakan pelaksanaan ciri untuk struktur Memandangkan rujukan boleh menunjukkan kepada struktur saiz yang berbeza, kompilator tidak boleh tahu saiznya pada masa kompilasi dan mesti meletakkan variabel pada tumpukan bukannya tumpukan. Saya cuba untuk memindahkan kod asal kepada Rust satu kepada satu untuk tujuan pendidikan. Java asal tidak mengambil keuntungan daripada polymorphism; ia tidak hebat. dalam Rust, ia lebih jelek. Ia menarik untuk menyedari bahawa walaupun Rust bukan bahasa pemrograman berorientasikan objek, ia membawa anda untuk menggunakan polymorphism. Amaran: Saya tidak mengesyorkan kod berikut dan akan menyangkal apa-apa perkongsian dengan ia! 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 jenis Rust tidak menawarkan cara untuk mendapatkan jenis variabel. kita mesti mencipta fungsi khusus untuk itu. Melaksanakan fungsi untuk struktur Perlawanan pada jenis struktur asas Periksa jenis Downcast ke struktur asas untuk menggunakan medan Port kod buatan di atas menyesatkan keupayaan pattern-matching Rust. . Banyak tempat Kesimpulan Antara semua bahasa yang diterangkan dalam post, Scala adalah yang pertama yang menyediakan pattern-matching dalam Selama bertahun-tahun, ia adalah Grail yang orang lain cuba menangkap; Kotlin dan Java akhirnya telah mencapai peringkat ini. switch Di luar JVM, Python dan Rust mempunyai keupayaan pattern-matching yang kuat. Dengan pemusnahan, mencocokkan corak adalah bantuan besar kepada pemaju yang mahu menulis kod yang boleh dibaca dan boleh dikekalkan. Kode sumber lengkap untuk artikel ini boleh didapati di . GitHub ialah To go further: 
 
 
 
 
 
 Perbezaan dalam Java 23 Pattern matching di Kotlin Perbezaan dalam Scala Pernyataan perlawanan dalam Python Pattern matching dalam Rust Awalnya diterbitkan di A Java Geek pada 20 Julai, 2025 Tag: java geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Audio ini dihasilkan dalam bahasa asal cerita!

Membandingkan pattern-matching antara bahasa yang berbeza: Java, Scala, dan lain-lain

About Author

KOMEN

GANTUNG TANDA

ARTIKEL INI DIBENTANGKAN DALAM

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps