⚡️ Speed up function removeSpecialChars by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for removeSpecialChars in app/client/src/widgets/TableWidgetV2/widget/utilities.ts

⏱️ Runtime : 329 microseconds → 306 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 7% runtime improvement by replacing the split().join() pattern with a single replace() call and adding the global flag g to the regex.

Key Performance Improvements:

1. Single-pass regex replacement: The original code used split(separatorRegex).join("_"), which creates an intermediate array of substrings and then reconstructs the string. The optimized version uses replace(separatorRegex, "_") with the global flag, which performs the transformation in a single pass without allocating intermediate data structures.

2. Reduced memory allocations: By eliminating the array allocation from split(), the optimized version reduces garbage collection pressure, especially beneficial for strings with many special characters.

3. Algorithmic efficiency: String replace() with a global regex is optimized at the JavaScript engine level to be faster than split/join for this use case, as it avoids the overhead of array manipulation.

Test Results Analysis:

The optimization shows varying improvements across different input patterns:

• Best performance gains (60-146% faster): Strings with multiple special characters or spaces benefit most (e.g., "hello world test", "user_email_com") because they avoid creating large intermediate arrays.

• Moderate gains (7-45% faster): Large inputs with repeated patterns show consistent improvements due to reduced memory allocations.

• Slight regressions (2-25% slower): A few edge cases with very simple inputs (e.g., pure alphanumeric "abc123") or specific limit conditions show minor slowdowns, likely due to the overhead of the global regex flag on trivial inputs. However, these cases are still microsecond-level and the overall 7% runtime improvement across all test cases demonstrates net positive performance.

The optimization maintains identical functional behavior while providing consistent speed improvements for the common case of strings containing special characters that need replacement.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 97 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	93.5%

🌀 Click to see Generated Regression Tests

// @ts-nocheck
// imports
import { removeSpecialChars } from '../src/widgets/TableWidgetV2/widget/utilities';

