A mintamegfelelés a szoftverfejlesztés egyik fő jellemzője.Míg a mintamegfelelés több helyen is alkalmazható, jelenlegi használata a Szeretném összehasonlítani a minták összehasonlításának erejét néhány olyan programozási nyelven, amelyekkel ebben a bejegyzésben ismerős vagyok. switch case Úgy gondolom, hogy minden olvasó ismeri a Szintaxis örökölt C. Röviden: switch case 
 
 
 
 
 A switch záradék egy értékvisszafizetési nyilatkozatra utal. Minden esettanulmányi záradék egy másik kijelentést állít fel; ha az érték megfelel a kijelentésnek, akkor végrehajtja a kapcsolódó blokkot. Az első feltétel, amely egyezik, a blokkját végrehajtja. A C-ben az esettanulmányok esettanulmányok; kifejezetten meg kell szakítani, hogy elkerülje a kapcsolót, különben a következő esetet értékelik Java szabványok összehangolása Kezdjük a Java-val, mivel ez volt az első programozási nyelv, amelyet professzionális környezetben használtam. A Java mintamegfelelése sokat fejlődött a verziókon át. Itt van a „hivatalos” minta a 23. verzióhoz, enyhén módosítva. A végrehajtás és a módszer, hogy értékelje a periméter. ez határozottan Jó példa az objektumorientált programozásra. 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");
        };
    }
}
 
 
 
 
 
 
 Az alakzat paramétere, mint s Értékelje, hogy s egy téglalap, és hogy a téglalap egy négyzet Értékelje, hogy s egy téglalap Értékelje, hogy a s egy kör Ha az előző bekezdések egyike sem egyezik meg, az alapértelmezett kivétel Ez a Java verzió lesz a kiindulópontunk. Az új rendszer jellemzői szintaxis váltó váltó Az új szintaxisnak van néhány előnye az örökletes nem-nyilakkal szemben Az öröklődő c. switch C stílus A fentiek a fentiekből következnek: a futtatás után a Blokk, fut a következő blokkolás. annak elkerülése érdekében be kell állítania egy A nem olyan jó régi időkben egyes fejlesztők kihasználták ezt a funkciót, hogy elkerüljék a kód duplikációját. case case case break A tapasztalatok azonban azt mutatják, hogy túl sok a potenciális hibák oka: a modern kódolási gyakorlatok hajlamosak elkerülni. Az új nyilak szintaxisával a futási idő csak a megfelelő A blokk. break case C stílus A klauzulák csak egyszerű értékeket értékelnek. A közösség a Java 7-et óriási előnyként ünnepelte, amikor lehetővé tette a String értékeket. A Java 21 még tovább ment: a nyilak szintaxisával párosulva lehetővé tette a típusok váltását. A típus. case Shape Ezenkívül, ha az osztályok váltakoznak Ha az osztály hierarchia , a kompilátor automatikusan észleli a hiányzó eseteket. Végül a 24. verzió hozzáadta az opcionális A szűrő. és sealed when A fordított oldalon, a régi C szintaxisban a futási idő közvetlenül a helyes Az új nyilak szintaxis szekvenciálisan értékeli őket, pontosan úgy, mint ha A nyilatkozatok. case if else A következő szakaszokban a kódot más nyelvekre portáljuk. A Scala mintázata A Scala mintamegfelelése a kezdetektől fogva nem más, Kotlin sok inspirációt szerzett belőle. 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
  }
}
 
 
 
 
 
 
 
 Használja az S hivatkozást közvetlenül Értékelje, hogy s egy téglalap, és hogy a téglalap egy négyzet A Scala kiegészíti az osztály tulajdonságait Értékelje, hogy s egy téglalap Értékelje, hogy a s egy kör Ha az előző bekezdések egyike sem egyezik meg, az alapértelmezett kivétel Kotlin mintázata Fordítsuk le a Java kódját a Kotlin-re. Aktiválja a   Az összeállításban leírt . Muszáj kísérleti Xwhen-guards Szilveszter 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
    }
}
 
 
 
 
 
 
 Az alakzat paramétere, mint s Értékelje, hogy s egy téglalap, és hogy a téglalap szélessége egyenlő-e magasságával. Értékelje, hogy s egy téglalap Értékelje, hogy a s egy kör Ha az előző bekezdések egyike sem egyezik meg, az alapértelmezett kivétel Kotlin mintázata nagyon hasonlít a Java-ra, enyhe szintaxisváltozásokkal. az , helyettesítő . Az e.g if when A Kotlin vs. Java összehasonlító evolúciója a mintamegfelelésben meglehetősen megvilágító. A Java lemaradt a hagyományos C szintaxis mögött, míg a Kotlin már a kezdetektől fogva megegyezhetett a beton típusokkal. 2020-ban a Java 14 csökkentette a nyíl operátorral való szakadékot; egy évvel később a Java 16 teljesen lezárta a szakadékot a beton típusokkal való megegyezés képességével. A záradék. when A Kotlin kísérleti jellege Ez azt jelenti, hogy a Java meghaladta a Java-t – legalábbis ezen a területen! if Python szabványok összehasonlítása Korábban a Python nem kínált semmi hasonlót a a fenti JVM nyelvek nyilatkozata. a 3.10-es verzióból elegáns módon ugyanazt a képességet kínálja: 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")
 A futamidő értékelése a A szövegek szekvenciálisak, mint a JVM nyelvekben. case Rust's Pattern összehasonlítás A Rust megközelítése a memóriakezeléshez nem játszik jól a vizsgálati típusokkal. röviden, a Rust két alapkoncepciót kínál: 
 
 
 
 
 A struktúrák strukturált adattartók; memóriájuk mérete a kompilálás idején ismert. A tulajdonságok szerződések, hasonlóan az interfészekhez Egy struktúrára vonatkozó funkció végrehajtását biztosíthatja Mivel a hivatkozás különböző méretű struktúrákra utalhat, a kompilátor nem tudja a méretét a kompilálás idején, és a változót a halom helyett a halomra kell helyeznie. Az eredeti Java nem használja ki a polimorfizmust; nem nagyszerű. A Rust-ban még csúnyabb. Érdekes felismerni, hogy míg a Rust nem objektumorientált programozási nyelv, polimorfizmust használ. Figyelmeztetés: Nem ajánlom a következő kódot, és tagadom a vele való bármilyen kapcsolatot! 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!()
    }
}
 
 
 
 
 
 
 A Rust típusrendszere nem kínál módot a változó típusának megszerzésére. ehhez egy dedikált funkciót kell létrehoznunk. A struktúrák funkciójának végrehajtása Összehasonlítás az alapul szolgáló szerkezet típusával Ellenőrizze a típusát Letöltés a mögöttes struktúrába, hogy használja a mezőket A fenti mesterséges kódport tévesen ábrázolja a Rust mintamegfelelő képességeit. . Sok helyszín következtetés A posztban leírt összes nyelv közül a Scala volt az első, amely szabványmegfelelést biztosított a Sok éven át ez volt a Grál, amit mások megpróbáltak elérni; Kotlin és Java végre elérte ezt a szakaszt. switch A JVM-en kívül a Python és a Rust erőteljes mintamegfelelési képességekkel rendelkezik. A szerkezetátalakítással a mintamegfelelés hatalmas segítség azoknak a fejlesztőknek, akik olvasható és karbantartható kódot akarnak írni. A cikk teljes forráskódja megtalálható a . A GitHub To go further: 
 
 
 
 
 
 Javaslatok a Java 23 használatához Párbeszéd Kotlinban Párbeszéd a Scala-ban Játékleírás Pythonban Párbeszéd a nyugalomban Eredetileg megjelent A Java Geek július 20, 2025 Egy Java Geek

Read all my posts!

Read My Stories

Follow @nicolas_frankel on Twitter

Ez a hanganyag a történet eredeti nyelvén készült!

Különböző nyelvek mintázatainak összehasonlítása: Java, Scala és több

About Author

HOZZÁSZÓLÁSOK

HANG TAGOK

EZT A CIKKET BEMUTATTA

Related Stories

Of The First and Last Things: Part 1

And now the important day of the election had arrived

INTRODUCTION

Of The First and Last Things: Part 3

Of The First and Last Things: Part 1

And now the important day of the election had arrived

INTRODUCTION

Of The First and Last Things: Part 3

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps