web-dev-qa-db-fra.com

L'instruction SWITCH et CASE est-elle prise en charge dans APEX dans Salesforce?

Au lieu de cette structure de base avec IF/THEN/ELSEIF/ELSE

int month = 8;
String monthString;
if (month == 1) {
    monthString = "January";
} else if (month == 2) {
    monthString = "February";
}
...  // and so on

ce serait bien d'avoir 

    int month = 8;
    String monthString;
    switch (month) {
        case 1:  monthString = "January";
                 break;
        case 2:  monthString = "February";
                 break;

        ..... // and so on

        case 12: monthString = "December";
                 break;
        default: monthString = "Invalid month";
                 break;
    }

Cela améliorerait la lisibilité et faciliterait le débogage grâce à la clarté de l'intention.

salesforceapex
12
David W Grigsby

2018 - Ouais !!!! - Si Finally est - De bonnes nouvelles - Switch maintenant supporté Passer à l'heure exacte en vidéo sur YouTube de la session au moment d'or

2014 - Pas pour le moment malheureusement. J'attendais cette fonctionnalité depuis 2009 et elle est très demandée par le lien de la communauté ci-dessous.

Ajouter une déclaration "Switch" ou "Case" à Apex

13
David W Grigsby
    monthMap = new Map<Integer,String>();
    monthMap.put(1,'JAN');
    monthMap.put(2,'FEB');
    monthMap.put(3,'MAR');
    monthMap.put(4,'APR');
    monthMap.put(5,'MAY');
    monthMap.put(6,'JUN');
    monthMap.put(7,'JUL');
    monthMap.put(8,'AUG');
    monthMap.put(9,'SEP');
    monthMap.put(10,'OCT');
    monthMap.put(11,'NOV');
    monthMap.put(12,'DEC');

Ensuite, faites un get en fonction de la valeur de votre mois entier.

Pas besoin d'écrire un gros si-sinon.

9
Avijit Chakraborty

La prise en charge des instructions switch arrive pour Apex dans la version Summer '18.

Tiré de la session TrailheadX 2018 Commutation avec Apex :

 enter image description here

Initialement, il supportera Enums, String, Integer et Long

4
Daniel Ballinger

J'ai ajouté mes commentaires à d'autres réponses. 

Bien que celui-ci ne réponde pas vraiment à la question, je pense toujours que c'est une bonne idée de la jeter ici. Je déteste voir de telles "bibliothèques de date maison" ...

DateTime someDate = System.now();
System.debug(someDate.format('MMM'));  // Jan, Feb etc.
System.debug(someDate.format('MMMM')); // January, February etc.

Ce sera toujours en anglais, même si la langue choisie par l'utilisateur actuel est différente. La chaîne de formatage est transmise à la méthode Java interne. Il suffit donc de jeter un coup d’œil rapide sur http://docs.Oracle.com/javase/6/docs/api/Java/text/SimpleDateFormat.html

3
eyescream

Pendant ce temps, SFDC fournit un moteur natif, vous pouvez utiliser une "infrastructure" de petit utilitaire comme "instruction" orientée objet dans un cas de commutation:

Utilitaire Switch-Case

Exemple d'utilisation:

public with sharing class SwitchCaseExample {

    public String result {get; set;}

    public static final String MSG_FROM_ACTION_1 = 'invoke action 1';
    public static final String MSG_FROM_ACTION_2 = 'invoke action 2';
    public static final String MSG_FROM_ACTION_3 = 'invoke action 3';
    public static final String MSG_FROM_ACTION_4 = 'invoke action 4';

    public void testSwitchCase(String value) {

        SwitchCaseHelper sch = new SwitchCaseHelper();  

        sch.switch(value)
            .case('value1', new Action1(this), SwitchCaseHelper.PUT_BREAK)
            .case('value2', new Action2(this), SwitchCaseHelper.PUT_CONTINUE)
            .case('value3', new Action3(this), SwitchCaseHelper.PUT_BREAK)
            .default(new Action4(this));
    }


    private class Action1 implements ActionContainer {

        private SwitchCaseExample outerCtx;

        public Action1(SwitchCaseExample outerCtx) {

            this.outerCtx = outerCtx;
        }

        public String doAction() {

            outerCtx.result = MSG_FROM_ACTION_1;
            return null; 
        }
    }

    private class Action2 implements ActionContainer {

        private SwitchCaseExample outerCtx;

        public Action2(SwitchCaseExample outerCtx) {

            this.outerCtx = outerCtx;
        }

        public String doAction() {

            outerCtx.result = MSG_FROM_ACTION_2;
            return null; 
        }
    }

    private class Action3 implements ActionContainer {

        private SwitchCaseExample outerCtx;

        public Action3(SwitchCaseExample outerCtx) {

            this.outerCtx = outerCtx;
        }

        public String doAction() {

            outerCtx.result = MSG_FROM_ACTION_3;
            return null; 
        }
    }

    private class Action4 implements ActionContainer {

        private SwitchCaseExample outerCtx;

        public Action4(SwitchCaseExample outerCtx) {

            this.outerCtx = outerCtx;
        }

        public String doAction() {

            outerCtx.result = MSG_FROM_ACTION_4;
            return null; 
        }
    }

}

Interface:

public interface ActionContainer {

    String doAction();

}

Et implémentation de logique d'interrupteur

public with sharing class SwitchCaseHelper {

    public static final Boolean PUT_BREAK = true;
    public static final Boolean PUT_CONTINUE = false;

    public class SwitchCaseException extends Exception {}

    public static final String EXCEPTION_MESSAGE = 'Switch-Case construction must have one (and only one) "switch" statement';

    @TestVisible
    private Object switchOperand;

    @TestVisible
    private Boolean isCaseAfterBreakStatement;

    @TestVisible
    private Boolean isPreviousSwitch;

    public SwitchCaseHelper() {

        isCaseAfterBreakStatement = false;
    }

    public SwitchCaseHelper switch(Object switchOperand) {

        if (isPreviousSwitch != null) {
            throw new SwitchCaseException(EXCEPTION_MESSAGE);
        }
        isPreviousSwitch = true;
        this.switchOperand = switchOperand;
        return this;
    }

    public SwitchCaseHelper case(Object caseOperand, ActionContainer container, Boolean hasBreak) {

        if (isPreviousSwitch == null) {
            throw new SwitchCaseException(EXCEPTION_MESSAGE);
        }

        if (isPreviousSwitch) {
            isPreviousSwitch = false;
        }

        if (isCaseAfterBreakStatement) {
            return this;
        }

        if (switchOperand.equals(caseOperand)) {
            container.doAction();
            isCaseAfterBreakStatement = hasBreak;
        }

        return this;
    }

    public SwitchCaseHelper default(ActionContainer container) {

        if (isPreviousSwitch == null) {
            throw new SwitchCaseException(EXCEPTION_MESSAGE);
        }

        if (!isCaseAfterBreakStatement) {
            container.doAction();
        }
        return this;
    }
}
2
Vladimir

Apex prend désormais en charge les instructions Switch (à partir de la version Summer '18):

Réponse complète ici: https://success.salesforce.com/answers?id=90630000000wkANAAY

via Notes de version: 

Où: Cette modification s'applique à Lightning Experience et Salesforce Classic dans les éditions Enterprise, Performance, Unlimited et Developer.

How: La syntaxe est la suivante:

switch on expression {
    when value1 {       // when block 1
        // code block 1
    }   
    when value2 {       // when block 2
        // code block 2
    }
    when value3 {       // when block 3
        // code block 3
    }
    when else {       // when else block, optional
        // code block 4
    }
}

PS: Ajout ici pour référence future.

0
Vitap Ramdevputra