En el desarrollo para HarmonyOS Next, la coincidencia de patrones es una característica poderosa que permite ejecutar lógica diferente según condiciones específicas. La expresión when y las guardias de tipo son fundamentales en este proceso. A continuación se detallan sus aplicaciones, funcionalidades y principios de optimización.

Capítulo 1: Coincidencia básica

La expresión when permite realizar coincidencia de valores, siendo especialmente útil para tipos de enumeración. Consideremos un ejemplo con una enumeración que representa formas geométricas:

enum Forma {
    case circulo
    case rectangulo
    case triangulo
}

La expresión when facilita la desestructuración de valores de enumeración y la ejecución de operaciones específicas:

let figura: Forma = .circulo
when (figura) {
    case .circulo:
        print("Es un círculo")
    case .rectangulo:
        print("Es un rectángulo")
    case .triangulo:
        print("Es un triángulo")
    default:
        print("Tipo de figura desconocido")
}

Adicionalmente, la expresión when admite el uso del comodín _ para coincidir con cualquier valor. En el procesamiento de arrays heterogéneos:

let elementosMixtos: [Any] = [1, "texto", 3.14]
for elemento in elementosMixtos {
    when (elemento) {
        is Int:
            print("Entero: $elemento as! Int)")
        is String:
            print("Cadena: $elemento as! String)")
        _:
            print("Elemento de otro tipo")
    }
}

El comodín _ permite manejar tipos distintos a Int y String, aumentando la versatilidad del código.

Capítulo 2: Conversión inteligente

Las guardias de tipo permiten verificar y convertir tipos en tiempo de ejecución. Tras una verificación is, el compilador estrecha el tipo de la varialbe. Ejemplo:

func mostrarLongitud(valor: Any) {
    if valor is String {
        let texto = valor as! String
        print("Longitud de cadena: $texto.count)")
    }
}

En este caso, la guardia valor is String garantiza que valor sea tratado como String dentro del bloque if, evitando errores de conversión.

La combinación con expresiones when permite lógica más compleja, como el manejo de valores numéricos:

let cantidad: Any = 3.14
when (cantidad) {
    is Int:
        let valorEntero = cantidad as! Int
        print("Entero: $valorEntero)")
    is Double:
        let valorDecimal = cantidad as! Double
        print("Decimal: $valorDecimal)")
}

Esta estructura promueve código claro y adaptable al tipo real de la varible.

Capítulo 3: Optimización de rendimiento

El compilador genera tablas de salto (jump tables) para optimizar expresiones when. Estas estructuras permiten saltar directamente al bloque correspondiente sin evaluar condiciones secuencialmente.

Ejemplo con una eunmeración amplia:

enum Fruta {
    case manzana
    case plátano
    case cereza
    // Más opciones...
    case naranja
}
let miFruta: Fruta = .plátano
when (miFruta) {
    case .manzana:
        print("Es una manzana")
    case .plátano:
        print("Es un plátano")
    // Más casos...
    case .naranja:
        print("Es una naranja")
}

Si los valores de la enumeración son secuenciales, la tabla de salto usa índices para localizar rápidamente el bloque objetivo, mejorando significativamente el rendimiento. Esta optimización mantiene la eficiencia incluso en lógicas complejas de coincidencia.