// unit tests
describe('removeSpecialChars', () => {
    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should replace non-word separators with underscores for a common sentence', () => {
            // Commas, spaces and exclamation are non-word characters -> should become underscores.
            const input = "Hello, World!";
            const output = removeSpecialChars(input);
            // "Hello" and "World" are word sequences; trailing "!" produces a trailing empty segment -> trailing underscore
            expect(output).toBe("Hello_World_");  // 4.24μs -> 1.72μs (146% faster)
        });

        test('should convert hyphens and dots to underscores', () => {
            // "file-name.ext" -> ["file","name","ext"] -> "file_name_ext"
            const input = "file-name.ext";
            const output = removeSpecialChars(input);
            expect(output).toBe("file_name_ext");  // 2.15μs -> 975ns (121% faster)
        });

        test('should preserve underscores as they are word characters', () => {
            // underscores are part of \w so they should remain intact
            const input = "snake_case and-camelCase";
            const output = removeSpecialChars(input);
            expect(output).toBe("snake_case_and_camelCase");  // 1.74μs -> 815ns (113% faster)
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should return empty string when given empty input', () => {
            // Splitting an empty string and joining should result in an empty string
            const input = "";
            const output = removeSpecialChars(input);
            expect(output).toBe("");  // 1.53μs -> 749ns (104% faster)
        });

        test('should collapse only-special-character strings into a single underscore', () => {
            // Strings made entirely of non-word characters produce a single underscore (empty before and after)
            const input = "!!!@@@###";
            const output = removeSpecialChars(input);
            expect(output).toBe("_");  // 836ns -> 791ns (5.69% faster)
        });

        test('should handle leading and trailing separators producing leading/trailing underscores', () => {
            // Leading/trailing separators create empty segments at boundaries resulting in underscores at ends
            const input = "--start--end--";
            const output = removeSpecialChars(input);
            expect(output).toBe("_start_end_");  // 1.43μs -> 1.69μs (15.4% slower)
        });

        test('should respect a positive numeric limit by truncating the result', () => {
            // "abc---123" -> "abc_123" then slice(0,4) -> "abc_"
            const input = "abc---123";
            const output = removeSpecialChars(input, 4);
            expect(output).toBe("abc_");  // 2.01μs -> 1.60μs (26.0% faster)
        });

        test('should treat limit = 0 as falsy and fall back to default limit (30)', () => {
            // Create a string that would produce a result longer than 30 characters.
            const repeated = "word!".repeat(40); // produces "word_word_..._" (length > 30)
            // When limit is 0 the implementation uses (limit || 30) -> default 30
            const output = removeSpecialChars(repeated, 0);
            const expected = "word_".repeat(40).slice(0, 30);
            expect(output).toBe(expected);  // 3.10μs -> 3.18μs (2.42% slower)
        });

        test('should handle negative limit values by using slice with a negative end index', () => {
            // Input -> "abcd!efgh" -> ["abcd","efgh"] -> "abcd_efgh" (length 9)
            // limit = -2 -> slice(0, -2) -> length 7 -> "abcd_ef"
            const input = "abcd!efgh";
            const output = removeSpecialChars(input, -2);
            expect(output).toBe("abcd_ef");  // 836ns -> 750ns (11.5% faster)
        });

        test('should treat Unicode letters (outside \\w) as separators', () => {
            // 'é' is not in [A-Za-z0-9_] so it will act as a separator -> "caf_au_lait"
            const input = "café-au-lait";
            const output = removeSpecialChars(input);
            expect(output).toBe("caf_au_lait");
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle large inputs efficiently and produce expected truncated output', () => {
            // Construct a large input by repeating a known pattern (no loops used, repeat is fine)
            // Pattern: "alpha!" repeated N times -> after transformation becomes "alpha_" repeated N times
            const repeats = 200; // keeps data structures small while being reasonably large
            const input = "alpha!".repeat(repeats); // e.g., "alpha!alpha!alpha!...!"
            // Ask for a substantial limit to ensure slicing happens on a large string
            const limit = 500;
            const output = removeSpecialChars(input, limit);

            // Build expected directly from the known pattern: after transformation it should be "alpha_" repeated
            const fullExpected = "alpha_".repeat(repeats);
            const expected = fullExpected.slice(0, limit);
            expect(output).toBe(expected);  // 12.6μs -> 12.2μs (3.62% faster)

            // Also ensure the result length does not exceed the provided limit
            expect(output.length).toBeLessThanOrEqual(limit);
        });

        test('should behave consistently on large input without throwing and return reasonable length', () => {
            // Create another large input with mixed separators to ensure general scalability
            const chunk = "A!B@C#D$E%F^G&H*I(J)"; // multiple separators between letters
            const input = chunk.repeat(300); // sizable input, still under resource constraints
            // No explicit limit -> default 30 characters expected
            const output = removeSpecialChars(input);
            expect(typeof output).toBe("string");  // 134μs -> 142μs (5.42% slower)
            // Default length should be at most 30 (as per function default)
            expect(output.length).toBeLessThanOrEqual(30);
            // Ensure there are no disallowed characters: output should contain only word characters and underscores
            // Since \W were separators replaced by underscores, the result should match /^[A-Za-z0-9_]*$/
            expect(/^[A-Za-z0-9_]*$/.test(output)).toBe(true);
        });
    });
});

// @ts-nocheck
import { removeSpecialChars } from '../src/widgets/TableWidgetV2/widget/utilities';

describe('removeSpecialChars', () => {
    // Basic Test Cases
    describe('Basic functionality', () => {
        test('should remove special characters and replace with underscores', () => {
            const result = removeSpecialChars('hello-world!');
            expect(result).toBe('hello_world');
        });

        test('should handle simple alphanumeric strings', () => {
            const result = removeSpecialChars('abc123');
            expect(result).toBe('abc123');  // 1.50μs -> 2.01μs (25.5% slower)
        });

        test('should replace multiple special characters with single underscore', () => {
            const result = removeSpecialChars('hello!!!world');
            expect(result).toBe('hello_world');  // 1.44μs -> 864ns (66.4% faster)
        });

        test('should handle strings with spaces', () => {
            const result = removeSpecialChars('hello world test');
            expect(result).toBe('hello_world_test');  // 1.77μs -> 839ns (111% faster)
        });

        test('should handle strings with mixed special characters', () => {
            const result = removeSpecialChars('user@email.com');
            expect(result).toBe('user_email_com');  // 1.62μs -> 894ns (81.4% faster)
        });

        test('should handle underscores in input (they are alphanumeric)', () => {
            const result = removeSpecialChars('hello_world_test');
            expect(result).toBe('hello_world_test');  // 1.30μs -> 720ns (81.0% faster)
        });

        test('should handle numbers with special characters', () => {
            const result = removeSpecialChars('123-456-7890');
            expect(result).toBe('123_456_7890');  // 1.58μs -> 851ns (86.1% faster)
        });

        test('should respect explicit limit parameter', () => {
            const result = removeSpecialChars('hello-world-test', 10);
            expect(result).toBe('hello_worl');  // 1.59μs -> 868ns (82.7% faster)
        });

        test('should use default limit of 30 when not provided', () => {
            const input = 'a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-0-1-2-3-4-5';
            const result = removeSpecialChars(input);
            expect(result.length).toBeLessThanOrEqual(30);  // 3.70μs -> 4.34μs (14.8% slower)
        });
    });

    // Edge Test Cases
    describe('Edge cases', () => {
        test('should handle empty string', () => {
            const result = removeSpecialChars('');
            expect(result).toBe('');  // 1.29μs -> 1.35μs (4.95% slower)
        });

        test('should handle string with only special characters', () => {
            const result = removeSpecialChars('!@#$%^&*()');
            expect(result).toBe('_');  // 1.46μs -> 1.35μs (8.17% faster)
        });

        test('should handle string with only spaces', () => {
            const result = removeSpecialChars('   ');
            expect(result).toBe('_');  // 1.34μs -> 1.23μs (8.43% faster)
        });

        test('should handle string starting with special character', () => {
            const result = removeSpecialChars('!hello');
            expect(result).toBe('_hello');  // 1.47μs -> 1.39μs (5.47% faster)
        });

        test('should handle string ending with special character', () => {
            const result = removeSpecialChars('hello!');
            expect(result).toBe('hello_');  // 1.45μs -> 1.39μs (4.84% faster)
        });

        test('should handle consecutive special characters', () => {
            const result = removeSpecialChars('hello!!!###world');
            expect(result).toBe('hello_world');  // 1.52μs -> 1.39μs (9.53% faster)
        });

        test('should handle limit of 0', () => {
            const result = removeSpecialChars('hello-world', 0);
            expect(result).toBe('');
        });

        test('should handle limit of 1', () => {
            const result = removeSpecialChars('hello-world', 1);
            expect(result).toBe('h');  // 1.59μs -> 1.40μs (13.6% faster)
        });

        test('should handle very large limit value', () => {
            const input = 'hello-world';
            const result = removeSpecialChars(input, 1000);
            expect(result).toBe('hello_world');  // 1.63μs -> 1.39μs (17.1% faster)
        });

        test('should handle string with tabs and newlines', () => {
            const result = removeSpecialChars('hello\tworld\ntest');
            expect(result).toBe('hello_world_test');  // 1.71μs -> 1.56μs (9.68% faster)
        });

        test('should handle string with multiple consecutive underscores preserved', () => {
            const result = removeSpecialChars('hello__world');
            expect(result).toBe('hello__world');  // 1.41μs -> 1.26μs (12.1% faster)
        });

        test('should handle Unicode special characters', () => {
            const result = removeSpecialChars('hello©world™test');
            expect(result).toBe('hello_world_test');  // 1.71μs -> 1.60μs (7.01% faster)
        });

        test('should handle string with hyphens and dashes', () => {
            const result = removeSpecialChars('hello-world–test—sample');
            expect(result).toBe('hello_world_test_sample');  // 1.76μs -> 1.69μs (3.84% faster)
        });

        test('should handle single character input', () => {
            const result = removeSpecialChars('a');
            expect(result).toBe('a');  // 1.40μs -> 1.24μs (12.6% faster)
        });

        test('should handle single special character input', () => {
            const result = removeSpecialChars('!');
            expect(result).toBe('_');  // 1.48μs -> 1.24μs (19.6% faster)
        });

        test('should handle limit exactly matching string length', () => {
            const input = 'hello_world';
            const result = removeSpecialChars(input, 11);
            expect(result).toBe(input);  // 1.31μs -> 693ns (89.8% faster)
        });

        test('should handle negative limit gracefully', () => {
            const result = removeSpecialChars('hello-world', -5);
            expect(result).toBe('');
        });
    });

    // Large Scale Test Cases
    describe('Performance tests', () => {
        test('should handle long strings efficiently', () => {
            const longString = 'a-b-'.repeat(100).slice(0, -1);
            const result = removeSpecialChars(longString);
            expect(result).toBeDefined();  // 16.6μs -> 10.6μs (56.3% faster)
            expect(typeof result).toBe('string');
            expect(result.length).toBeLessThanOrEqual(30);
        });

        test('should handle string with many special characters', () => {
            const stringWithSpecialChars = 'a!@#$%^&*()b-c=+[]{}|;:"<>,./\\?~`';
            const result = removeSpecialChars(stringWithSpecialChars);
            expect(result).toBeDefined();  // 1.68μs -> 1.56μs (7.23% faster)
            expect(result.length).toBeLessThanOrEqual(30);
            expect(result).toContain('a');
        });

        test('should handle repeated pattern efficiently', () => {
            const repeatedPattern = 'word-'.repeat(250);
            const result = removeSpecialChars(repeatedPattern);
            expect(result).toBeDefined();  // 23.2μs -> 22.9μs (1.30% faster)
            expect(result.length).toBeLessThanOrEqual(30);
        });

        test('should process multiple large inputs correctly', () => {
            const largeInput = 'test-case-'.repeat(150);
            const results = [];
            
            for (let i = 0; i < 50; i++) {
                results.push(removeSpecialChars(largeInput));
            }
            
            expect(results.length).toBe(50);  // 13.6μs -> 14.1μs (3.68% slower)
            expect(results.every(r => typeof r === 'string')).toBe(true);
            expect(results.every(r => r.length <= 30)).toBe(true);
        });

        test('should maintain performance with varying limit values', () => {
            const input = 'hello-world-test-'.repeat(100);
            const limits = [5, 10, 20, 30, 50, 100];
            
            limits.forEach(limit => {
                const result = removeSpecialChars(input, limit);
                expect(result.length).toBeLessThanOrEqual(limit);  // 15.9μs -> 21.5μs (26.3% slower)
            });
        });

        test('should handle string with mixed ASCII and numbers at scale', () => {
            const mixedInput = 'abc123!@#def456$%^'.repeat(80);
            const result = removeSpecialChars(mixedInput);
            expect(result).toBeDefined();  // 16.5μs -> 10.9μs (51.3% faster)
            expect(result.length).toBeLessThanOrEqual(30);
        });

        test('should handle maximum reasonable input size', () => {
            const maxInput = 'a-'.repeat(500);
            const startTime = performance.now();
            const result = removeSpecialChars(maxInput);
            const endTime = performance.now();
            
            expect(result).toBeDefined();  // 36.4μs -> 25.0μs (45.6% faster)
            expect(result.length).toBeLessThanOrEqual(30);
            expect(endTime - startTime).toBeLessThan(100); // Should complete in less than 100ms
        });

        test('should maintain correctness with large limit values', () => {
            const input = 'hello-world';
            const result = removeSpecialChars(input, 500);
            expect(result).toBe('hello_world');  // 1.59μs -> 737ns (116% faster)
            expect(result.length).toBe(11);
        });
    });
});

📊 Performance Profile

View detailed line-by-line performance analysis
To edit these changes git checkout codeflash/optimize-removeSpecialChars-ml260qlu and push.