El ajuste de patrones es una característica importante en el desarrollo de software. Mientras que el ajuste de patrones se aplica en varios lugares, su uso actual se limita a: Quiero comparar el poder de la coincidencia de patrones en un par de lenguajes de programación con los que estoy familiarizado en este post. switch case Todos los lectores están familiarizados con el Sintaxis heredada de C. En resumen: switch case 
 
 
 
 
 La cláusula de cambio hace referencia a una declaración de retorno de valor. Cada cláusula de caso establece otra declaración; si el valor coincide con la declaración, ejecuta el bloque relacionado. Las cláusulas de caso se evalúan en orden.La primera cláusula que coincide obtiene su bloque ejecutado. En C, las cláusulas de caso son fall-through; es necesario romper explícitamente para escapar del interruptor, de lo contrario, se evalúa el siguiente caso. El Pattern Matching de Java Comenzaré con Java, ya que fue el primer lenguaje de programación que usé en un contexto profesional. El ajuste de patrones de Java ha evolucionado mucho a través de sus versiones. Aquí está la muestra "oficial" para la versión 23, ligeramente modificada. Implementación y a el método para evaluar su perímetro. Es un buen ejemplo de programación orientada a objetos. 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");
        };
    }
}
 
 
 
 
 
 
 Referenciar el parámetro de forma como s Evaluar si s es un rectángulo y si el rectángulo es un cuadrado Evaluar si s es un rectángulo Evaluar si s es un círculo Si ninguna de las cláusulas anteriores coincide, por defecto a lanzar una excepción Esta versión de Java será nuestra base. Características del nuevo Síntesis Switch Switch La nueva sintaxis tiene algunas ventajas sobre el legado sin flecha heredado de C. switch Estilo C El tiempo de ejecución: Una vez que el tiempo de ejecución ha sido Bloco, se ejecuta el siguiente bloqueo. Para evitarlo, es necesario establecer un En los no tan buenos viejos días, algunos desarrolladores aprovecharon esta característica para evitar la duplicación de código. case case case break Sin embargo, la experiencia ha demostrado que era demasiado una causa de posibles errores: las prácticas modernas de codificación tienden a evitarlo. Con la nueva sintaxis de flecha, el tiempo de ejecución sólo evalúa el El Bloque. break case Estilo C Las cláusulas sólo evalúan valores simples. La comunidad celebró Java 7 como un gran bono cuando permitió los valores de String. Java 21 fue aún más lejos: junto con la sintaxis de flecha, permitió cambiar tipos. El tipo. case Shape Además, si cambiamos de clase Si la jerarquía de clases es , el compilador puede detectar automáticamente los casos faltantes. Finalmente, la versión 24 añadió la opción adicional El filtro. y sealed when En el lado flip, en la vieja sintaxis C, el tiempo de ejecución salta directamente al correcto La nueva sintaxis de flecha las evalúa secuencialmente, exactamente como si con Las declaraciones. case if else En las siguientes secciones, llevaremos el código a otros idiomas. El Pattern Matching de Scala La combinación de patrones de Scala ha sido segunda a ninguna desde su creación. 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
  }
}
 
 
 
 
 
 
 
 Utilice la referencia S directamente Evaluar si s es un rectángulo y si el rectángulo es un cuadrado Scala también coincide con los atributos de la clase Evaluar si s es un rectángulo Evaluar si s es un círculo Si ninguna de las cláusulas anteriores coincide, por defecto a lanzar una excepción El Pattern Matching de Kotlin Traducimos el código de Java a Kotlin. activar el   La compilación descrita en . debe Experimentales Xwhen-guards Página 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
    }
}
 
 
 
 
 
 
 Referenciar el parámetro de forma como s Evaluar si s es un rectángulo y si la anchura del rectángulo es igual a su altura Evaluar si s es un rectángulo Evaluar si s es un círculo Si ninguna de las cláusulas anteriores coincide, por defecto a lanzar una excepción La combinación de patrones de Kotlin es muy similar a la de Java, con ligeros cambios en la sintaxis. , de sustituyentes . El E.G. if when La evolución comparativa de Kotlin vs. Java en la coincidencia de patrones es bastante esclarecedora. Java quedó atrás de la sintaxis C heredada, mientras que Kotlin ya podría coincidir en tipos de hormigón desde el principio. En 2020, Java 14 redujo la brecha con el operador de flecha; un año después, Java 16 cerró la brecha completamente con la capacidad de coincidir en tipos de hormigón. La cláusula. when La naturaleza experimental de Kotlin significa que Java ha superado a Java, al menos en esta área! es lo suficientemente raro como para ser notado. if Pattern Matching de Python Antes, Python no ofrecía nada similar al Declaración de los lenguajes JVM anteriores. A partir de la versión 3.10, ofrece la misma capacidad de una manera elegante: 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 curso evalúa el de la misma manera que en los idiomas JVM. case El Pattern Matching de Rust El enfoque de Rust para la gestión de la memoria no juega bien con los tipos de comprobación.En resumen, Rust ofrece dos conceptos básicos: 
 
 
 
 
 Las estructuras son portadores de datos estructurados; su tamaño de memoria se conoce en el momento de la compilación. Características son contratos, similares a las interfaces Puede proporcionar una implementación de un rasgo para una estructura Dado que la referencia puede apuntar a estructuras de diferentes tamaños, el compilador no puede conocer su tamaño en el momento de la compilación y debe colocar la variable en el montón en lugar de la pila. He intentado portar el código original a Rust uno a uno para fines educativos. El Java original no aprovecha el polimorfismo; no es grande. En Rust, es aún más feo. Es interesante darse cuenta de que aunque Rust no es un lenguaje de programación orientado a objetos, te lleva a usar el polimorfismo. ¡Advertencia: No recomiendo el siguiente código y negaré cualquier asociación con él! 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 tipo de Rust no ofrece una manera de obtener el tipo de una variable. Implementar la función para estructuras Competición sobre el tipo de estructura subyacente Compruebe el tipo Descargar a la estructura subyacente para utilizar sus campos Este puerto de código artificial de arriba representa erróneamente las capacidades de correspondencia de patrones de Rust. . Muchos lugares Conclusión Entre todos los idiomas descritos en el post, Scala fue el primero en proporcionar el ajuste de patrones en Durante muchos años, fue el Graal que otros trataron de alcanzar; Kotlin y Java han llegado finalmente a esta etapa. switch Outside of the JVM, Python and Rust feature powerful pattern-matching capabilities. Con la destrucción, el ajuste de patrones es una gran ayuda para los desarrolladores que desean escribir código legible y mantenible. El código fuente completo de este artículo se puede encontrar en . En GitHub To go further: 
 
 
 
 
 
 Desarrollo de aplicaciones en Java 23 Pattern matching en Kotlin Punto de encuentro en Scala Declaración de juego en Python Pattern matching en Rust Originally published at   on July 20th, 2025 A Java Geek El nuevo Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Este audio es producido en el idioma original de la historia!

Comparación de Pattern-Matching entre diferentes lenguajes: Java, Scala y más

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps