La coincidència de patrons és una característica important en el desenvolupament de programari. Mentre que la coincidència de patrons s'aplica en diversos llocs, el seu ús actual es limita a: Vull comparar el poder del patró coincidint entre un parell de llenguatges de programació que estic familiaritzat amb en aquest post. switch case Suposo que tots els lectors estan familiaritzats amb Sintaxa heretada de C. En resum: switch case 
 
 
 
 
 La clàusula de canvi fa referència a una declaració de retorn de valor. Cada clàusula de cas estableix una altra declaració; si el valor coincideix amb la declaració, executa el bloc relacionat. La primera clàusula que coincideix obté el seu bloc executat. En C, les clàusules de cas són fall-through; cal trencar explícitament per escapar del interruptor, en cas contrari, s'avalua el següent cas. El Pattern Matching de Java Començaré amb Java, ja que va ser el primer llenguatge de programació que vaig utilitzar en un context professional. El pattern matching de Java ha evolucionat molt a través de les seves versions.Aquí hi ha la mostra "oficial" per a la versió 23, lleugerament modificada. Aplicacions i a per determinar el seu perímetre, és clar. Un bon exemple de programació orientada a objectes. 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");
        };
    }
}
 
 
 
 
 
 
 Referència al paràmetre de forma com s Avaluar si s és un rectangle i si el rectangle és un quadrat Avaluar si s és un rectangle Avaluar si s és un cercle Si cap de les clàusules anteriors coincideix, per defecte a llançar una excepció Aquesta versió de Java serà la nostra base. Característiques del nou Síntesi canviant canviant La nova sintaxi té alguns avantatges sobre l'heretat no fletxa Heretat de C. switch C-style  El temps d'execució és el mateix que el temps d'execució, una vegada que s'ha executat un Bloc, s'executa el següent bloc. Per evitar-ho, cal establir una En els temps no tan bons, alguns desenvolupadors van aprofitar aquesta característica per evitar la duplicació de codi. case case case break No obstant això, l'experiència ha demostrat que era massa una causa de possibles errors: les pràctiques modernes de codificació tendeixen a evitar-ho. Amb la nova sintaxi de fletxa, el temps d'execució només avalua el corresponent El bloc. break case Estil C Les clàusules només avaluen valors simples. La comunitat va celebrar Java 7 com un gran benefici quan va permetre valors de cadena. Java 21 va anar encara més enllà: juntament amb la sintaxi de fletxa, va permetre canviar de tipus. El tipus. case Shape A més, si es canvia la classe Si la jerarquia de classes és , el compilador pot detectar automàticament els casos que falten. Finalment, la versió 24 va afegir l'opcional addicional El filtre. i sealed when En el cas de l'antiga sintaxi C, el temps d'execució salta directament al correcte. La nova sintaxi de fletxa les avalua seqüencialment, exactament com si amb Les declaracions. case if else En les següents seccions, portarem el codi a altres idiomes. El Pattern Matching de Scala La coincidència de patrons de Scala ha estat segona a cap des de la seva creació. 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
  }
}
 
 
 
 
 
 
 
 Utilitzar la referència S directament Avaluar si s és un rectangle i si el rectangle és un quadrat Scala també coincideix amb els atributs de la classe Avaluar si s és un rectangle Avaluar si s és un cercle Si cap de les clàusules anteriors coincideix, per defecte a llançar una excepció El patró de Kotlin traduïm el codi de Java a Kotlin. Activar el   Característiques de la col·lecció descrita en . Mussà Experimentació Xwhen-guards Pàrquing 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
    }
}
 
 
 
 
 
 
 Referència al paràmetre de forma com s Avaluar si s és un rectangle i si l'amplada del rectangle és igual a la seva alçada Avaluar si s és un rectangle Avaluar si s és un cercle Si cap de les clàusules anteriors coincideix, per defecte a llançar una excepció El patró de Kotlin s'assembla molt al de Java, amb canvis lleus en la sintaxi. , Substitució . El g. if when L'evolució comparativa de Kotlin vs. Java en la coincidència de patrons és bastant il·luminant. Java va quedar darrere de la sintaxi C llegida, mentre que Kotlin ja podia coincidir en tipus de formigó des del principi. El 2020, Java 14 va reduir la bretxa amb l'operador de fletxa; un any més tard, Java 16 va tancar la bretxa completament amb la capacitat de coincidir en tipus de formigó. La clàusula when La naturalesa experimental de Kotlin Això vol dir que Java ha superat Java, almenys en aquesta àrea! if El Pattern Matching de Python Abans, Python no oferia res semblant a la Des de la versió 3.10, ofereix la mateixa capacitat d'una manera elegant: 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")
 El rànquing avalua el Les clàusules són seqüencials, com en els idiomes JVM. case El patró de Rust L'enfocament de Rust en la gestió de la memòria no juga bé amb els tipus de comprovació. 
 
 
 
 
 Les estructures són localitzadors de dades estructurades; la seva mida de memòria es coneix en el moment de la compilació. Les característiques són contractes, semblants a les interfícies Pot proporcionar una implementació d'un tret per a una estructura Atès que la referència pot apuntar a estructures de diferents mides, el compilador no pot conèixer la seva mida en el moment de la compilació i ha de col·locar la variable a la pila en lloc de la pila. He intentat portar el codi original a Rust un a un per a fins educatius. El Java original no aprofita el polimorfisme; no és gran. En Rust, és encara més feixuc. És interessant adonar-se que tot i que Rust no és un llenguatge de programació orientat a objectes, et porta a utilitzar el polimorfisme. ADVERTÈNCIA: No recomano el següent codi i negaré qualsevol associació amb ell! 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!()
    }
}
 
 
 
 
 
 
 El sistema de tipus de Rust no ofereix una manera d'obtenir el tipus d'una variable. Implementar la funció per a les estructures Match sobre el tipus d'estructura subjacent Comprova el tipus Downcast to the underlying structure to use its fields Aquest port de codi artificial a dalt representa incorrectament les capacitats de coincidència de patrons de Rust. . Molts llocs Conclusió Entre tots els idiomes descrits en el post, Scala va ser el primer a proporcionar la coincidència de patrons en Durant molts anys, va ser el Graal que altres van tractar d'agafar; Kotlin i Java han arribat finalment a aquesta etapa. switch Fora del JVM, Python i Rust tenen potents capacitats de coincidència de patrons. Amb la destrucció, la coincidència de patrons és una gran ajuda per als desenvolupadors que volen escriure codi llegible i mantenible. El codi font complet d'aquest article es pot trobar a . El GitHub To go further: 
 
 
 
 
 
 Desenvolupament de patterns en Java 23 Pattern matching a Kotlin El patró coincideix amb l'escala Declaració de jocs en Python El patró coincideix en Rust Originalment publicat a A Java Geek el 20 de juliol de 2025. Una java geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Aquest àudio és produït a l'idioma original de la història!

Comparació de patró-matching entre diferents llenguatges: Java, Scala i més

About Author

COMENTARIS

Etiquetes penjant

AQUEST ARTICLE VA SER PRESENTAT A

Related Stories

How AWS, Bosch & Brave Reach 4M+ Tech Pros on HackerNoon

TON Game ‘BANANA’ Hits 1M Users In 72 Hours

New Features: They're Everything, We're Just Ken

Startups of The Year: Meet the Engineering Industry

How AWS, Bosch & Brave Reach 4M+ Tech Pros on HackerNoon

TON Game ‘BANANA’ Hits 1M Users In 72 Hours

New Features: They're Everything, We're Just Ken

Startups of The Year: Meet the Engineering Industry

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps