Let's say that initially, we have a complex data processing function designed to operate on an array of objects, applying a transformation that converts all string values within the objects to uppercase. Here's the initial version:
type Item = { [key: string]: any };
function processData(items: Item[]): void {
const processedItems = items.map(item => {
const processedItem: Item = {};
for (const key in item) {
processedItem[key] = typeof item[key] === 'string' ? item[key].toUpperCase() : item[key];
}
return processedItem;
});
processedItems.slice(0, 3).forEach(item => console.log(`Processed Item: ${JSON.stringify(item)}`));
}
// Default behavior - convert string values to uppercase
processData([{ name: "apple", quantity: 10 }, { name: "orange", quantity: 5 }]);
We intend to expand this function, adding capabilities to filter the items based on a condition and allowing for custom transformations. The aim is to retain backward compatibility while introducing these enhancements. Here's the updated approach:
type ConditionFunction = (item: Item) => boolean;
type TransformFunction = (item: Item) => Item;
function processData(
items: Item[],
condition: ConditionFunction = () => true,
transform: TransformFunction | null = null
): void {
const processedItems = items.reduce<Item[]>((acc, item) => {
if (condition(item)) {
let processedItem: Item;
if (transform) {
processedItem = transform(item);
} else {
processedItem = {};
for (const key in item) {
processedItem[key] = typeof item[key] === 'string' ? item[key].toUpperCase() : item[key];
}
}
acc.push(processedItem);
}
return acc;
}, []);
processedItems.slice(0, 3).forEach(item => console.log(`Processed Item: ${JSON.stringify(item)}`));
}
// Default behavior - convert string values to uppercase
processData([{ name: "apple", quantity: 10 }, { name: "orange", quantity: 5 }]);
// Custom filter - select items with a quantity greater than 5
processData(
[{ name: "apple", quantity: 10 }, { name: "orange", quantity: 5 }],
item => item.quantity > 5
);
// Custom transformation - convert names to uppercase and multiply the quantity by 2
const customTransform: TransformFunction = item => {
const transformedItem: Item = {};
for (const key in item) {
transformedItem[key] = key === "name" ? item[key].toUpperCase() : item[key] * 2;
}
return transformedItem;
};
processData(
[{ name: "apple", quantity: 10 }, { name: "orange", quantity: 5 }],
() => true,
customTransform
);
In the evolved version, we've introduced two optional parameters: condition, a function to filter the input array based on a given condition, and transform, a function for custom transformations of the filtered items. The default behavior processes all items, converting string values to uppercase, which ensures that the original function's behavior is maintained for existing code paths. This robust enhancement strategy facilitates adding new features to a function with significant complexity while preserving backward compatibility, showcasing an advanced application of evolving software capabilities responsibly.
