es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo evalúo y capturo una función para su uso posterior en un bucle?

06 Aug, 2023 Programación

Tengo la siguiente función:

pub fn generate_mock_balances(interval: &Interval, n: &i32) -> Vec<historicbalance> {
    let time = Utc::now();
    let ticks = (1..*n).map(|v| v as i64);
    let mut mocks = vec![];

    for tick in ticks {
        let historic_time = match interval {
            Interval::Hour => time - Duration::minutes(tick),
            Interval::Day => time - Duration::hours(tick),
            Interval::Week => time - Duration::days(tick),
            Interval::Month => time - Duration::weeks(tick),
            Interval::Year => time - Duration::weeks(4 * tick),
        };

        mocks.push(HistoricBalance {
            time: historic_time.timestamp().to_string(),
            balance: (1499 * tick).to_string(),
        });
    }

    mocks
}

Siento que el “switch case” dentro del bucle no es eficiente y que debe haber una manera de seleccionar la función de Duration adecuada una vez y almacenarla para usarla en el bucle, en lugar de hacer la comprobación en cada iteración del bucle.

He echado un vistazo a la documentación de cierres y, aunque instintivamente siento que es el camino a seguir, parece más adecuado para acelerar cálculos lentos almacenando el resultado de dicho cálculo para reutilizarlo. ¿Cómo hago esto?

Tags:  

Answer

  1. Avatar for davy.ai
    davy.ai

    Puedes almacenar la función Duration adecuada en una variable antes del bucle y utilizarla dentro del bucle. Aquí tienes un ejemplo:

    pub fn generate_mock_balances(interval: &Interval, n: &i32) -> Vec<historicbalance> {
    let time = Utc::now();
    let duration_fn = match interval {
        Interval::Hour => Duration::minutes,
        Interval::Day => Duration::hours,
        Interval::Week => Duration::days,
        Interval::Month => Duration::weeks,
        Interval::Year => |semanas| Duration::weeks(4 * semanas),
    };
    let ticks = (1..*n).map(|v| v as i64);
    let mut mocks = vec![];

    for tick in ticks {
        let historic_time = time - duration_fn(tick);

        mocks.push(HistoricBalance {
            time: historic_time.timestamp().to_string(),
            balance: (1499 * tick).to_string(),
        });
    }

    mocks
}

    En este ejemplo, almacenamos la función Duration adecuada en la variable duration_fn utilizando una expresión match para los casos del enum Interval, y un cierre para el caso Year porque requiere un cálculo adicional. Luego, dentro del bucle, llamamos a duration_fn con el valor tick para calcular la duración adecuada para esa iteración. De esta manera, solo necesitamos hacer la comprobación una vez en lugar de en cada iteración.

Comments are closed.