Una gran función de transferencia o separada en múltiples funciones

¿Es mejor mantener toda la lógica dentro de la función de transferencia o separarla en 3 funciones como hice yo? ¡Gracias de antemano!

function transfer(address _to, uint256 _value) public returns (bool) {

    require(_to != address(0));
    if (updateBalance(_to, _value)) { 
        if(allowedContracts[_to]) {
            BIHReceiver receiver = BIHReceiver(_to);
            receiver.tokenFallback(msg.sender,_value);
        }
        Transfer(msg.sender, _to, (_value.sub(feePaid)));
        Transfer(msg.sender, feeWallet, (feePaid));
    }
    return true;
}


function updateBalance(address _to, uint256 _value) public returns (bool) {

    require(_to != address(0));
    if (checkBalance(_to,_value)) {
        uint256 feePaid = (_value.mul(fee).div(10000);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value.sub(feePaid));
        balances[feeWallet] = balances[feeWallet].add(feePaid);
        return true;
    }
} 

function checkBalance(address _to, uint256 _value) public returns (bool) {

    require(_to != address(0));
    if(_value > 0) {
        if(balances[msg.sender] == 0) {
            addresses[indexes[msg.sender]] = addresses[lastIndex];
            indexes[addresses[lastIndex]] = indexes[msg.sender];
            indexes[msg.sender] = 0;
            delete addresses[lastIndex];
            lastIndex--;
        }
        if(indexes[_to]==0) {
            lastIndex++;
            addresses[lastIndex] = _to;
            indexes[_to] = lastIndex;
        }
        return false;
    } else {
        return true; 
    }
}

Respuestas (1)

En general, los desarrolladores suelen hacer que las funciones sean cortas y simples con una responsabilidad limitada por razones que incluyen (pero no se limitan a):

  1. aumenta la legibilidad, lo que hace que sea más fácil seguir la intención
  2. es más fácil probar funciones con menos efectos secundarios
  3. es más fácil mantenerse SECO y evitar errores potencialmente catastróficos derivados de pequeñas diferencias en lo que debería ser el mismo código

Diría que se distribuye en varias funciones.