Refactoring many nested ifs or chained if statements

I have an object with large number of similar fields (like more than 10 of them) and I have to assign them values from an array of variable length. The solution would be either a huge nested bunch of ifs based on checking length of array each time and assigning each field

OR

a chain of ifs checking on whether the length is out of bounds and assigning each time after that check.开发者_如何学JAVA

Both seem to be repetitive. Is there a better solution ?

If you language has switch/case with fallthrough, you could do it like this:

switch(array.length){
    case 15: field14 = array[14];
    case 14: field13 = array[13];
    case 13: field12 = array[12];
    // etc.
    case 1: field0 = array[0];
    case 0: break;
    default: throw Exception("array too long!");
}

for (int i = 0; i < fieldCount; i++)
    fields[i].value = array[i];

That is to say, maintain an array of fields that corresponds to your array of values.

If your language supports delegates, anonymous functions, that sort of thing, you can use those to clean it up. For example, in C# you could write this:

string[] values = GetValues();
SomeObject result = new SomeObject();
Apply(values, 0, v => result.ID = v);
Apply(values, 1, v => result.FirstName = v);
Apply(values, 2, v => result.LastName = v);
// etc.

The apply method would look like:

void Apply(string[] values, int index, Action<string> action)
{
    if (index < values.Length)
        action(values[index]);
}

This is obviously language-dependent, but something to think about regardless.

Another very simple option that we might be overlooking is, if you are actually trying to initialize an object from this value array (as opposed to update an existing object), to just accept the default values if the array isn't large enough.

C# example:

void CreateMyObject(object[] values)
{
    MyObject o = new MyObject();
    o.ID = GetValueOrDefault<int>(values, 0);
    o.FirstName = GetValueOrDefault<string>(values, 0);
    o.LastName = GetValueOrDefault<string>(values, 0);
    // etc.
}

void GetValueOrDefault<T>(object[] values, int index)
{
    if (index < values.Length)
        return (T)values[index];
    return default(T);
}

Sometimes the dumb solution is the smartest choice.

If your fields are declared in the same order of the array's elements, you could use reflection (if available in your language) to set these values. Here is an example of how you could do it in Java:

// obj is your object, values is the array of values
Field[] fields = obj.getClass().getFields();
for (int i = 0; i < fields.length && i < values.length; ++i) {
    fields[i].set(obj, values[i]);
}