Dans le développement sous HarmonyOS Next, les expressions conditionnelles en langage Cangjie sont essentielles pour implémenter les branches logiques du programme. L'expression if et le mécanisme de correspondance de motifs se complètent pour offrir aux développeurs une flexibilité et un pouvoir considérables.

Structure de base de if

Différences entre vérification forte des types et conversions implicites en C

Les expressions if en Cangjie imposent une vérification stricte des types lors des jugements conditionnels, contrairement aux conversions implicites en C. En C, les entiers, flottants, etc., peuvent être convertis implicitement en valeurs booléennes ; les valeurs non nulles sont généralement traitées comme true, tandis que zéro est false. Par exemple :

int num = 5;
if (num) {
    // Bloc exécuté
}

En revanche, en Cangjie, la condition d'une expression if doit être de type booléen, sans possibilité de conversion implictie depuis des entiers ou des flottants. Le code suivant provoquerait une erreur de compilation en Cangjie :

fonction_principale() {
    var valeur = 1
    si (valeur) { // Erreur : types incompatibles
        afficher("Valeur non nulle")
    }
}

Cette vérification stricte des types peut ajouter des contraintes lors de l'écriture du code mais permet de détecter les erreurs de type à la compilation, améliorant ainsi la fiabilité et la stabilité du code. Dans les grands projets, ce mécanisme de détection précoce évite de nombreux bugs potentiels à l'exécution, réduisant les coûts de maintenance.

Chaînes conditionnelles multiples

Optimisation des jugements sur les vitesses cosmiques

Dans le développement pratique, il est courant de rencontrer des scénarios nécessitant plusieurs niveaux de jugement conditionnel. Prenons l'exemple des vitesses cosmiques. Voici un code original :

import std.aleatoire.*
fonction_principale() {
    var vitesse = Aleatoire().prochainFloat64() * 20.0
    afficher("${vitesse} km/s")
    si (vitesse > 16.7) {
        afficher("Troisième vitesse cosmique, rencontre céleste")
    } sinon {
        si (vitesse > 11.2) {
            afficher("Deuxième vitesse cosmique, voyage vers la lune")
        } sinon {
            si (vitesse > 7.9) {
                afficher("Première vitesse cosmique, envolée magique")
            } sinon {
                afficher("Pieds sur terre, regard vers les étoiles")
            }
        }
    }
}

Cette structure imbriquée est fonctionnelle mais peu lisible. Utiliser la forme "sinon_si" en Cangjie améliore la lisibilité :

import std.aleatoire.*
fonction_principale() {
    var vitesse = Aleatoire().prochainFloat64() * 20.0
    afficher("${vitesse} km/s")
    si (vitesse > 16.7) {
        afficher("Troisième vitesse cosmique, rencontre céleste")
    } sinon_si (vitesse > 11.2) {
        afficher("Deuxième vitesse cosmique, voyage vers la lune")
    } sinon_si (vitesse > 7.9) {
        afficher("Première vitesse cosmique, envolée magique")
    } sinon {
        afficher("Pieds sur terre, regard vers les étoiles")
    }
}

Le code optimisé est plus clair et chaque branche conditionnelle est facilement compréhensible, facilitant modifications et extensions ultérieures.

Mécanisme de déduction de type

Exemple de déduction automatique du type parent commun minimal

Les expressions if en Cangjie ont un mécanisme unique de déduction de type. Si elles servent à initialiser une variable, leur type est déduit comme le type parent commun minimal des blocs de code des différentes branches. Par exemple :

fonction_principale() {
    var zero: Int8 = 0
    var un: Int8 = 1
    var tension = 5.0
    var bit = si (tension < 2.5) {
        zero
    } sinon {
        un
    }
}

Ici, les deux branches ont le type Int8, donc bit est également de type Int8. Si les types diffèrent :

fonction_principale() {
    var tension = 5.0
    var resultat = si (tension < 2.5) {
        "Basse tension"
    } sinon {
        1
    }
}

Comme "Basse tension" est de type String et 1 de type Int, sans parent commun, une erreur de compilation survient. Comprendre ce mécanisme aide à gérer précisément les types des variables, évitant les erreurs liées aux types et augmentant la simplicité et la lisibilité du code.