Simplificación binaria del juicio de múltiples condiciones

Introducción

Cuando se juzgan múltiples condiciones al mismo tiempo, y cada condición puede afectar el resultado, si el if-else se juzga directamente, es particularmente fácil confundirse y cometer errores en la interpretación.

Podemos considerar cada bit como un valor bool según las características de los datos binarios.

Si desea juzgar si es cierto en la combinación de cuatro condiciones, puede usar cada condición como un bit en binario y numerarlo de derecha a izquierda.

Las cuatro condiciones son a, b, c, d, correspondientes a los últimos 4 dígitos de derecha a izquierda, para luego guardar los valores correspondientes en variables, tales como:

a=verdadero, b=falso, c=verdadero, d=verdadero, el binario obtenido es: resultado=1011

Cuando es necesario juzgar que a, c y d son verdaderas, se puede simplificar como:

if(result & 11 == 11) //todo
//or 转为10进制
if(parseInt("result",2) == 11) //todo

En el caso de n condiciones combinadas, y así sucesivamente.

Código

Realización de la operación de desplazamiento

function conditionValue1(datas: (string | boolean | number)[]): number {
    
    
    let n = 0;
    let strs: string[] = [];
    datas.reverse().forEach((value, index) => {
    
    
        const yes = value && value == "1";
        strs.push(yes ? "1" : "0");
        n += Math.pow(2, index) >> (yes ? 0 : index + 1);
    });
    console.log(strs);
    return n;
}

//测试
console.log(conditionValue1(["1", "0", 1, 0, true, false]));
//结果
101010;
42;

Implementación de concatenación de cadenas

function conditionValue2(datas: (string | boolean | number)[]): number {
    
    
    let n = "";
    datas.forEach((value, index) => {
    
    
        const yes = value && value == "1";
        n += yes ? "1" : "0";
    });
    console.log(n);
    return parseInt(n, 2);
}

//测试
console.log(conditionValue2(["1", "0", 1, 0, true, false]));
//结果
101010;
42;

ejemplo

Supongamos que tenemos la siguiente tabla de juicio:

	1	2	3	4	5	6	7	8
romper de antemano	norte	norte	norte	norte	Y	Y	Y	Y
Recompensa del último ciclo > 0	norte	Y	norte	Y	norte	Y	norte	Y
Recompensas para este ciclo > 0	norte	norte	Y	Y	norte	norte	Y	Y
resultado	Recibir (gris)	Recibir (brillante)	Recibir (gris)	Recibir (brillante)	romper (ceniza)	Recibir (brillante)	romper (brillante)	Recibir (brillante)
acción	ninguno	Recibir premio	ninguno	Recibir premio	ninguno	Recibir premio	aplastar recompensa	Recibir premio

Se puede ver en la tabla:

1. Condición a = si romper por adelantado
2. Condición b = recompensa del último ciclo > 0
3. Condición c=Recompensa de este ciclo>0

En el caso de una tabla de juicio clara, podemos generar fácilmente el siguiente código.

private initBtnType() {
    
    
        if (this._confData) {
    
    
            const a = this._confData.early_break_status;
            const b = this._confData.previous_rebate_amount > 0;
            const c = this._confData.current_rebate_amount > 0;
            const result = this.conditionValue([a, b, c]);
            switch (result + 1) {
    
    
                case 2:
                case 4:
                case 6:
                case 8:
                    //领取（亮）
                    break;
                case 7:
                    //打碎（亮）
                    break;
                case 5:
                    //打碎（灰）
                    break;
                default:
                    //领取（灰）
                    break;
            }
        }
    }

Resumir

1. Este método de código no es legible y no es amigable para aquellos que se harán cargo del trabajo más adelante.
2. Por lo tanto, se requiere una tabla de juicio lógica y clara antes del diseño.
3. Cuantas más condiciones de juicio haya, más conveniente es este código, y las dos condiciones no son necesarias.