Pattern matching is een belangrijk kenmerk in softwareontwikkeling. Terwijl pattern matching op verschillende locaties van toepassing is, is het huidige gebruik ervan beperkt tot: Ik wil de kracht van pattern matching vergelijken in een paar programmeertaal die ik in dit bericht ken. switch case Ik veronderstel dat elke lezer bekend is met de Syntax geërfd van C. Kortom: switch case 
 
 
 
 
 De switchclausule verwijst naar een waarde-return statement. Elke case-clausule stelt een andere verklaring; als de waarde overeenkomt met de verklaring, voert deze het gerelateerde blok uit. De eerste clausule die overeenkomt krijgt zijn blok uitgevoerd. In C zijn gevalclausules doorlopend; u moet expliciet breken om de schakelaar te ontsnappen, anders wordt het volgende geval geëvalueerd Java's patroon matching Ik zal beginnen met Java, omdat het de eerste programmeertaal was die ik in een professionele context gebruikte. Java's pattern matching heeft zich veel ontwikkeld in zijn versies. hier is de "officiële" steekproef voor versie 23, enigszins gewijzigd. Uitvoering en a methode om zijn perimeter te beoordelen. het is zeker Een goed voorbeeld van 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");
        };
    }
}
 
 
 
 
 
 
 Refereren van de Shape-parameter als s Beoordeel of s een rechthoek is en of de rechthoek een vierkant is Beoordelen of s een rechthoek is Beoordelen of s een cirkel is Als geen van de vorige clausules overeenkomen, wordt standaard een uitzondering Deze Java-versie zal onze baseline zijn. Kenmerken van de nieuwe Syntax Schakelen Schakelen De nieuwe syntax heeft enkele voordelen ten opzichte van de legacy non-pile Geërfd van C. switch De C-stijl clausules zijn doorlopend. zodra de runtime een Block, het loopt de volgende blok. om dit te voorkomen, moet u een In de niet-zo-goede oude dagen gebruikten sommige ontwikkelaars deze functie om duplicatie van code te voorkomen. case case case break Ervaring heeft echter aangetoond dat het te veel van een oorzaak van potentiële bugs was: moderne coderingspraktijken hebben de neiging om het te vermijden. Met de nieuwe pijl syntax evalueert de runtime alleen de overeenkomstige Het blok. break case De C-stijl clausules evalueren alleen eenvoudige waarden. De gemeenschap vierde Java 7 als een enorme gunst toen het String-waarden toelaat. Java 21 ging nog verder: in combinatie met de pijl syntax, stelde het toe om typen te schakelen. Het type. case Shape Bovendien, als het schakelen in de klassen Als de hiërarchie van de klassen , de compilator kan automatisch ontbrekende gevallen detecteren. Ten slotte, versie 24 voegde de extra optionele Het filter. en sealed when Aan de andere kant, in de oude C-syntax, springt de runtime rechtstreeks naar de juiste De nieuwe pijl syntax evalueert ze sequentieel, precies zoals met De verklaringen. case if else In de volgende secties brengen we de code naar andere talen. Scala's patroon matching Scala's patroonmatching is sinds de oprichting op de tweede plaats geweest. 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
  }
}
 
 
 
 
 
 
 
 Gebruik de s-referentie direct Beoordeel of s een rechthoek is en of de rechthoek een vierkant is Scala komt bovendien overeen met de klasseattributen Beoordelen of s een rechthoek is Beoordelen of s een cirkel is Als geen van de vorige clausules overeenkomen, wordt standaard een uitzondering Het patroon van Kotlin Laten we de code van Java vertalen naar Kotlin. Activeren van de   compilatiefunctie beschreven in . Moet Experimenteren Xwhen-guards Hoofdstuk 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
    }
}
 
 
 
 
 
 
 Refereren van de Shape-parameter als s Beoordeel of s een rechthoek is en of de breedte van de rechthoek gelijk is aan de hoogte ervan. Beoordelen of s een rechthoek is Beoordelen of s een cirkel is Als geen van de vorige clausules overeenkomen, wordt standaard een uitzondering Het patroon van Kotlin lijkt sterk op dat van Java, met lichte syntaxwijzigingen. - het vervangen . Het e.g. if when De vergelijkende evolutie van Kotlin versus Java in pattern matching is behoorlijk verhelderend. Java lag achter de oude C-syntax, terwijl Kotlin al vanaf het begin op concrete typen kon matchen. In 2020 verlaagde Java 14 de kloof met de pijloperator; een jaar later sloot Java 16 de kloof volledig met de mogelijkheid om op concrete typen te matchen. De clausule. when De experimentele aard van Kotlin's betekent dat Java Java heeft overtroffen – althans in dit gebied! if Python's patroonmatching Voorheen bood Python niets vergelijkbaars aan. Uitspraak van de bovenstaande JVM-talen.Vanaf versie 3.10 biedt het dezelfde mogelijkheden op een elegante manier: 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")
 De runtime evalueert de Dit gebeurt op verschillende manieren, zoals in de JVM-talen. case Rust's patroon matching De benadering van Rust voor geheugenbeheer speelt niet goed met het controleren van typen. 
 
 
 
 
 Structuren zijn gestructureerde gegevensplaatshouders; hun geheugengrootte is bekend op compilatietijd Kenmerken zijn contracten, vergelijkbaar met interfaces U kunt een implementatie van een eigenschap voor een structuur Aangezien de verwijzing naar structuren van verschillende groottes kan wijzen, kan de compilator zijn grootte niet kennen op het moment van compilatie en moet hij de variabele op de stapel plaatsen in plaats van de stapel. Ik heb geprobeerd om de oorspronkelijke code naar Rust één-op-één te porteren voor educatieve doeleinden. De oorspronkelijke Java maakt geen gebruik van polymorphism; het is niet geweldig. In Rust is het nog lelijker. Het is interessant om te beseffen dat terwijl Rust geen objectgeoriënteerde programmeertaal is, het je leidt tot het gebruik van polymorphism. Waarschuwing: Ik raad de volgende code niet aan en zal elke associatie ermee ontkennen! 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!()
    }
}
 
 
 
 
 
 
 Het type-systeem van Rust biedt geen manier om het type van een variabele te krijgen. Implementeer de functie voor structuren Match op het onderliggende type structuur Controleer het type Downcast naar de onderliggende structuur om zijn velden te gebruiken Deze kunstmatige code-poort hierboven vertegenwoordigt de patronenmatching-mogelijkheden van Rust. . Veel plaatsen Conclusie Onder alle talen die in de post worden beschreven, was Scala de eerste die pattern-matching in Jarenlang was het de Graal die anderen probeerden te pakken; Kotlin en Java hebben eindelijk dit stadium bereikt. switch Buiten de JVM hebben Python en Rust krachtige patronenmatching-mogelijkheden. Met de vernietiging is pattern matching een enorme hulp voor ontwikkelaars die leesbare en onderhoudbare code willen schrijven. De volledige broncode voor dit artikel is te vinden op . Met github To go further: 
 
 
 
 
 
 Gebaseerd op Java 23 Pattern matching in Kotlin Pattern matching in Scala Match statement in Python Pattern matching in Rust Oorspronkelijk gepubliceerd op A Java Geek op 20 juli, 2025 Een Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Deze audio wordt geproduceerd in de originele taal van het verhaal!

Pattern-matching vergelijken in verschillende talen: Java, Scala en meer

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps